summaryrefslogtreecommitdiff
path: root/src
diff options
context:
space:
mode:
authorpaul <nintendo6496@googlemail.com>2018-10-06 17:51:44 +0200
committerpaul <nintendo6496@googlemail.com>2018-10-06 17:51:44 +0200
commit0aa555d13499fb5f446b5c42d3d7c5166225edc4 (patch)
tree7a73f77a735323c7967cc80d056b070b2fd687c7 /src
parentefebe909c604beff57c7e2481a0de83dfe084d21 (diff)
parent2cb551cf0df29e2602d6a80c16f8bac0a136b134 (diff)
Merge remote-tracking branch 'upstream/master'
Diffstat (limited to 'src')
-rw-r--r--src/battle_ai_script_commands.c2234
-rw-r--r--src/m4a_2.c8
-rw-r--r--src/script.c554
-rw-r--r--src/sound.c628
-rw-r--r--src/task.c219
-rw-r--r--src/text.c8
6 files changed, 3643 insertions, 8 deletions
diff --git a/src/battle_ai_script_commands.c b/src/battle_ai_script_commands.c
new file mode 100644
index 000000000..22ed95040
--- /dev/null
+++ b/src/battle_ai_script_commands.c
@@ -0,0 +1,2234 @@
+#include "global.h"
+#include "battle.h"
+#include "item.h"
+#include "pokemon.h"
+#include "constants/species.h"
+#include "constants/abilities.h"
+#include "constants/battle_ai.h"
+#include "constants/battle_move_effects.h"
+
+extern u16 Random(void);
+extern void sub_80C7164(void);
+
+#define AI_ACTION_DONE 0x0001
+#define AI_ACTION_FLEE 0x0002
+#define AI_ACTION_WATCH 0x0004
+#define AI_ACTION_DO_NOT_ATTACK 0x0008
+#define AI_ACTION_UNK5 0x0010
+#define AI_ACTION_UNK6 0x0020
+#define AI_ACTION_UNK7 0x0040
+#define AI_ACTION_UNK8 0x0080
+
+#define AI_THINKING_STRUCT ((struct AI_ThinkingStruct *)(gBattleResources->ai))
+#define BATTLE_HISTORY ((struct BattleHistory *)(gBattleResources->battleHistory))
+
+// AI states
+enum
+{
+ AIState_SettingUp,
+ AIState_Processing,
+ AIState_FinishedProcessing,
+ AIState_DoNotProcess
+};
+
+extern const u8 *gAIScriptPtr;
+extern u8 *BattleAIs[];
+extern u16 gLastUsedMove[];
+
+static void BattleAICmd_if_random_less_than(void);
+static void BattleAICmd_if_random_greater_than(void);
+static void BattleAICmd_if_random_equal(void);
+static void BattleAICmd_if_random_not_equal(void);
+static void BattleAICmd_score(void);
+static void BattleAICmd_if_hp_less_than(void);
+static void BattleAICmd_if_hp_more_than(void);
+static void BattleAICmd_if_hp_equal(void);
+static void BattleAICmd_if_hp_not_equal(void);
+static void BattleAICmd_if_status(void);
+static void BattleAICmd_if_not_status(void);
+static void BattleAICmd_if_status2(void);
+static void BattleAICmd_if_not_status2(void);
+static void BattleAICmd_if_status3(void);
+static void BattleAICmd_if_not_status3(void);
+static void BattleAICmd_if_status4(void);
+static void BattleAICmd_if_not_status4(void);
+static void BattleAICmd_if_less_than(void);
+static void BattleAICmd_if_more_than(void);
+static void BattleAICmd_if_equal(void);
+static void BattleAICmd_if_not_equal(void);
+static void BattleAICmd_if_less_than_32(void);
+static void BattleAICmd_if_more_than_32(void);
+static void BattleAICmd_if_equal_32(void);
+static void BattleAICmd_if_not_equal_32(void);
+static void BattleAICmd_if_move(void);
+static void BattleAICmd_if_not_move(void);
+static void BattleAICmd_if_in_bytes(void);
+static void BattleAICmd_if_not_in_bytes(void);
+static void BattleAICmd_if_in_words(void);
+static void BattleAICmd_if_not_in_words(void);
+static void BattleAICmd_if_user_can_damage(void);
+static void BattleAICmd_if_user_cant_damage(void);
+static void BattleAICmd_get_turn_count(void);
+static void BattleAICmd_get_type(void);
+static void BattleAICmd_get_move_power(void);
+static void BattleAICmd_is_most_powerful_move(void);
+static void BattleAICmd_get_move(void);
+static void BattleAICmd_if_arg_equal(void);
+static void BattleAICmd_if_arg_not_equal(void);
+static void BattleAICmd_if_would_go_first(void);
+static void BattleAICmd_if_would_not_go_first(void);
+static void BattleAICmd_nullsub_2A(void);
+static void BattleAICmd_nullsub_2B(void);
+static void BattleAICmd_count_alive_pokemon(void);
+static void BattleAICmd_get_considered_move(void);
+static void BattleAICmd_get_considered_move_effect(void);
+static void BattleAICmd_get_ability(void);
+static void BattleAICmd_get_highest_possible_damage(void);
+static void BattleAICmd_if_type_effectiveness(void);
+static void BattleAICmd_nullsub_32(void);
+static void BattleAICmd_nullsub_33(void);
+static void BattleAICmd_if_status_in_party(void);
+static void BattleAICmd_if_status_not_in_party(void);
+static void BattleAICmd_get_weather(void);
+static void BattleAICmd_if_effect(void);
+static void BattleAICmd_if_not_effect(void);
+static void BattleAICmd_if_stat_level_less_than(void);
+static void BattleAICmd_if_stat_level_more_than(void);
+static void BattleAICmd_if_stat_level_equal(void);
+static void BattleAICmd_if_stat_level_not_equal(void);
+static void BattleAICmd_if_can_faint(void);
+static void BattleAICmd_if_cant_faint(void);
+static void BattleAICmd_if_has_move(void);
+static void BattleAICmd_if_dont_have_move(void);
+static void BattleAICmd_if_move_effect(void);
+static void BattleAICmd_if_not_move_effect(void);
+static void BattleAICmd_if_last_move_did_damage(void);
+static void BattleAICmd_if_encored(void);
+static void BattleAICmd_flee(void);
+static void BattleAICmd_frlg_safari(void);
+static void BattleAICmd_watch(void);
+static void BattleAICmd_get_hold_effect(void);
+static void BattleAICmd_get_gender(void);
+static void BattleAICmd_is_first_turn(void);
+static void BattleAICmd_get_stockpile_count(void);
+static void BattleAICmd_is_double_battle(void);
+static void BattleAICmd_get_used_held_item(void);
+static void BattleAICmd_get_move_type_from_result(void);
+static void BattleAICmd_get_move_power_from_result(void);
+static void BattleAICmd_get_move_effect_from_result(void);
+static void BattleAICmd_get_protect_count(void);
+static void BattleAICmd_nullsub_52(void);
+static void BattleAICmd_nullsub_53(void);
+static void BattleAICmd_nullsub_54(void);
+static void BattleAICmd_nullsub_55(void);
+static void BattleAICmd_nullsub_56(void);
+static void BattleAICmd_nullsub_57(void);
+static void BattleAICmd_call(void);
+static void BattleAICmd_jump(void);
+static void BattleAICmd_end(void);
+static void BattleAICmd_if_level_compare(void);
+static void BattleAICmd_if_taunted(void);
+static void BattleAICmd_if_not_taunted(void);
+
+typedef void (*BattleAICmdFunc)(void);
+
+static const BattleAICmdFunc sBattleAICmdTable[] =
+{
+ BattleAICmd_if_random_less_than, // 0x0
+ BattleAICmd_if_random_greater_than, // 0x1
+ BattleAICmd_if_random_equal, // 0x2
+ BattleAICmd_if_random_not_equal, // 0x3
+ BattleAICmd_score, // 0x4
+ BattleAICmd_if_hp_less_than, // 0x5
+ BattleAICmd_if_hp_more_than, // 0x6
+ BattleAICmd_if_hp_equal, // 0x7
+ BattleAICmd_if_hp_not_equal, // 0x8
+ BattleAICmd_if_status, // 0x9
+ BattleAICmd_if_not_status, // 0xA
+ BattleAICmd_if_status2, // 0xB
+ BattleAICmd_if_not_status2, // 0xC
+ BattleAICmd_if_status3, // 0xD
+ BattleAICmd_if_not_status3, // 0xE
+ BattleAICmd_if_status4, // 0xF
+ BattleAICmd_if_not_status4, // 0x10
+ BattleAICmd_if_less_than, // 0x11
+ BattleAICmd_if_more_than, // 0x12
+ BattleAICmd_if_equal, // 0x13
+ BattleAICmd_if_not_equal, // 0x14
+ BattleAICmd_if_less_than_32, // 0x15
+ BattleAICmd_if_more_than_32, // 0x16
+ BattleAICmd_if_equal_32, // 0x17
+ BattleAICmd_if_not_equal_32, // 0x18
+ BattleAICmd_if_move, // 0x19
+ BattleAICmd_if_not_move, // 0x1A
+ BattleAICmd_if_in_bytes, // 0x1B
+ BattleAICmd_if_not_in_bytes, // 0x1C
+ BattleAICmd_if_in_words, // 0x1D
+ BattleAICmd_if_not_in_words, // 0x1E
+ BattleAICmd_if_user_can_damage, // 0x1F
+ BattleAICmd_if_user_cant_damage, // 0x20
+ BattleAICmd_get_turn_count, // 0x21
+ BattleAICmd_get_type, // 0x22
+ BattleAICmd_get_move_power, // 0x23
+ BattleAICmd_is_most_powerful_move, // 0x24
+ BattleAICmd_get_move, // 0x25
+ BattleAICmd_if_arg_equal, // 0x26
+ BattleAICmd_if_arg_not_equal, // 0x27
+ BattleAICmd_if_would_go_first, // 0x28
+ BattleAICmd_if_would_not_go_first, // 0x29
+ BattleAICmd_nullsub_2A, // 0x2A
+ BattleAICmd_nullsub_2B, // 0x2B
+ BattleAICmd_count_alive_pokemon, // 0x2C
+ BattleAICmd_get_considered_move, // 0x2D
+ BattleAICmd_get_considered_move_effect, // 0x2E
+ BattleAICmd_get_ability, // 0x2F
+ BattleAICmd_get_highest_possible_damage, // 0x30
+ BattleAICmd_if_type_effectiveness, // 0x31
+ BattleAICmd_nullsub_32, // 0x32
+ BattleAICmd_nullsub_33, // 0x33
+ BattleAICmd_if_status_in_party, // 0x34
+ BattleAICmd_if_status_not_in_party, // 0x35
+ BattleAICmd_get_weather, // 0x36
+ BattleAICmd_if_effect, // 0x37
+ BattleAICmd_if_not_effect, // 0x38
+ BattleAICmd_if_stat_level_less_than, // 0x39
+ BattleAICmd_if_stat_level_more_than, // 0x3A
+ BattleAICmd_if_stat_level_equal, // 0x3B
+ BattleAICmd_if_stat_level_not_equal, // 0x3C
+ BattleAICmd_if_can_faint, // 0x3D
+ BattleAICmd_if_cant_faint, // 0x3E
+ BattleAICmd_if_has_move, // 0x3F
+ BattleAICmd_if_dont_have_move, // 0x40
+ BattleAICmd_if_move_effect, // 0x41
+ BattleAICmd_if_not_move_effect, // 0x42
+ BattleAICmd_if_last_move_did_damage, // 0x43
+ BattleAICmd_if_encored, // 0x44
+ BattleAICmd_flee, // 0x45
+ BattleAICmd_frlg_safari, // 0x46
+ BattleAICmd_watch, // 0x47
+ BattleAICmd_get_hold_effect, // 0x48
+ BattleAICmd_get_gender, // 0x49
+ BattleAICmd_is_first_turn, // 0x4A
+ BattleAICmd_get_stockpile_count, // 0x4B
+ BattleAICmd_is_double_battle, // 0x4C
+ BattleAICmd_get_used_held_item, // 0x4D
+ BattleAICmd_get_move_type_from_result, // 0x4E
+ BattleAICmd_get_move_power_from_result, // 0x4F
+ BattleAICmd_get_move_effect_from_result, // 0x50
+ BattleAICmd_get_protect_count, // 0x51
+ BattleAICmd_nullsub_52, // 0x52
+ BattleAICmd_nullsub_53, // 0x53
+ BattleAICmd_nullsub_54, // 0x54
+ BattleAICmd_nullsub_55, // 0x55
+ BattleAICmd_nullsub_56, // 0x56
+ BattleAICmd_nullsub_57, // 0x57
+ BattleAICmd_call, // 0x58
+ BattleAICmd_jump, // 0x59
+ BattleAICmd_end, // 0x5A
+ BattleAICmd_if_level_compare, // 0x5B
+ BattleAICmd_if_taunted, // 0x5C
+ BattleAICmd_if_not_taunted, // 0x5D
+};
+
+#ifdef NONMATCHING
+static
+#endif
+const u16 sDiscouragedPowerfulMoveEffects[] =
+{
+ EFFECT_EXPLOSION,
+ EFFECT_DREAM_EATER,
+ EFFECT_RAZOR_WIND,
+ EFFECT_SKY_ATTACK,
+ EFFECT_RECHARGE,
+ EFFECT_SKULL_BASH,
+ EFFECT_SOLARBEAM,
+ EFFECT_SPIT_UP,
+ EFFECT_FOCUS_PUNCH,
+ EFFECT_SUPERPOWER,
+ EFFECT_ERUPTION,
+ EFFECT_OVERHEAT,
+ 0xFFFF
+};
+
+// TODO: move these
+extern u8 sBattler_AI;
+extern const u32 gBitTable[]; // util.h
+extern u32 gStatuses3[]; // battle_2.h
+extern u16 gSideAffecting[2];
+extern const struct BattleMove gBattleMoves[];
+extern u16 gBattlerPartyIndexes[];
+extern u16 gDynamicBasePower;
+extern u8 gMoveResultFlags;
+extern u8 gCritMultiplier;
+extern u16 gCurrentMove;
+extern s32 gBattleMoveDamage;
+
+void BattleAI_SetupAIData(void);
+void BattleAI_DoAIProcessing(void);
+void AIStackPushVar(const u8 *ptr);
+bool8 AIStackPop(void);
+
+void BattleAI_HandleItemUseBeforeAISetup(void)
+{
+ s32 i;
+ u8 *data = (u8 *)BATTLE_HISTORY;
+
+ for (i = 0; i < sizeof(struct BattleHistory); i++)
+ data[i] = 0;
+
+ // Items are allowed to use in ONLY trainer battles.
+ // TODO: Use proper flags
+ if ((gBattleTypeFlags & 0x8)
+ && (gTrainerBattleOpponent_A != 0x400)
+ && !(gBattleTypeFlags & 0x80982)
+ )
+ {
+ for (i = 0; i < 4; i++)
+ {
+ if (gTrainers[gTrainerBattleOpponent_A].items[i] != 0)
+ {
+ BATTLE_HISTORY->trainerItems[BATTLE_HISTORY->itemsNo] = gTrainers[gTrainerBattleOpponent_A].items[i];
+ BATTLE_HISTORY->itemsNo++;
+ }
+ }
+ }
+
+ BattleAI_SetupAIData();
+}
+
+void BattleAI_SetupAIData(void)
+{
+ s32 i;
+ u8 *data = (u8 *)AI_THINKING_STRUCT;
+ u8 moveLimitations;
+
+ // Clear AI data.
+ for (i = 0; i < sizeof(struct AI_ThinkingStruct); i++)
+ data[i] = 0;
+
+ for (i = 0; i < 4; i++)
+ AI_THINKING_STRUCT->score[i] = 100;
+
+ moveLimitations = CheckMoveLimitations(gActiveBattler, 0, 0xFF);
+
+ // Ignore moves that aren't possible to use.
+ for (i = 0; i < 4; i++)
+ {
+ if (gBitTable[i] & moveLimitations)
+ AI_THINKING_STRUCT->score[i] = 0;
+
+ AI_THINKING_STRUCT->simulatedRNG[i] = 100 - (Random() % 16);
+ }
+
+ gBattleResources->AI_ScriptsStack->size = 0;
+ sBattler_AI = gActiveBattler;
+
+ // Decide a random target battlerId in doubles.
+ if (gBattleTypeFlags & BATTLE_TYPE_DOUBLE)
+ {
+ gBattlerTarget = (Random() & BIT_FLANK);
+
+ if (gAbsentBattlerFlags & gBitTable[gBattlerTarget])
+ gBattlerTarget ^= BIT_FLANK;
+ }
+ // There's only one choice in single battles.
+ else
+ {
+ gBattlerTarget = sBattler_AI ^ BIT_SIDE;
+ }
+
+ // Choose proper trainer ai scripts.
+ // Fire Red, why all the returns?!?
+ if (gBattleTypeFlags & BATTLE_TYPE_SAFARI) // _080C6E84
+ {
+ AI_THINKING_STRUCT->aiFlags = AI_SCRIPT_SAFARI;
+ return;
+ }
+ else if (gBattleTypeFlags & BATTLE_TYPE_ROAMER) // _080C6EAC
+ {
+ AI_THINKING_STRUCT->aiFlags = AI_SCRIPT_ROAMING;
+ return;
+ }
+ else if (!(gBattleTypeFlags & (0x80900)) && (gTrainerBattleOpponent_A != 0x400)) // _080C6ECC
+ {
+ if(gBattleTypeFlags & (0x80 << 10))
+ {
+ AI_THINKING_STRUCT->aiFlags = 1;
+ return;
+ }
+ else if(gBattleTypeFlags & (0x80 << 11))
+ {
+ AI_THINKING_STRUCT->aiFlags = 7;
+ return;
+ }
+ }
+ else
+ {
+ AI_THINKING_STRUCT->aiFlags = 7;
+ return;
+ }
+ AI_THINKING_STRUCT->aiFlags = gTrainers[gTrainerBattleOpponent_A].aiFlags;
+}
+
+u8 BattleAI_GetAIActionToUse(void)
+{
+ u8 currentMoveArray[MAX_MON_MOVES];
+ u8 consideredMoveArray[MAX_MON_MOVES];
+ u8 numOfBestMoves;
+ s32 i;
+
+ sub_80C7164();
+ while (AI_THINKING_STRUCT->aiFlags != 0)
+ {
+ if (AI_THINKING_STRUCT->aiFlags & 1)
+ {
+ AI_THINKING_STRUCT->aiState = AIState_SettingUp;
+ BattleAI_DoAIProcessing();
+ }
+ AI_THINKING_STRUCT->aiFlags >>= 1;
+ AI_THINKING_STRUCT->aiLogicId++;
+ AI_THINKING_STRUCT->movesetIndex = 0;
+ }
+
+ // special flee or watch cases for safari.
+ if (AI_THINKING_STRUCT->aiAction & (AI_ACTION_FLEE)) // flee
+ return 4;
+ if (AI_THINKING_STRUCT->aiAction & (AI_ACTION_WATCH)) // watch
+ return 5;
+
+ numOfBestMoves = 1;
+ currentMoveArray[0] = AI_THINKING_STRUCT->score[0];
+ consideredMoveArray[0] = 0;
+
+ for (i = 1; i < MAX_MON_MOVES; i++)
+ {
+ if (currentMoveArray[0] < AI_THINKING_STRUCT->score[i])
+ {
+ numOfBestMoves = 1;
+ currentMoveArray[0] = AI_THINKING_STRUCT->score[i];
+ consideredMoveArray[0] = i;
+ }
+ if (currentMoveArray[0] == AI_THINKING_STRUCT->score[i])
+ {
+ currentMoveArray[numOfBestMoves] = AI_THINKING_STRUCT->score[i];
+ consideredMoveArray[numOfBestMoves++] = i;
+ }
+ }
+
+ return consideredMoveArray[Random() % numOfBestMoves]; // break any ties that exist.
+}
+
+void BattleAI_DoAIProcessing(void)
+{
+ while (AI_THINKING_STRUCT->aiState != AIState_FinishedProcessing)
+ {
+ switch (AI_THINKING_STRUCT->aiState)
+ {
+ case AIState_DoNotProcess: //Needed to match.
+ break;
+ case AIState_SettingUp:
+ gAIScriptPtr = BattleAIs[AI_THINKING_STRUCT->aiLogicId]; // set the AI ptr.
+ if (gBattleMons[sBattler_AI].pp[AI_THINKING_STRUCT->movesetIndex] == 0)
+ {
+ AI_THINKING_STRUCT->moveConsidered = 0; // don't consider a move you have 0 PP for, idiot.
+ }
+ else
+ {
+ AI_THINKING_STRUCT->moveConsidered = gBattleMons[sBattler_AI].moves[AI_THINKING_STRUCT->movesetIndex];
+ }
+ AI_THINKING_STRUCT->aiState++;
+ break;
+ case AIState_Processing:
+ if (AI_THINKING_STRUCT->moveConsidered != 0)
+ sBattleAICmdTable[*gAIScriptPtr](); // run AI command.
+ else
+ {
+ AI_THINKING_STRUCT->score[AI_THINKING_STRUCT->movesetIndex] = 0; // definitely do not consider any move that has 0 PP.
+ AI_THINKING_STRUCT->aiAction |= AI_ACTION_DONE;
+ }
+ if (AI_THINKING_STRUCT->aiAction & AI_ACTION_DONE)
+ {
+ AI_THINKING_STRUCT->movesetIndex++;
+ if (AI_THINKING_STRUCT->movesetIndex < MAX_MON_MOVES && (AI_THINKING_STRUCT->aiAction & AI_ACTION_DO_NOT_ATTACK) == 0)
+ AI_THINKING_STRUCT->aiState = AIState_SettingUp; // as long as their are more moves to process, keep setting this to setup state.
+ else
+ AI_THINKING_STRUCT->aiState++; // done processing.
+ AI_THINKING_STRUCT->aiAction &= (AI_ACTION_FLEE | AI_ACTION_WATCH | AI_ACTION_DO_NOT_ATTACK |
+ AI_ACTION_UNK5 | AI_ACTION_UNK6 | AI_ACTION_UNK7 | AI_ACTION_UNK8); // disable AI_ACTION_DONE.
+ }
+ break;
+ }
+ }
+}
+
+void sub_80C7164(void)
+{
+ s32 i;
+
+ for (i = 0; i < 8; i++)
+ {
+ if (BATTLE_HISTORY->usedMoves[gBattlerTarget >> 1][i] == 0)
+ {
+ BATTLE_HISTORY->usedMoves[gBattlerTarget >> 1][i] = gLastUsedMove[gBattlerTarget];
+ return;
+ }
+ }
+}
+
+void sub_80C71A8(u8 a)
+{
+ s32 i;
+
+ for (i = 0; i < 8; i++)
+ BATTLE_HISTORY->usedMoves[a / 2][i] = 0;
+}
+
+void sub_80C71D0(u8 a, u8 b)
+{
+ if (GetBankSide(a) == 0)
+ BATTLE_HISTORY->abilities[GetBankIdentity(a) & 1] = b;
+}
+
+void sub_80C7208(u8 a, u8 b)
+{
+ if (GetBankSide(a) == 0)
+ BATTLE_HISTORY->itemEffects[GetBankIdentity(a) & 1] = b;
+}
+
+static void BattleAICmd_if_random_less_than(void)
+{
+ if (Random() % 256 < gAIScriptPtr[1])
+ gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 2);
+ else
+ gAIScriptPtr += 6;
+}
+
+static void BattleAICmd_if_random_greater_than(void)
+{
+ if (Random() % 256 > gAIScriptPtr[1])
+ gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 2);
+ else
+ gAIScriptPtr += 6;
+}
+
+static void BattleAICmd_if_random_equal(void)
+{
+ if (Random() % 256 == gAIScriptPtr[1])
+ gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 2);
+ else
+ gAIScriptPtr += 6;
+}
+
+static void BattleAICmd_if_random_not_equal(void)
+{
+ if (Random() % 256 != gAIScriptPtr[1])
+ gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 2);
+ else
+ gAIScriptPtr += 6;
+}
+
+static void BattleAICmd_score(void)
+{
+ AI_THINKING_STRUCT->score[AI_THINKING_STRUCT->movesetIndex] += gAIScriptPtr[1]; // add the result to the array of the move consider's score.
+
+ if (AI_THINKING_STRUCT->score[AI_THINKING_STRUCT->movesetIndex] < 0) // if the score is negative, flatten it to 0.
+ AI_THINKING_STRUCT->score[AI_THINKING_STRUCT->movesetIndex] = 0;
+
+ gAIScriptPtr += 2; // AI return.
+}
+
+enum {
+ TARGET,
+ USER
+};
+
+static void BattleAICmd_if_hp_less_than(void)
+{
+ u16 index;
+
+ if (gAIScriptPtr[1] == USER)
+ index = sBattler_AI;
+ else
+ index = gBattlerTarget;
+
+ if ((u32)(100 * gBattleMons[index].hp / gBattleMons[index].maxHP) < gAIScriptPtr[2])
+ gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 3);
+ else
+ gAIScriptPtr += 7;
+}
+
+static void BattleAICmd_if_hp_more_than(void)
+{
+ u16 index;
+
+ if (gAIScriptPtr[1] == USER)
+ index = sBattler_AI;
+ else
+ index = gBattlerTarget;
+
+ if ((u32)(100 * gBattleMons[index].hp / gBattleMons[index].maxHP) > gAIScriptPtr[2])
+ gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 3);
+ else
+ gAIScriptPtr += 7;
+}
+
+static void BattleAICmd_if_hp_equal(void)
+{
+ u16 index;
+
+ if (gAIScriptPtr[1] == USER)
+ index = sBattler_AI;
+ else
+ index = gBattlerTarget;
+
+ if ((u32)(100 * gBattleMons[index].hp / gBattleMons[index].maxHP) == gAIScriptPtr[2])
+ gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 3);
+ else
+ gAIScriptPtr += 7;
+}
+
+static void BattleAICmd_if_hp_not_equal(void)
+{
+ u16 index;
+
+ if (gAIScriptPtr[1] == USER)
+ index = sBattler_AI;
+ else
+ index = gBattlerTarget;
+
+ if ((u32)(100 * gBattleMons[index].hp / gBattleMons[index].maxHP) != gAIScriptPtr[2])
+ gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 3);
+ else
+ gAIScriptPtr += 7;
+}
+
+static void BattleAICmd_if_status(void)
+{
+ u16 index;
+ u32 arg;
+
+ if (gAIScriptPtr[1] == USER)
+ index = sBattler_AI;
+ else
+ index = gBattlerTarget;
+
+ arg = T1_READ_32(gAIScriptPtr + 2);
+
+ if ((gBattleMons[index].status1 & arg) != 0)
+ gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 6);
+ else
+ gAIScriptPtr += 10;
+}
+
+static void BattleAICmd_if_not_status(void)
+{
+ u16 index;
+ u32 arg;
+
+ if (gAIScriptPtr[1] == USER)
+ index = sBattler_AI;
+ else
+ index = gBattlerTarget;
+
+ arg = T1_READ_32(gAIScriptPtr + 2);
+
+ if ((gBattleMons[index].status1 & arg) == 0)
+ gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 6);
+ else
+ gAIScriptPtr += 10;
+}
+
+static void BattleAICmd_if_status2(void)
+{
+ u16 index;
+ u32 arg;
+
+ if (gAIScriptPtr[1] == USER)
+ index = sBattler_AI;
+ else
+ index = gBattlerTarget;
+
+ arg = T1_READ_32(gAIScriptPtr + 2);
+
+ if ((gBattleMons[index].status2 & arg) != 0)
+ gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 6);
+ else
+ gAIScriptPtr += 10;
+}
+
+static void BattleAICmd_if_not_status2(void)
+{
+ u16 index;
+ u32 arg;
+
+ if (gAIScriptPtr[1] == USER)
+ index = sBattler_AI;
+ else
+ index = gBattlerTarget;
+
+ arg = T1_READ_32(gAIScriptPtr + 2);
+
+ if ((gBattleMons[index].status2 & arg) == 0)
+ gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 6);
+ else
+ gAIScriptPtr += 10;
+}
+
+static void BattleAICmd_if_status3(void)
+{
+ u16 index;
+ u32 arg;
+
+ if (gAIScriptPtr[1] == USER)
+ index = sBattler_AI;
+ else
+ index = gBattlerTarget;
+
+ arg = T1_READ_32(gAIScriptPtr + 2);
+
+ if ((gStatuses3[index] & arg) != 0)
+ gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 6);
+ else
+ gAIScriptPtr += 10;
+}
+
+static void BattleAICmd_if_not_status3(void)
+{
+ u16 index;
+ u32 arg;
+
+ if (gAIScriptPtr[1] == USER)
+ index = sBattler_AI;
+ else
+ index = gBattlerTarget;
+
+ arg = T1_READ_32(gAIScriptPtr + 2);
+
+ if ((gStatuses3[index] & arg) == 0)
+ gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 6);
+ else
+ gAIScriptPtr += 10;
+}
+
+static void BattleAICmd_if_status4(void)
+{
+ u16 index;
+ u32 arg1, arg2;
+
+ if (gAIScriptPtr[1] == USER)
+ index = sBattler_AI;
+ else
+ index = gBattlerTarget;
+
+ arg1 = GetBankIdentity(index) & 1;
+ arg2 = T1_READ_32(gAIScriptPtr + 2);
+
+ if ((gSideAffecting[arg1] & arg2) != 0)
+ gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 6);
+ else
+ gAIScriptPtr += 10;
+}
+
+static void BattleAICmd_if_not_status4(void)
+{
+ u16 index;
+ u32 arg1, arg2;
+
+ if (gAIScriptPtr[1] == USER)
+ index = sBattler_AI;
+ else
+ index = gBattlerTarget;
+
+ arg1 = GetBankIdentity(index) & 1;
+ arg2 = T1_READ_32(gAIScriptPtr + 2);
+
+ if ((gSideAffecting[arg1] & arg2) == 0)
+ gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 6);
+ else
+ gAIScriptPtr += 10;
+}
+
+static void BattleAICmd_if_less_than(void)
+{
+ if (AI_THINKING_STRUCT->funcResult < gAIScriptPtr[1])
+ gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 2);
+ else
+ gAIScriptPtr += 6;
+}
+
+static void BattleAICmd_if_more_than(void)
+{
+ if (AI_THINKING_STRUCT->funcResult > gAIScriptPtr[1])
+ gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 2);
+ else
+ gAIScriptPtr += 6;
+}
+
+static void BattleAICmd_if_equal(void)
+{
+ if (AI_THINKING_STRUCT->funcResult == gAIScriptPtr[1])
+ gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 2);
+ else
+ gAIScriptPtr += 6;
+}
+
+static void BattleAICmd_if_not_equal(void)
+{
+ if (AI_THINKING_STRUCT->funcResult != gAIScriptPtr[1])
+ gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 2);
+ else
+ gAIScriptPtr += 6;
+}
+
+static void BattleAICmd_if_less_than_32(void)
+{
+ u8 *temp = T1_READ_PTR(gAIScriptPtr + 1);
+
+ if (AI_THINKING_STRUCT->funcResult < *temp)
+ gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 5);
+ else
+ gAIScriptPtr += 9;
+}
+
+static void BattleAICmd_if_more_than_32(void)
+{
+ u8 *temp = T1_READ_PTR(gAIScriptPtr + 1);
+
+ if (AI_THINKING_STRUCT->funcResult > *temp)
+ gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 5);
+ else
+ gAIScriptPtr += 9;
+}
+
+static void BattleAICmd_if_equal_32(void)
+{
+ u8 *temp = T1_READ_PTR(gAIScriptPtr + 1);
+
+ if (AI_THINKING_STRUCT->funcResult == *temp)
+ gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 5);
+ else
+ gAIScriptPtr += 9;
+}
+
+static void BattleAICmd_if_not_equal_32(void)
+{
+ u8 *temp = T1_READ_PTR(gAIScriptPtr + 1);
+
+ if (AI_THINKING_STRUCT->funcResult != *temp)
+ gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 5);
+ else
+ gAIScriptPtr += 9;
+}
+
+static void BattleAICmd_if_move(void)
+{
+ u16 move = T1_READ_16(gAIScriptPtr + 1);
+
+ if (AI_THINKING_STRUCT->moveConsidered == move)
+ gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 3);
+ else
+ gAIScriptPtr += 7;
+}
+
+static void BattleAICmd_if_not_move(void)
+{
+ u16 move = T1_READ_16(gAIScriptPtr + 1);
+
+ if (AI_THINKING_STRUCT->moveConsidered != move)
+ gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 3);
+ else
+ gAIScriptPtr += 7;
+}
+
+static void BattleAICmd_if_in_bytes(void)
+{
+ u8 *ptr = T1_READ_PTR(gAIScriptPtr + 1);
+
+ while (*ptr != 0xFF)
+ {
+ if (AI_THINKING_STRUCT->funcResult == *ptr)
+ {
+ gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 5);
+ return;
+ }
+ ptr++;
+ }
+ gAIScriptPtr += 9;
+}
+
+static void BattleAICmd_if_not_in_bytes(void)
+{
+ u8 *ptr = T1_READ_PTR(gAIScriptPtr + 1);
+
+ while (*ptr != 0xFF)
+ {
+ if (AI_THINKING_STRUCT->funcResult == *ptr)
+ {
+ gAIScriptPtr += 9;
+ return;
+ }
+ ptr++;
+ }
+ gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 5);
+}
+
+static void BattleAICmd_if_in_words(void)
+{
+ u16 *ptr = (u16 *)T1_READ_PTR(gAIScriptPtr + 1);
+
+ while (*ptr != 0xFFFF)
+ {
+ if (AI_THINKING_STRUCT->funcResult == *ptr)
+ {
+ gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 5);
+ return;
+ }
+ ptr++;
+ }
+ gAIScriptPtr += 9;
+}
+
+static void BattleAICmd_if_not_in_words(void)
+{
+ u16 *ptr = (u16 *)T1_READ_PTR(gAIScriptPtr + 1);
+
+ while (*ptr != 0xFFFF)
+ {
+ if (AI_THINKING_STRUCT->funcResult == *ptr)
+ {
+ gAIScriptPtr += 9;
+ return;
+ }
+ ptr++;
+ }
+ gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 5);
+}
+
+static void BattleAICmd_if_user_can_damage(void)
+{
+ s32 i;
+
+ for (i = 0; i < MAX_MON_MOVES; i++)
+ {
+ if (gBattleMons[sBattler_AI].moves[i] != 0
+ && gBattleMoves[gBattleMons[sBattler_AI].moves[i]].power != 0)
+ break;
+ }
+ if (i == MAX_MON_MOVES)
+ gAIScriptPtr += 5;
+ else
+ gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1);
+}
+
+static void BattleAICmd_if_user_cant_damage(void)
+{
+ s32 i;
+
+ for (i = 0; i < MAX_MON_MOVES; i++)
+ {
+ if (gBattleMons[sBattler_AI].moves[i] != 0
+ && gBattleMoves[gBattleMons[sBattler_AI].moves[i]].power != 0)
+ break;
+ }
+ if (i != MAX_MON_MOVES)
+ gAIScriptPtr += 5;
+ else
+ gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1);
+}
+
+static void BattleAICmd_get_turn_count(void)
+{
+ AI_THINKING_STRUCT->funcResult = gBattleResults.battleTurnCounter;
+ gAIScriptPtr += 1;
+}
+
+static void BattleAICmd_get_type(void)
+{
+ switch (gAIScriptPtr[1])
+ {
+ case 1: // player primary type
+ AI_THINKING_STRUCT->funcResult = gBattleMons[sBattler_AI].type1;
+ break;
+ case 0: // enemy primary type
+ AI_THINKING_STRUCT->funcResult = gBattleMons[gBattlerTarget].type1;
+ break;
+ case 3: // player secondary type
+ AI_THINKING_STRUCT->funcResult = gBattleMons[sBattler_AI].type2;
+ break;
+ case 2: // enemy secondary type
+ AI_THINKING_STRUCT->funcResult = gBattleMons[gBattlerTarget].type2;
+ break;
+ case 4: // type of move being pointed to
+ AI_THINKING_STRUCT->funcResult = gBattleMoves[AI_THINKING_STRUCT->moveConsidered].type;
+ break;
+ }
+ gAIScriptPtr += 2;
+}
+
+static void BattleAICmd_get_move_power(void)
+{
+ AI_THINKING_STRUCT->funcResult = gBattleMoves[AI_THINKING_STRUCT->moveConsidered].power;
+ gAIScriptPtr += 1;
+}
+
+// still a nonmatching
+#ifdef NONMATCHING
+static void BattleAICmd_is_most_powerful_move(void)
+{
+ int i, j;
+ s32 damages[MAX_MON_MOVES];
+
+ for (i = 0; sDiscouragedPowerfulMoveEffects[i] != 0xFFFF; i++)
+ if (gBattleMoves[AI_THINKING_STRUCT->moveConsidered].effect == sDiscouragedPowerfulMoveEffects[i])
+ break;
+
+ if (gBattleMoves[AI_THINKING_STRUCT->moveConsidered].power > 1
+ && sDiscouragedPowerfulMoveEffects[i] == 0xFFFF)
+ {
+ gDynamicBasePower = 0;
+ eDynamicMoveType = 0;
+ eDmgMultiplier = 1;
+ gMoveResultFlags = 0;
+ gCritMultiplier = 1;
+
+ for (i = 0; i < MAX_MON_MOVES; i++)
+ {
+ for (j = 0; sDiscouragedPowerfulMoveEffects[j] != 0xFFFF; j++)
+ { // _08108276
+ if (gBattleMoves[gBattleMons[gBankAttacker].moves[i]].effect == sDiscouragedPowerfulMoveEffects[j])
+ break;
+ }
+
+ // _081082BA
+ if (gBattleMons[gBankAttacker].moves[i]
+ && sDiscouragedPowerfulMoveEffects[j] == 0xFFFF
+ && gBattleMoves[gBattleMons[gBankAttacker].moves[i]].power > 1)
+ {
+ gCurrentMove = gBattleMons[gBankAttacker].moves[i];
+ AI_CalcDmg(gBankAttacker, gBankTarget);
+ TypeCalc(gCurrentMove, gBankAttacker, gBankTarget);
+ damages[i] = (gBattleMoveDamage * AI_THINKING_STRUCT->simulatedRNG[i]) / 100;
+
+ if (damages[i] == 0) // moves always do at least 1 damage.
+ damages[i] = 1;
+ }
+ else
+ {
+ damages[i] = 0;
+ }
+ }
+
+ for (i = 0; i < MAX_MON_MOVES; i++)
+ if (damages[i] > damages[AI_THINKING_STRUCT->movesetIndex])
+ break;
+
+ if (i == MAX_MON_MOVES)
+ AI_THINKING_STRUCT->funcResult = 2;
+ else
+ AI_THINKING_STRUCT->funcResult = 1;
+ }
+ else
+ {
+ AI_THINKING_STRUCT->funcResult = 0;
+ }
+
+ gAIScriptPtr += 1;
+}
+#else
+NAKED
+static void BattleAICmd_is_most_powerful_move(void)
+{
+ asm(".syntax unified\n\
+ push {r4-r7,lr}\n\
+ mov r7, r10\n\
+ mov r6, r9\n\
+ mov r5, r8\n\
+ push {r5-r7}\n\
+ sub sp, 0x14\n\
+ movs r3, 0\n\
+ ldr r0, _080C80A4 @ =sDiscouragedPowerfulMoveEffects\n\
+ ldrh r1, [r0]\n\
+ ldr r5, _080C80A8 @ =0x0000ffff\n\
+ ldr r6, _080C80AC @ =gBattleMoves\n\
+ ldr r2, _080C80B0 @ =gBattleResources\n\
+ cmp r1, r5\n\
+ beq _080C7FA2\n\
+ ldr r0, [r2]\n\
+ ldr r0, [r0, 0x14]\n\
+ ldrh r1, [r0, 0x2]\n\
+ lsls r0, r1, 1\n\
+ adds r0, r1\n\
+ lsls r0, 2\n\
+ adds r0, r6\n\
+ ldrb r4, [r0]\n\
+ ldr r1, _080C80A4 @ =sDiscouragedPowerfulMoveEffects\n\
+_080C7F92:\n\
+ ldrh r0, [r1]\n\
+ cmp r4, r0\n\
+ beq _080C7FA2\n\
+ adds r1, 0x2\n\
+ adds r3, 0x1\n\
+ ldrh r0, [r1]\n\
+ cmp r0, r5\n\
+ bne _080C7F92\n\
+_080C7FA2:\n\
+ ldr r0, [r2]\n\
+ ldr r0, [r0, 0x14]\n\
+ ldrh r1, [r0, 0x2]\n\
+ lsls r0, r1, 1\n\
+ adds r0, r1\n\
+ lsls r0, 2\n\
+ adds r0, r6\n\
+ ldrb r0, [r0, 0x1]\n\
+ cmp r0, 0x1\n\
+ bhi _080C7FB8\n\
+ b _080C8142\n\
+_080C7FB8:\n\
+ lsls r0, r3, 1\n\
+ ldr r1, _080C80A4 @ =sDiscouragedPowerfulMoveEffects\n\
+ adds r0, r1\n\
+ ldrh r3, [r0]\n\
+ ldr r0, _080C80A8 @ =0x0000ffff\n\
+ cmp r3, r0\n\
+ beq _080C7FC8\n\
+ b _080C8142\n\
+_080C7FC8:\n\
+ ldr r0, _080C80B4 @ =gDynamicBasePower\n\
+ movs r1, 0\n\
+ strh r1, [r0]\n\
+ ldr r0, _080C80B8 @ =gBattleStruct\n\
+ ldr r0, [r0]\n\
+ strb r1, [r0, 0x13]\n\
+ ldr r0, _080C80BC @ =gBattleScripting\n\
+ movs r2, 0x1\n\
+ strb r2, [r0, 0xE]\n\
+ ldr r0, _080C80C0 @ =gMoveResultFlags\n\
+ strb r1, [r0]\n\
+ ldr r0, _080C80C4 @ =gCritMultiplier\n\
+ strb r2, [r0]\n\
+ movs r6, 0\n\
+ mov r9, r3\n\
+ ldr r2, _080C80A4 @ =sDiscouragedPowerfulMoveEffects\n\
+ ldrh r2, [r2]\n\
+ str r2, [sp, 0x10]\n\
+_080C7FEC:\n\
+ movs r3, 0\n\
+ ldr r5, _080C80C8 @ =gBattleMons\n\
+ lsls r4, r6, 1\n\
+ ldr r7, _080C80CC @ =sBattler_AI\n\
+ lsls r0, r6, 2\n\
+ mov r8, r0\n\
+ adds r1, r6, 0x1\n\
+ mov r10, r1\n\
+ ldr r2, [sp, 0x10]\n\
+ cmp r2, r9\n\
+ beq _080C8030\n\
+ ldr r2, _080C80AC @ =gBattleMoves\n\
+ ldrb r1, [r7]\n\
+ movs r0, 0x58\n\
+ muls r0, r1\n\
+ adds r0, r4, r0\n\
+ adds r1, r5, 0\n\
+ adds r1, 0xC\n\
+ adds r0, r1\n\
+ ldrh r1, [r0]\n\
+ lsls r0, r1, 1\n\
+ adds r0, r1\n\
+ lsls r0, 2\n\
+ adds r0, r2\n\
+ ldrb r2, [r0]\n\
+ ldr r1, _080C80A4 @ =sDiscouragedPowerfulMoveEffects\n\
+_080C8020:\n\
+ ldrh r0, [r1]\n\
+ cmp r2, r0\n\
+ beq _080C8030\n\
+ adds r1, 0x2\n\
+ adds r3, 0x1\n\
+ ldrh r0, [r1]\n\
+ cmp r0, r9\n\
+ bne _080C8020\n\
+_080C8030:\n\
+ ldrb r1, [r7]\n\
+ movs r0, 0x58\n\
+ muls r0, r1\n\
+ adds r0, r4, r0\n\
+ adds r1, r5, 0\n\
+ adds r1, 0xC\n\
+ adds r1, r0, r1\n\
+ ldrh r0, [r1]\n\
+ cmp r0, 0\n\
+ beq _080C80DC\n\
+ lsls r0, r3, 1\n\
+ ldr r2, _080C80A4 @ =sDiscouragedPowerfulMoveEffects\n\
+ adds r0, r2\n\
+ ldrh r0, [r0]\n\
+ cmp r0, r9\n\
+ bne _080C80DC\n\
+ ldr r0, _080C80AC @ =gBattleMoves\n\
+ ldrh r2, [r1]\n\
+ lsls r1, r2, 1\n\
+ adds r1, r2\n\
+ lsls r1, 2\n\
+ adds r1, r0\n\
+ ldrb r0, [r1, 0x1]\n\
+ cmp r0, 0x1\n\
+ bls _080C80DC\n\
+ ldr r5, _080C80D0 @ =gCurrentMove\n\
+ strh r2, [r5]\n\
+ ldrb r0, [r7]\n\
+ ldr r4, _080C80D4 @ =gBattlerTarget\n\
+ ldrb r1, [r4]\n\
+ bl AI_CalcDmg\n\
+ ldrh r0, [r5]\n\
+ ldrb r1, [r7]\n\
+ ldrb r2, [r4]\n\
+ bl TypeCalc\n\
+ mov r4, sp\n\
+ add r4, r8\n\
+ ldr r2, _080C80D8 @ =gBattleMoveDamage\n\
+ ldr r0, _080C80B0 @ =gBattleResources\n\
+ ldr r0, [r0]\n\
+ ldr r0, [r0, 0x14]\n\
+ adds r0, 0x18\n\
+ adds r0, r6\n\
+ ldrb r1, [r0]\n\
+ ldr r0, [r2]\n\
+ muls r0, r1\n\
+ movs r1, 0x64\n\
+ bl __divsi3\n\
+ str r0, [r4]\n\
+ cmp r0, 0\n\
+ bne _080C80E4\n\
+ movs r0, 0x1\n\
+ str r0, [r4]\n\
+ b _080C80E4\n\
+ .align 2, 0\n\
+_080C80A4: .4byte sDiscouragedPowerfulMoveEffects\n\
+_080C80A8: .4byte 0x0000ffff\n\
+_080C80AC: .4byte gBattleMoves\n\
+_080C80B0: .4byte gBattleResources\n\
+_080C80B4: .4byte gDynamicBasePower\n\
+_080C80B8: .4byte gBattleStruct\n\
+_080C80BC: .4byte gBattleScripting\n\
+_080C80C0: .4byte gMoveResultFlags\n\
+_080C80C4: .4byte gCritMultiplier\n\
+_080C80C8: .4byte gBattleMons\n\
+_080C80CC: .4byte sBattler_AI\n\
+_080C80D0: .4byte gCurrentMove\n\
+_080C80D4: .4byte gBattlerTarget\n\
+_080C80D8: .4byte gBattleMoveDamage\n\
+_080C80DC:\n\
+ mov r1, sp\n\
+ add r1, r8\n\
+ movs r0, 0\n\
+ str r0, [r1]\n\
+_080C80E4:\n\
+ mov r6, r10\n\
+ cmp r6, 0x3\n\
+ bgt _080C80EC\n\
+ b _080C7FEC\n\
+_080C80EC:\n\
+ movs r6, 0\n\
+ ldr r2, _080C8130 @ =gBattleResources\n\
+ ldr r0, [r2]\n\
+ ldr r0, [r0, 0x14]\n\
+ ldrb r0, [r0, 0x1]\n\
+ lsls r0, 2\n\
+ add r0, sp\n\
+ ldr r1, [sp]\n\
+ ldr r0, [r0]\n\
+ ldr r5, _080C8134 @ =gAIScriptPtr\n\
+ cmp r1, r0\n\
+ bgt _080C8122\n\
+ adds r4, r2, 0\n\
+ mov r3, sp\n\
+_080C8108:\n\
+ adds r3, 0x4\n\
+ adds r6, 0x1\n\
+ cmp r6, 0x3\n\
+ bgt _080C8122\n\
+ ldr r0, [r4]\n\
+ ldr r0, [r0, 0x14]\n\
+ ldrb r0, [r0, 0x1]\n\
+ lsls r0, 2\n\
+ add r0, sp\n\
+ ldr r1, [r3]\n\
+ ldr r0, [r0]\n\
+ cmp r1, r0\n\
+ ble _080C8108\n\
+_080C8122:\n\
+ cmp r6, 0x4\n\
+ bne _080C8138\n\
+ ldr r0, [r2]\n\
+ ldr r1, [r0, 0x14]\n\
+ movs r0, 0x2\n\
+ str r0, [r1, 0x8]\n\
+ b _080C814C\n\
+ .align 2, 0\n\
+_080C8130: .4byte gBattleResources\n\
+_080C8134: .4byte gAIScriptPtr\n\
+_080C8138:\n\
+ ldr r0, [r2]\n\
+ ldr r1, [r0, 0x14]\n\
+ movs r0, 0x1\n\
+ str r0, [r1, 0x8]\n\
+ b _080C814C\n\
+_080C8142:\n\
+ ldr r0, [r2]\n\
+ ldr r1, [r0, 0x14]\n\
+ movs r0, 0\n\
+ str r0, [r1, 0x8]\n\
+ ldr r5, _080C8164 @ =gAIScriptPtr\n\
+_080C814C:\n\
+ ldr r0, [r5]\n\
+ adds r0, 0x1\n\
+ str r0, [r5]\n\
+ add sp, 0x14\n\
+ pop {r3-r5}\n\
+ mov r8, r3\n\
+ mov r9, r4\n\
+ mov r10, r5\n\
+ pop {r4-r7}\n\
+ pop {r0}\n\
+ bx r0\n\
+ .align 2, 0\n\
+_080C8164: .4byte gAIScriptPtr\n\
+ .syntax divided\n");
+}
+#endif
+
+static void BattleAICmd_get_move(void)
+{
+ if (gAIScriptPtr[1] == USER)
+ AI_THINKING_STRUCT->funcResult = gLastUsedMove[sBattler_AI];
+ else
+ AI_THINKING_STRUCT->funcResult = gLastUsedMove[gBattlerTarget];
+
+ gAIScriptPtr += 2;
+}
+
+static void BattleAICmd_if_arg_equal(void)
+{
+ if (gAIScriptPtr[1] == AI_THINKING_STRUCT->funcResult)
+ gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 2);
+ else
+ gAIScriptPtr += 6;
+}
+
+static void BattleAICmd_if_arg_not_equal(void)
+{
+ if (gAIScriptPtr[1] != AI_THINKING_STRUCT->funcResult)
+ gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 2);
+ else
+ gAIScriptPtr += 6;
+}
+
+static void BattleAICmd_if_would_go_first(void)
+{
+ if (GetWhoStrikesFirst(sBattler_AI, gBattlerTarget, TRUE) == gAIScriptPtr[1])
+ gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 2);
+ else
+ gAIScriptPtr += 6;
+}
+
+static void BattleAICmd_if_would_not_go_first(void)
+{
+ if (GetWhoStrikesFirst(sBattler_AI, gBattlerTarget, TRUE) != gAIScriptPtr[1])
+ gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 2);
+ else
+ gAIScriptPtr += 6;
+}
+
+static void BattleAICmd_nullsub_2A(void)
+{
+}
+
+static void BattleAICmd_nullsub_2B(void)
+{
+}
+
+static void BattleAICmd_count_alive_pokemon(void)
+{
+ struct Pokemon *party;
+ int i;
+ u8 index;
+ u8 var, var2;
+
+ AI_THINKING_STRUCT->funcResult = 0;
+
+ if (gAIScriptPtr[1] == USER)
+ index = sBattler_AI;
+ else
+ index = gBattlerTarget;
+
+ if (GetBankSide(index) == 0)
+ party = gPlayerParty;
+ else
+ party = gEnemyParty;
+
+ if (gBattleTypeFlags & BATTLE_TYPE_DOUBLE)
+ {
+ u32 status;
+ var = gBattlerPartyIndexes[index];
+ status = GetBankIdentity(index) ^ 2;
+ var2 = gBattlerPartyIndexes[GetBankByIdentity(status)];
+ }
+ else
+ {
+ var = gBattlerPartyIndexes[index];
+ var2 = gBattlerPartyIndexes[index];
+ }
+
+ for (i = 0; i < 6; i++)
+ {
+ if (i != var && i != var2
+ && GetMonData(&party[i], MON_DATA_HP) != 0
+ && GetMonData(&party[i], MON_DATA_SPECIES2) != SPECIES_NONE
+ && GetMonData(&party[i], MON_DATA_SPECIES2) != SPECIES_EGG)
+ {
+ AI_THINKING_STRUCT->funcResult++;
+ }
+ }
+
+ gAIScriptPtr += 2;
+}
+
+static void BattleAICmd_get_considered_move(void)
+{
+ AI_THINKING_STRUCT->funcResult = AI_THINKING_STRUCT->moveConsidered;
+ gAIScriptPtr += 1;
+}
+
+static void BattleAICmd_get_considered_move_effect(void)
+{
+ AI_THINKING_STRUCT->funcResult = gBattleMoves[AI_THINKING_STRUCT->moveConsidered].effect;
+ gAIScriptPtr += 1;
+}
+
+static void BattleAICmd_get_ability(void)
+{
+ u8 index;
+
+ if (gAIScriptPtr[1] == USER)
+ index = sBattler_AI;
+ else
+ index = gBattlerTarget;
+
+ if (GetBankSide(index) == TARGET)
+ {
+ u16 side = GetBankIdentity(index) & 1;
+
+ if (BATTLE_HISTORY->abilities[side] != 0)
+ {
+ AI_THINKING_STRUCT->funcResult = BATTLE_HISTORY->abilities[side];
+ gAIScriptPtr += 2;
+ return;
+ }
+
+ // abilities that prevent fleeing.
+ if (gBattleMons[index].ability == ABILITY_SHADOW_TAG
+ || gBattleMons[index].ability == ABILITY_MAGNET_PULL
+ || gBattleMons[index].ability == ABILITY_ARENA_TRAP)
+ {
+ AI_THINKING_STRUCT->funcResult = gBattleMons[index].ability;
+ gAIScriptPtr += 2;
+ return;
+ }
+
+ if (gBaseStats[gBattleMons[index].species].ability1 != ABILITY_NONE)
+ {
+ if (gBaseStats[gBattleMons[index].species].ability2 != ABILITY_NONE)
+ {
+ // AI has no knowledge of opponent, so it guesses which ability.
+ if (Random() % 2)
+ {
+ AI_THINKING_STRUCT->funcResult = gBaseStats[gBattleMons[index].species].ability1;
+ }
+ else
+ {
+ AI_THINKING_STRUCT->funcResult = gBaseStats[gBattleMons[index].species].ability2;
+ }
+ }
+ else
+ {
+ AI_THINKING_STRUCT->funcResult = gBaseStats[gBattleMons[index].species].ability1; // it's definitely ability 1.
+ }
+ }
+ else
+ {
+ AI_THINKING_STRUCT->funcResult = gBaseStats[gBattleMons[index].species].ability2; // AI cant actually reach this part since every mon has at least 1 ability.
+ }
+ }
+ else
+ {
+ // The AI knows its own ability.
+ AI_THINKING_STRUCT->funcResult = gBattleMons[index].ability;
+ }
+ gAIScriptPtr += 2;
+}
+
+static void BattleAICmd_get_highest_possible_damage(void)
+{
+ s32 i;
+ u8 *dynamicMoveType;
+
+ gDynamicBasePower = 0;
+ dynamicMoveType = &gBattleStruct->dynamicMoveType;
+ *dynamicMoveType = 0;
+ gBattleScripting.dmgMultiplier = 1;
+ gMoveResultFlags = 0;
+ gCritMultiplier = 1;
+ AI_THINKING_STRUCT->funcResult = 0;
+
+ for (i = 0; i < 4; i++)
+ {
+ gBattleMoveDamage = 40;
+ gCurrentMove = gBattleMons[sBattler_AI].moves[i];
+
+ if (gCurrentMove != 0)
+ {
+ TypeCalc(gCurrentMove, sBattler_AI, gBattlerTarget);
+
+ if (gBattleMoveDamage == 120) // Super effective STAB.
+ gBattleMoveDamage = AI_EFFECTIVENESS_x2;
+ if (gBattleMoveDamage == 240)
+ gBattleMoveDamage = AI_EFFECTIVENESS_x4;
+ if (gBattleMoveDamage == 30) // Not very effective STAB.
+ gBattleMoveDamage = AI_EFFECTIVENESS_x0_5;
+ if (gBattleMoveDamage == 15)
+ gBattleMoveDamage = AI_EFFECTIVENESS_x0_25;
+
+ if (gMoveResultFlags & MOVE_RESULT_DOESNT_AFFECT_FOE)
+ gBattleMoveDamage = AI_EFFECTIVENESS_x0;
+
+ if (AI_THINKING_STRUCT->funcResult < gBattleMoveDamage)
+ AI_THINKING_STRUCT->funcResult = gBattleMoveDamage;
+ }
+ }
+
+ gAIScriptPtr += 1;
+}
+
+static void BattleAICmd_if_type_effectiveness(void)
+{
+ u8 damageVar;
+
+ gDynamicBasePower = 0;
+ gBattleStruct->dynamicMoveType = 0;
+ gBattleScripting.dmgMultiplier = 1;
+ gMoveResultFlags = 0;
+ gCritMultiplier = 1;
+
+ gBattleMoveDamage = AI_EFFECTIVENESS_x1;
+ gCurrentMove = AI_THINKING_STRUCT->moveConsidered;
+
+ TypeCalc(gCurrentMove, sBattler_AI, gBattlerTarget);
+
+ if (gBattleMoveDamage == 120) // Super effective STAB.
+ gBattleMoveDamage = AI_EFFECTIVENESS_x2;
+ if (gBattleMoveDamage == 240)
+ gBattleMoveDamage = AI_EFFECTIVENESS_x4;
+ if (gBattleMoveDamage == 30) // Not very effective STAB.
+ gBattleMoveDamage = AI_EFFECTIVENESS_x0_5;
+ if (gBattleMoveDamage == 15)
+ gBattleMoveDamage = AI_EFFECTIVENESS_x0_25;
+
+ if (gMoveResultFlags & MOVE_RESULT_DOESNT_AFFECT_FOE)
+ gBattleMoveDamage = AI_EFFECTIVENESS_x0;
+
+ // Store gBattleMoveDamage in a u8 variable because gAIScriptPtr[1] is a u8.
+ damageVar = gBattleMoveDamage;
+
+ if (damageVar == gAIScriptPtr[1])
+ gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 2);
+ else
+ gAIScriptPtr += 6;
+}
+
+static void BattleAICmd_nullsub_32(void)
+{
+}
+
+static void BattleAICmd_nullsub_33(void)
+{
+}
+
+static void BattleAICmd_if_status_in_party(void)
+{
+ struct Pokemon *party;
+ struct Pokemon *partyPtr;
+ int i;
+ u32 statusToCompareTo;
+
+ // for whatever reason, game freak put the party pointer into 2 variables instead of 1. it's possible at some point the switch encompassed the whole function and used each respective variable creating largely duplicate code.
+ switch (gAIScriptPtr[1])
+ {
+ case 1:
+ party = partyPtr = gEnemyParty;
+ break;
+ default:
+ party = partyPtr = gPlayerParty;
+ break;
+ }
+
+ statusToCompareTo = T1_READ_32(gAIScriptPtr + 2);
+
+ for (i = 0; i < 6; i++)
+ {
+ u16 species = GetMonData(&party[i], MON_DATA_SPECIES);
+ u16 hp = GetMonData(&party[i], MON_DATA_HP);
+ u32 status = GetMonData(&party[i], MON_DATA_STATUS);
+
+ if (species != SPECIES_NONE && species != SPECIES_EGG && hp != 0 && status == statusToCompareTo)
+ {
+ gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 6); // WHAT. why is this being merged into the above switch
+ return;
+ }
+ }
+
+ gAIScriptPtr += 10;
+}
+
+// bugged, doesnt return properly. also unused
+static void BattleAICmd_if_status_not_in_party(void)
+{
+ struct Pokemon *party;
+ struct Pokemon *partyPtr;
+ int i;
+ u32 statusToCompareTo;
+
+ switch (gAIScriptPtr[1])
+ {
+ case 1:
+ party = partyPtr = gEnemyParty;
+ break;
+ default:
+ party = partyPtr = gPlayerParty;
+ break;
+ }
+
+ statusToCompareTo = T1_READ_32(gAIScriptPtr + 2);
+
+ for (i = 0; i < 6; i++)
+ {
+ u16 species = GetMonData(&party[i], MON_DATA_SPECIES);
+ u16 hp = GetMonData(&party[i], MON_DATA_HP);
+ u32 status = GetMonData(&party[i], MON_DATA_STATUS);
+
+ // everytime the status is found, the AI's logic jumps further and further past its intended destination. this results in a broken AI macro and is probably why it is unused.
+ if (species != SPECIES_NONE && species != SPECIES_EGG && hp != 0 && status == statusToCompareTo)
+ gAIScriptPtr += 10; // doesnt return?
+ }
+ gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 6);
+}
+
+enum
+{
+ WEATHER_TYPE_SUN,
+ WEATHER_TYPE_RAIN,
+ WEATHER_TYPE_SANDSTORM,
+ WEATHER_TYPE_HAIL,
+};
+
+extern u16 gBattleWeather;
+
+static void BattleAICmd_get_weather(void)
+{
+ if (gBattleWeather & WEATHER_RAIN_ANY)
+ AI_THINKING_STRUCT->funcResult = WEATHER_TYPE_RAIN;
+ if (gBattleWeather & WEATHER_SANDSTORM_ANY)
+ AI_THINKING_STRUCT->funcResult = WEATHER_TYPE_SANDSTORM;
+ if (gBattleWeather & WEATHER_SUN_ANY)
+ AI_THINKING_STRUCT->funcResult = WEATHER_TYPE_SUN;
+ if (gBattleWeather & WEATHER_HAIL)
+ AI_THINKING_STRUCT->funcResult = WEATHER_TYPE_HAIL;
+
+ gAIScriptPtr += 1;
+}
+
+static void BattleAICmd_if_effect(void)
+{
+ if (gBattleMoves[AI_THINKING_STRUCT->moveConsidered].effect == gAIScriptPtr[1])
+ gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 2);
+ else
+ gAIScriptPtr += 6;
+}
+
+static void BattleAICmd_if_not_effect(void)
+{
+ if (gBattleMoves[AI_THINKING_STRUCT->moveConsidered].effect != gAIScriptPtr[1])
+ gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 2);
+ else
+ gAIScriptPtr += 6;
+}
+
+static void BattleAICmd_if_stat_level_less_than(void)
+{
+ u32 party;
+
+ if (gAIScriptPtr[1] == USER)
+ party = sBattler_AI;
+ else
+ party = gBattlerTarget;
+
+ if (gBattleMons[party].statStages[gAIScriptPtr[2]] < gAIScriptPtr[3])
+ gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 4);
+ else
+ gAIScriptPtr += 8;
+}
+
+static void BattleAICmd_if_stat_level_more_than(void)
+{
+ u32 party;
+
+ if (gAIScriptPtr[1] == USER)
+ party = sBattler_AI;
+ else
+ party = gBattlerTarget;
+
+ if (gBattleMons[party].statStages[gAIScriptPtr[2]] > gAIScriptPtr[3])
+ gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 4);
+ else
+ gAIScriptPtr += 8;
+}
+
+static void BattleAICmd_if_stat_level_equal(void)
+{
+ u32 party;
+
+ if (gAIScriptPtr[1] == USER)
+ party = sBattler_AI;
+ else
+ party = gBattlerTarget;
+
+ if (gBattleMons[party].statStages[gAIScriptPtr[2]] == gAIScriptPtr[3])
+ gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 4);
+ else
+ gAIScriptPtr += 8;
+}
+
+static void BattleAICmd_if_stat_level_not_equal(void)
+{
+ u32 party;
+
+ if (gAIScriptPtr[1] == USER)
+ party = sBattler_AI;
+ else
+ party = gBattlerTarget;
+
+ if (gBattleMons[party].statStages[gAIScriptPtr[2]] != gAIScriptPtr[3])
+ gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 4);
+ else
+ gAIScriptPtr += 8;
+}
+
+static void BattleAICmd_if_can_faint(void)
+{
+ if (gBattleMoves[AI_THINKING_STRUCT->moveConsidered].power < 2)
+ {
+ gAIScriptPtr += 5;
+ return;
+ }
+
+ gDynamicBasePower = 0;
+ gBattleStruct->dynamicMoveType = 0;
+ gBattleScripting.dmgMultiplier = 1;
+ gMoveResultFlags = 0;
+ gCritMultiplier = 1;
+ gCurrentMove = AI_THINKING_STRUCT->moveConsidered;
+ AI_CalcDmg(sBattler_AI, gBattlerTarget);
+ TypeCalc(gCurrentMove, sBattler_AI, gBattlerTarget);
+
+ gBattleMoveDamage = gBattleMoveDamage * AI_THINKING_STRUCT->simulatedRNG[AI_THINKING_STRUCT->movesetIndex] / 100;
+
+ // Moves always do at least 1 damage.
+ if (gBattleMoveDamage == 0)
+ gBattleMoveDamage = 1;
+
+ if (gBattleMons[gBattlerTarget].hp <= gBattleMoveDamage)
+ gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1);
+ else
+ gAIScriptPtr += 5;
+}
+
+static void BattleAICmd_if_cant_faint(void)
+{
+ if (gBattleMoves[AI_THINKING_STRUCT->moveConsidered].power < 2)
+ {
+ gAIScriptPtr += 5;
+ return;
+ }
+
+ gDynamicBasePower = 0;
+ gBattleStruct->dynamicMoveType = 0;
+ gBattleScripting.dmgMultiplier = 1;
+ gMoveResultFlags = 0;
+ gCritMultiplier = 1;
+ gCurrentMove = AI_THINKING_STRUCT->moveConsidered;
+ AI_CalcDmg(sBattler_AI, gBattlerTarget);
+ TypeCalc(gCurrentMove, sBattler_AI, gBattlerTarget);
+
+ gBattleMoveDamage = gBattleMoveDamage * AI_THINKING_STRUCT->simulatedRNG[AI_THINKING_STRUCT->movesetIndex] / 100;
+
+ // This macro is missing the damage 0 = 1 assumption.
+
+ if (gBattleMons[gBattlerTarget].hp > gBattleMoveDamage)
+ gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1);
+ else
+ gAIScriptPtr += 5;
+}
+
+static void BattleAICmd_if_has_move(void)
+{
+ int i;
+ u16 *temp_ptr = (u16 *)(gAIScriptPtr + 2);
+
+ switch (gAIScriptPtr[1])
+ {
+ case 1:
+ case 3:
+ for (i = 0; i < MAX_MON_MOVES; i++)
+ {
+ if (gBattleMons[sBattler_AI].moves[i] == *temp_ptr)
+ break;
+ }
+ if (i == MAX_MON_MOVES)
+ gAIScriptPtr += 8;
+ else
+ gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 4);
+ break;
+ case 0:
+ case 2:
+ for (i = 0; i < 8; i++)
+ {
+ if (BATTLE_HISTORY->usedMoves[gBattlerTarget >> 1][i] == *temp_ptr)
+ break;
+ }
+ if (i == 8)
+ gAIScriptPtr += 8;
+ else
+ gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 4);
+ break;
+ }
+}
+
+static void BattleAICmd_if_dont_have_move(void)
+{
+ int i;
+ u16 *temp_ptr = (u16 *)(gAIScriptPtr + 2);
+
+ switch (gAIScriptPtr[1])
+ {
+ case 1:
+ case 3:
+ for (i = 0; i < MAX_MON_MOVES; i++)
+ {
+ if (gBattleMons[sBattler_AI].moves[i] == *temp_ptr)
+ break;
+ }
+ if (i != MAX_MON_MOVES)
+ gAIScriptPtr += 8;
+ else
+ gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 4);
+ break;
+ case 0:
+ case 2:
+ for (i = 0; i < 8; i++)
+ {
+ if (BATTLE_HISTORY->usedMoves[gBattlerTarget >> 1][i] == *temp_ptr)
+ break;
+ }
+ if (i != 8)
+ gAIScriptPtr += 8;
+ else
+ gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 4);
+ break;
+ }
+}
+
+static void BattleAICmd_if_move_effect(void)
+{
+ int i;
+
+ switch (gAIScriptPtr[1])
+ {
+ case 1:
+ case 3:
+ for (i = 0; i < MAX_MON_MOVES; i++)
+ {
+ if (gBattleMons[sBattler_AI].moves[i] != 0 && gBattleMoves[gBattleMons[sBattler_AI].moves[i]].effect == gAIScriptPtr[2])
+ break;
+ }
+ if (i != MAX_MON_MOVES)
+ gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 3);
+ else
+ gAIScriptPtr += 7;
+ break;
+ case 0:
+ case 2:
+ for (i = 0; i < 8; i++)
+ {
+ if (gBattleMons[sBattler_AI].moves[i] != 0 && gBattleMoves[BATTLE_HISTORY->usedMoves[gBattlerTarget >> 1][i]].effect == gAIScriptPtr[2])
+ break;
+ }
+ gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 3);
+ }
+}
+
+static void BattleAICmd_if_not_move_effect(void)
+{
+ int i;
+
+ switch (gAIScriptPtr[1])
+ {
+ case 1:
+ case 3:
+ for (i = 0; i < MAX_MON_MOVES; i++)
+ {
+ if (gBattleMons[sBattler_AI].moves[i] != 0 && gBattleMoves[gBattleMons[sBattler_AI].moves[i]].effect == gAIScriptPtr[2])
+ break;
+ }
+ if (i != MAX_MON_MOVES)
+ gAIScriptPtr += 7;
+ else
+ gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 3);
+ break;
+ case 0:
+ case 2:
+ for (i = 0; i < 8; i++)
+ {
+ if (BATTLE_HISTORY->usedMoves[gBattlerTarget >> 1][i] != 0 && gBattleMoves[BATTLE_HISTORY->usedMoves[gBattlerTarget >> 1][i]].effect == gAIScriptPtr[2])
+ break;
+ }
+ gAIScriptPtr += 7;
+ }
+}
+
+static void BattleAICmd_if_last_move_did_damage(void)
+{
+ u8 index;
+
+ if (gAIScriptPtr[1] == USER)
+ index = sBattler_AI;
+ else
+ index = gBattlerTarget;
+
+ if (gAIScriptPtr[2] == 0)
+ {
+ if (gDisableStructs[index].disabledMove == 0)
+ {
+ gAIScriptPtr += 7;
+ return;
+ }
+ gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 3);
+ return;
+ }
+ else if (gAIScriptPtr[2] != 1) // ignore the macro if its not 0 or 1.
+ {
+ gAIScriptPtr += 7;
+ return;
+ }
+ else if (gDisableStructs[index].encoredMove != 0)
+ {
+ gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 3);
+ return;
+ }
+ gAIScriptPtr += 7;
+}
+
+static void BattleAICmd_if_encored(void)
+{
+ switch (gAIScriptPtr[1])
+ {
+ case 0: // _08109348
+ if (gDisableStructs[gActiveBattler].disabledMove == AI_THINKING_STRUCT->moveConsidered)
+ {
+ gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 2);
+ return;
+ }
+ gAIScriptPtr += 6;
+ return;
+ case 1: // _08109370
+ if (gDisableStructs[gActiveBattler].encoredMove == AI_THINKING_STRUCT->moveConsidered)
+ {
+ gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 2);
+ return;
+ }
+ gAIScriptPtr += 6;
+ return;
+ default:
+ gAIScriptPtr += 6;
+ return;
+ }
+}
+
+static void BattleAICmd_flee(void)
+{
+ AI_THINKING_STRUCT->aiAction |= (AI_ACTION_DONE | AI_ACTION_FLEE | AI_ACTION_DO_NOT_ATTACK); // what matters is AI_ACTION_FLEE being enabled.
+}
+
+// FRLG safari command
+static void BattleAICmd_frlg_safari(void)
+{
+ u8 var;
+
+ if(gBattleStruct->safariGoNearCounter)
+ {
+ var = gBattleStruct->safariEscapeFactor * 2;
+ if(var > 20)
+ var = 20;
+ }
+ else if(gBattleStruct->safariPkblThrowCounter != 0) // _080C91DC
+ {
+ var = gBattleStruct->safariEscapeFactor / 4;
+ if(var == 0)
+ var = 1;
+ }
+ else
+ var = gBattleStruct->safariEscapeFactor;
+ var *= 5;
+ if((u8)(Random() % 100) < var)
+ gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1);
+ else
+ gAIScriptPtr += 5;
+}
+
+static void BattleAICmd_watch(void)
+{
+ AI_THINKING_STRUCT->aiAction |= (AI_ACTION_DONE | AI_ACTION_WATCH | AI_ACTION_DO_NOT_ATTACK); // what matters is AI_ACTION_WATCH being enabled.
+}
+
+static void BattleAICmd_get_hold_effect(void)
+{
+ u8 index;
+ u16 side;
+
+ if (gAIScriptPtr[1] == USER)
+ index = sBattler_AI;
+ else
+ index = gBattlerTarget;
+
+ if (GetBankSide(index) == 0)
+ {
+ side = (GetBankIdentity(index) & 1);
+ AI_THINKING_STRUCT->funcResult = BATTLE_HISTORY->itemEffects[side];
+ }
+ else
+ AI_THINKING_STRUCT->funcResult = ItemId_GetHoldEffect(gBattleMons[index].item);
+
+ gAIScriptPtr += 2;
+}
+
+static void BattleAICmd_get_gender(void)
+{
+ u8 index;
+
+ if (gAIScriptPtr[1] == USER)
+ index = sBattler_AI;
+ else
+ index = gBattlerTarget;
+
+ AI_THINKING_STRUCT->funcResult = GetGenderFromSpeciesAndPersonality(gBattleMons[index].species, gBattleMons[index].personality);
+
+ gAIScriptPtr += 2;
+}
+
+static void BattleAICmd_is_first_turn(void)
+{
+ u8 index;
+
+ if (gAIScriptPtr[1] == USER)
+ index = sBattler_AI;
+ else
+ index = gBattlerTarget;
+
+ AI_THINKING_STRUCT->funcResult = gDisableStructs[index].isFirstTurn;
+
+ gAIScriptPtr += 2;
+}
+
+static void BattleAICmd_get_stockpile_count(void)
+{
+ u8 index;
+
+ if (gAIScriptPtr[1] == USER)
+ index = sBattler_AI;
+ else
+ index = gBattlerTarget;
+
+ AI_THINKING_STRUCT->funcResult = gDisableStructs[index].stockpileCounter;
+
+ gAIScriptPtr += 2;
+}
+
+static void BattleAICmd_is_double_battle(void)
+{
+ AI_THINKING_STRUCT->funcResult = gBattleTypeFlags & BATTLE_TYPE_DOUBLE;
+
+ gAIScriptPtr += 1;
+}
+
+static void BattleAICmd_get_used_held_item(void)
+{
+ u8 battlerId;
+
+ if (gAIScriptPtr[1] == AI_USER)
+ battlerId = sBattler_AI;
+ else
+ battlerId = gBattlerTarget;
+
+ // This is likely a leftover from Ruby's code and its ugly ewram access.
+ #ifdef NONMATCHING
+ AI_THINKING_STRUCT->funcResult = gBattleStruct->usedHeldItems[battlerId];
+ #else
+ AI_THINKING_STRUCT->funcResult = *(u8*)((u8*)(gBattleStruct) + offsetof(struct BattleStruct, usedHeldItems) + (battlerId * 2));
+ #endif // NONMATCHING
+
+ gAIScriptPtr += 2;
+}
+
+static void BattleAICmd_get_move_type_from_result(void)
+{
+ AI_THINKING_STRUCT->funcResult = gBattleMoves[AI_THINKING_STRUCT->funcResult].type;
+
+ gAIScriptPtr += 1;
+}
+
+static void BattleAICmd_get_move_power_from_result(void)
+{
+ AI_THINKING_STRUCT->funcResult = gBattleMoves[AI_THINKING_STRUCT->funcResult].power;
+
+ gAIScriptPtr += 1;
+}
+
+static void BattleAICmd_get_move_effect_from_result(void)
+{
+ AI_THINKING_STRUCT->funcResult = gBattleMoves[AI_THINKING_STRUCT->funcResult].effect;
+
+ gAIScriptPtr += 1;
+}
+
+static void BattleAICmd_get_protect_count(void)
+{
+ u8 index;
+
+ if (gAIScriptPtr[1] == USER)
+ index = sBattler_AI;
+ else
+ index = gBattlerTarget;
+
+ AI_THINKING_STRUCT->funcResult = gDisableStructs[index].protectUses;
+
+ gAIScriptPtr += 2;
+}
+
+static void BattleAICmd_nullsub_52(void)
+{
+}
+
+static void BattleAICmd_nullsub_53(void)
+{
+}
+
+static void BattleAICmd_nullsub_54(void)
+{
+}
+
+static void BattleAICmd_nullsub_55(void)
+{
+}
+
+static void BattleAICmd_nullsub_56(void)
+{
+}
+
+static void BattleAICmd_nullsub_57(void)
+{
+}
+
+static void BattleAICmd_call(void)
+{
+ AIStackPushVar(gAIScriptPtr + 5);
+ gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1);
+}
+
+static void BattleAICmd_jump(void)
+{
+ gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1);
+}
+
+static void BattleAICmd_end(void)
+{
+ if (AIStackPop() == FALSE)
+ AI_THINKING_STRUCT->aiAction |= AI_ACTION_DONE;
+}
+
+static void BattleAICmd_if_level_compare(void)
+{
+ switch (gAIScriptPtr[1])
+ {
+ case 0: // greater than
+ if (gBattleMons[sBattler_AI].level > gBattleMons[gBattlerTarget].level)
+ {
+ gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 2);
+ return;
+ }
+ gAIScriptPtr += 6;
+ return;
+ case 1: // less than
+ if (gBattleMons[sBattler_AI].level < gBattleMons[gBattlerTarget].level)
+ {
+ gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 2);
+ return;
+ }
+ gAIScriptPtr += 6;
+ return;
+ case 2: // equal
+ if (gBattleMons[sBattler_AI].level == gBattleMons[gBattlerTarget].level)
+ {
+ gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 2);
+ return;
+ }
+ gAIScriptPtr += 6;
+ return;
+ }
+}
+
+static void BattleAICmd_if_taunted(void)
+{
+ if (gDisableStructs[gBattlerTarget].tauntTimer1 != 0)
+ gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1);
+ else
+ gAIScriptPtr += 5;
+}
+
+static void BattleAICmd_if_not_taunted(void)
+{
+ if (gDisableStructs[gBattlerTarget].tauntTimer1 == 0)
+ gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1);
+ else
+ gAIScriptPtr += 5;
+}
+
+void AIStackPushVar(const u8 *var)
+{
+ gBattleResources->AI_ScriptsStack->ptr[gBattleResources->AI_ScriptsStack->size++] = var;
+}
+
+// unused
+void AIStackPushVar_cursor(void)
+{
+ gBattleResources->AI_ScriptsStack->ptr[gBattleResources->AI_ScriptsStack->size++] = gAIScriptPtr;
+}
+
+bool8 AIStackPop(void)
+{
+ if (gBattleResources->AI_ScriptsStack->size != 0)
+ {
+ --gBattleResources->AI_ScriptsStack->size;
+ gAIScriptPtr = gBattleResources->AI_ScriptsStack->ptr[gBattleResources->AI_ScriptsStack->size];
+ return TRUE;
+ }
+ else
+ return FALSE;
+}
diff --git a/src/m4a_2.c b/src/m4a_2.c
index 2d3c65848..0625f05d1 100644
--- a/src/m4a_2.c
+++ b/src/m4a_2.c
@@ -11,10 +11,10 @@ void *gMPlayJumpTable[36];
struct CgbChannel gCgbChans[4];
struct MusicPlayerTrack gPokemonCryTracks[MAX_POKEMON_CRIES * 2];
struct PokemonCrySong gPokemonCrySong;
-struct MusicPlayerInfo gMPlay_BGM;
-struct MusicPlayerInfo gMPlay_SE1;
-struct MusicPlayerInfo gMPlay_SE2;
-struct MusicPlayerInfo gMPlay_SE3;
+struct MusicPlayerInfo gMPlayInfo_BGM;
+struct MusicPlayerInfo gMPlayInfo_SE1;
+struct MusicPlayerInfo gMPlayInfo_SE2;
+struct MusicPlayerInfo gMPlayInfo_SE3;
u8 gMPlayMemAccArea[0x10];
u32 MidiKeyToFreq(struct WaveData *wav, u8 key, u8 fineAdjust)
diff --git a/src/script.c b/src/script.c
new file mode 100644
index 000000000..0c74debb2
--- /dev/null
+++ b/src/script.c
@@ -0,0 +1,554 @@
+#include "global.h"
+#include "script.h"
+#include "event_data.h"
+
+#define RAM_SCRIPT_MAGIC 51
+#define SCRIPT_STACK_SIZE 20
+
+extern u8 gUnknown_203ADFA;
+
+extern void sub_80CBDE8(void); // field_specials
+extern u16 CalcCRC16WithTable(u8 *data, int length); // util
+extern bool32 sub_8143FC8(void); // mevent
+
+enum
+{
+ SCRIPT_MODE_STOPPED,
+ SCRIPT_MODE_BYTECODE,
+ SCRIPT_MODE_NATIVE,
+};
+
+EWRAM_DATA u8 gUnknown_20370A0 = 0;
+EWRAM_DATA u8 *gUnknown_20370A4 = NULL;
+
+// ewram bss
+IWRAM_DATA static u8 sScriptContext1Status;
+IWRAM_DATA static u32 sUnusedVariable1;
+IWRAM_DATA static struct ScriptContext sScriptContext1;
+IWRAM_DATA static u32 sUnusedVariable2;
+IWRAM_DATA static struct ScriptContext sScriptContext2;
+IWRAM_DATA static bool8 sScriptContext2Enabled;
+IWRAM_DATA static u8 gUnknown_3000F9D;
+IWRAM_DATA static u8 gUnknown_3000F9E;
+IWRAM_DATA static u8 gUnknown_3000F9F;
+IWRAM_DATA static u8 gUnknown_3000FA0;
+IWRAM_DATA static u8 gUnknown_3000FA1;
+
+extern ScrCmdFunc gScriptCmdTable[];
+extern ScrCmdFunc gScriptCmdTableEnd[];
+extern void *gNullScriptPtr;
+
+void InitScriptContext(struct ScriptContext *ctx, void *cmdTable, void *cmdTableEnd)
+{
+ s32 i;
+
+ ctx->mode = SCRIPT_MODE_STOPPED;
+ ctx->scriptPtr = NULL;
+ ctx->stackDepth = 0;
+ ctx->nativePtr = NULL;
+ ctx->cmdTable = cmdTable;
+ ctx->cmdTableEnd = cmdTableEnd;
+
+ for (i = 0; i < 4; i++)
+ ctx->data[i] = 0;
+
+ for (i = 0; i < SCRIPT_STACK_SIZE; i++)
+ ctx->stack[i] = 0;
+}
+
+u8 SetupBytecodeScript(struct ScriptContext *ctx, const u8 *ptr)
+{
+ ctx->scriptPtr = ptr;
+ ctx->mode = SCRIPT_MODE_BYTECODE;
+ return 1;
+}
+
+void SetupNativeScript(struct ScriptContext *ctx, bool8 (*ptr)(void))
+{
+ ctx->mode = SCRIPT_MODE_NATIVE;
+ ctx->nativePtr = ptr;
+}
+
+void StopScript(struct ScriptContext *ctx)
+{
+ ctx->mode = SCRIPT_MODE_STOPPED;
+ ctx->scriptPtr = NULL;
+}
+
+bool8 RunScriptCommand(struct ScriptContext *ctx)
+{
+ // FRLG disabled this check, where-as it is present
+ // in Ruby/Sapphire and Emerald. Why did the programmers
+ // bother to remove a redundant check when it still
+ // exists in Emerald?
+ //if (ctx->mode == SCRIPT_MODE_STOPPED)
+ // return FALSE;
+
+ switch (ctx->mode)
+ {
+ case SCRIPT_MODE_STOPPED:
+ return FALSE;
+ case SCRIPT_MODE_NATIVE:
+ if (ctx->nativePtr)
+ {
+ if (ctx->nativePtr() == TRUE)
+ ctx->mode = SCRIPT_MODE_BYTECODE;
+ return TRUE;
+ }
+ ctx->mode = SCRIPT_MODE_BYTECODE;
+ case SCRIPT_MODE_BYTECODE:
+ while (1)
+ {
+ u8 cmdCode;
+ ScrCmdFunc *cmdFunc;
+
+ if (ctx->scriptPtr == NULL)
+ {
+ ctx->mode = SCRIPT_MODE_STOPPED;
+ return FALSE;
+ }
+
+ if (ctx->scriptPtr == gNullScriptPtr)
+ {
+ while (1)
+ asm("svc 2"); // HALT
+ }
+
+ cmdCode = *(ctx->scriptPtr);
+ ctx->scriptPtr++;
+ cmdFunc = &ctx->cmdTable[cmdCode];
+
+ if (cmdFunc >= ctx->cmdTableEnd)
+ {
+ ctx->mode = SCRIPT_MODE_STOPPED;
+ return FALSE;
+ }
+
+ if ((*cmdFunc)(ctx) == TRUE)
+ return TRUE;
+ }
+ }
+
+ return TRUE;
+}
+
+u8 ScriptPush(struct ScriptContext *ctx, const u8 *ptr)
+{
+ if (ctx->stackDepth + 1 >= SCRIPT_STACK_SIZE)
+ {
+ return 1;
+ }
+ else
+ {
+ ctx->stack[ctx->stackDepth] = ptr;
+ ctx->stackDepth++;
+ return 0;
+ }
+}
+
+const u8 *ScriptPop(struct ScriptContext *ctx)
+{
+ if (ctx->stackDepth == 0)
+ return NULL;
+
+ ctx->stackDepth--;
+ return ctx->stack[ctx->stackDepth];
+}
+
+void ScriptJump(struct ScriptContext *ctx, const u8 *ptr)
+{
+ ctx->scriptPtr = ptr;
+}
+
+void ScriptCall(struct ScriptContext *ctx, const u8 *ptr)
+{
+ ScriptPush(ctx, ctx->scriptPtr);
+ ctx->scriptPtr = ptr;
+}
+
+void ScriptReturn(struct ScriptContext *ctx)
+{
+ ctx->scriptPtr = ScriptPop(ctx);
+}
+
+u16 ScriptReadHalfword(struct ScriptContext *ctx)
+{
+ u16 value = *(ctx->scriptPtr++);
+ value |= *(ctx->scriptPtr++) << 8;
+ return value;
+}
+
+u32 ScriptReadWord(struct ScriptContext *ctx)
+{
+ u32 value0 = *(ctx->scriptPtr++);
+ u32 value1 = *(ctx->scriptPtr++);
+ u32 value2 = *(ctx->scriptPtr++);
+ u32 value3 = *(ctx->scriptPtr++);
+ return (((((value3 << 8) + value2) << 8) + value1) << 8) + value0;
+}
+
+void ScriptContext2_Enable(void)
+{
+ sScriptContext2Enabled = TRUE;
+}
+
+void ScriptContext2_Disable(void)
+{
+ sScriptContext2Enabled = FALSE;
+}
+
+bool8 ScriptContext2_IsEnabled(void)
+{
+ return sScriptContext2Enabled;
+}
+
+void sub_8069964(void)
+{
+ gUnknown_3000FA0 = 1;
+}
+
+void sub_8069970(void)
+{
+ gUnknown_3000FA0 = 0;
+}
+
+bool8 sub_806997C(void)
+{
+ if(gUnknown_3000FA0 == TRUE)
+ return TRUE;
+ else
+ return FALSE;
+}
+
+void sub_8069998(u8 var)
+{
+ gUnknown_3000F9F = var;
+}
+
+void sub_80699A4(void)
+{
+ gUnknown_3000F9F = 0;
+}
+
+u8 sub_80699B0(void)
+{
+ return gUnknown_3000F9F;
+}
+
+void sub_80699BC(void)
+{
+ gUnknown_3000F9D = 1;
+}
+
+void sub_80699C8(void)
+{
+ gUnknown_3000F9D = 0;
+}
+
+u8 sub_80699D4(void)
+{
+ return gUnknown_3000F9D;
+}
+
+void sub_80699E0(void)
+{
+ gUnknown_20370A0 = 6;
+ gUnknown_3000F9E = 1;
+}
+
+void sub_80699F8(void)
+{
+ gUnknown_3000F9E = 0;
+}
+
+bool8 sub_8069A04(void)
+{
+ if(gUnknown_3000F9E == TRUE)
+ return TRUE;
+ else
+ return FALSE;
+}
+
+void sub_8069A20(void)
+{
+ gUnknown_3000FA1 = 1;
+}
+
+void sub_8069A2C(void)
+{
+ gUnknown_3000FA1 = 0;
+}
+
+bool8 sub_8069A38(void)
+{
+ if(gUnknown_3000FA1 == TRUE)
+ return TRUE;
+ else
+ return FALSE;
+}
+
+void sub_8069A54(void)
+{
+ sub_80CBDE8();
+ sub_8069A2C();
+}
+
+bool8 ScriptContext1_IsScriptSetUp(void)
+{
+ if (sScriptContext1Status == 0)
+ return TRUE;
+ else
+ return FALSE;
+}
+
+void ScriptContext1_Init(void)
+{
+ InitScriptContext(&sScriptContext1, gScriptCmdTable, gScriptCmdTableEnd);
+ sScriptContext1Status = 2;
+}
+
+bool8 ScriptContext2_RunScript(void)
+{
+ if (sScriptContext1Status == 2)
+ return 0;
+
+ if (sScriptContext1Status == 1)
+ return 0;
+
+ ScriptContext2_Enable();
+
+ if (!RunScriptCommand(&sScriptContext1))
+ {
+ sScriptContext1Status = 2;
+ ScriptContext2_Disable();
+ return 0;
+ }
+
+ return 1;
+}
+
+void ScriptContext1_SetupScript(const u8 *ptr)
+{
+ sub_80699F8();
+ sub_80699C8();
+ sub_8069970();
+ InitScriptContext(&sScriptContext1, gScriptCmdTable, gScriptCmdTableEnd);
+ SetupBytecodeScript(&sScriptContext1, ptr);
+ ScriptContext2_Enable();
+ sScriptContext1Status = 0;
+}
+
+void ScriptContext1_Stop(void)
+{
+ sScriptContext1Status = 1;
+}
+
+void EnableBothScriptContexts(void)
+{
+ sScriptContext1Status = 0;
+ ScriptContext2_Enable();
+}
+
+void ScriptContext2_RunNewScript(const u8 *ptr)
+{
+ InitScriptContext(&sScriptContext2, &gScriptCmdTable, &gScriptCmdTableEnd);
+ SetupBytecodeScript(&sScriptContext2, ptr);
+ while (RunScriptCommand(&sScriptContext2) == TRUE);
+}
+
+u8 *mapheader_get_tagged_pointer(u8 tag)
+{
+ u8 *mapScripts = gMapHeader.mapScripts;
+
+ if (mapScripts == NULL)
+ return NULL;
+
+ while (1)
+ {
+ if (*mapScripts == 0)
+ return NULL;
+ if (*mapScripts == tag)
+ {
+ mapScripts++;
+ return (u8 *)(mapScripts[0] + (mapScripts[1] << 8) + (mapScripts[2] << 16) + (mapScripts[3] << 24));
+ }
+ mapScripts += 5;
+ }
+}
+
+void mapheader_run_script_by_tag(u8 tag)
+{
+ u8 *ptr = mapheader_get_tagged_pointer(tag);
+ if (ptr)
+ ScriptContext2_RunNewScript(ptr);
+}
+
+u8 *mapheader_get_first_match_from_tagged_ptr_list(u8 tag)
+{
+ u8 *ptr = mapheader_get_tagged_pointer(tag);
+
+ if (!ptr)
+ return NULL;
+
+ while (1)
+ {
+ u16 varIndex1;
+ u16 varIndex2;
+ varIndex1 = ptr[0] | (ptr[1] << 8);
+ if (!varIndex1)
+ return NULL;
+ ptr += 2;
+ varIndex2 = ptr[0] | (ptr[1] << 8);
+ ptr += 2;
+ if (VarGet(varIndex1) == VarGet(varIndex2))
+ return (u8 *)(ptr[0] + (ptr[1] << 8) + (ptr[2] << 16) + (ptr[3] << 24));
+ ptr += 4;
+ }
+}
+
+void mapheader_run_script_with_tag_x1(void)
+{
+ mapheader_run_script_by_tag(1);
+}
+
+void mapheader_run_script_with_tag_x3(void)
+{
+ mapheader_run_script_by_tag(3);
+}
+
+void mapheader_run_script_with_tag_x5(void)
+{
+ mapheader_run_script_by_tag(5);
+}
+
+void mapheader_run_script_with_tag_x7(void)
+{
+ mapheader_run_script_by_tag(7);
+}
+
+void mapheader_run_script_with_tag_x6(void)
+{
+ mapheader_run_script_by_tag(6);
+}
+
+bool8 mapheader_run_first_tag2_script_list_match(void)
+{
+ u8 *ptr;
+
+ if(gUnknown_203ADFA == 3)
+ return 0;
+
+ ptr = mapheader_get_first_match_from_tagged_ptr_list(2);
+
+ if (!ptr)
+ return 0;
+
+ ScriptContext1_SetupScript(ptr);
+ return 1;
+}
+
+void mapheader_run_first_tag4_script_list_match(void)
+{
+ u8 *ptr = mapheader_get_first_match_from_tagged_ptr_list(4);
+ if (ptr)
+ ScriptContext2_RunNewScript(ptr);
+}
+
+u32 CalculateRamScriptChecksum(void)
+{
+ return CalcCRC16WithTable((u8*)(&gSaveBlock1Ptr->ramScript.data), sizeof(gSaveBlock1Ptr->ramScript.data));
+}
+
+void ClearRamScript(void)
+{
+ CpuFill32(0, &gSaveBlock1Ptr->ramScript, sizeof(struct RamScript));
+}
+
+bool8 InitRamScript(u8 *script, u16 scriptSize, u8 mapGroup, u8 mapNum, u8 objectId)
+{
+ struct RamScriptData *scriptData = &gSaveBlock1Ptr->ramScript.data;
+
+ ClearRamScript();
+
+ if (scriptSize > sizeof(scriptData->script))
+ return FALSE;
+
+ scriptData->magic = RAM_SCRIPT_MAGIC;
+ scriptData->mapGroup = mapGroup;
+ scriptData->mapNum = mapNum;
+ scriptData->objectId = objectId;
+ memcpy(scriptData->script, script, scriptSize);
+ gSaveBlock1Ptr->ramScript.checksum = CalculateRamScriptChecksum();
+ return TRUE;
+}
+
+u8 *GetRamScript(u8 objectId, u8 *script)
+{
+ struct RamScriptData *scriptData = &gSaveBlock1Ptr->ramScript.data;
+ gUnknown_20370A4 = NULL;
+ if (scriptData->magic != RAM_SCRIPT_MAGIC)
+ return script;
+ if (scriptData->mapGroup != gSaveBlock1Ptr->location.mapGroup)
+ return script;
+ if (scriptData->mapNum != gSaveBlock1Ptr->location.mapNum)
+ return script;
+ if (scriptData->objectId != objectId)
+ return script;
+ if (CalculateRamScriptChecksum() != gSaveBlock1Ptr->ramScript.checksum)
+ {
+ ClearRamScript();
+ return script;
+ }
+ else
+ {
+ gUnknown_20370A4 = script;
+ return scriptData->script;
+ }
+}
+
+bool32 sub_8069DFC(void)
+{
+ struct RamScriptData *scriptData = &gSaveBlock1Ptr->ramScript.data;
+ if (scriptData->magic != RAM_SCRIPT_MAGIC)
+ return FALSE;
+ if (scriptData->mapGroup != 0xFF)
+ return FALSE;
+ if (scriptData->mapNum != 0xFF)
+ return FALSE;
+ if (scriptData->objectId != 0xFF)
+ return FALSE;
+ if (CalculateRamScriptChecksum() != gSaveBlock1Ptr->ramScript.checksum)
+ return FALSE;
+ return TRUE;
+}
+
+u8 *sub_8069E48(void)
+{
+ struct RamScriptData *scriptData = &gSaveBlock1Ptr->ramScript.data;
+ if (!sub_8143FC8())
+ return NULL;
+ if (scriptData->magic != RAM_SCRIPT_MAGIC)
+ return NULL;
+ if (scriptData->mapGroup != 0xFF)
+ return NULL;
+ if (scriptData->mapNum != 0xFF)
+ return NULL;
+ if (scriptData->objectId != 0xFF)
+ return NULL;
+ if (CalculateRamScriptChecksum() != gSaveBlock1Ptr->ramScript.checksum)
+ {
+ ClearRamScript();
+ return NULL;
+ }
+ else
+ {
+ return scriptData->script;
+ }
+}
+
+void sub_8069EA4(u8 *script, u16 scriptSize)
+{
+ if (scriptSize > sizeof(gSaveBlock1Ptr->ramScript.data.script))
+ scriptSize = sizeof(gSaveBlock1Ptr->ramScript.data.script);
+ InitRamScript(script, scriptSize, 0xFF, 0xFF, 0xFF);
+}
diff --git a/src/sound.c b/src/sound.c
new file mode 100644
index 000000000..b8814de81
--- /dev/null
+++ b/src/sound.c
@@ -0,0 +1,628 @@
+#include "global.h"
+#include "gba/m4a_internal.h"
+#include "sound.h"
+#include "battle.h"
+#include "m4a.h"
+#include "main.h"
+#include "pokemon.h"
+#include "constants/songs.h"
+#include "task.h"
+
+struct Fanfare
+{
+ u16 songNum;
+ u16 duration;
+};
+
+// TODO: what are these
+extern u8 gUnknown_2031DD8;
+extern u8 gUnknown_203ADFA;
+extern u8 gUnknown_203F174;
+
+// ewram
+EWRAM_DATA struct MusicPlayerInfo* gMPlay_PokemonCry = NULL;
+EWRAM_DATA u8 gPokemonCryBGMDuckingCounter = 0;
+
+// iwram bss
+IWRAM_DATA static u16 sCurrentMapMusic;
+IWRAM_DATA static u16 sNextMapMusic;
+IWRAM_DATA static u8 sMapMusicState;
+IWRAM_DATA static u8 sMapMusicFadeInSpeed;
+IWRAM_DATA static u16 sFanfareCounter;
+
+// iwram common
+bool8 gDisableMusic;
+
+extern u32 gBattleTypeFlags;
+extern struct MusicPlayerInfo gMPlayInfo_BGM;
+extern struct MusicPlayerInfo gMPlayInfo_SE1;
+extern struct MusicPlayerInfo gMPlayInfo_SE2;
+extern struct MusicPlayerInfo gMPlayInfo_SE3;
+extern struct ToneData gCryTable[];
+extern struct ToneData gCryTable2[];
+extern const struct Fanfare sFanfares[];
+
+extern u16 SpeciesToCryId(u16);
+
+static void Task_Fanfare(u8 taskId);
+static void CreateFanfareTask(void);
+static void Task_DuckBGMForPokemonCry(u8 taskId);
+static void RestoreBGMVolumeAfterPokemonCry(void);
+
+#define CRY_VOLUME 120 // was 125 in R/S
+
+void InitMapMusic(void)
+{
+ gDisableMusic = FALSE;
+ ResetMapMusic();
+}
+
+void MapMusicMain(void)
+{
+ switch (sMapMusicState)
+ {
+ case 0:
+ break;
+ case 1:
+ sMapMusicState = 2;
+ PlayBGM(sCurrentMapMusic);
+ break;
+ case 2:
+ case 3:
+ case 4:
+ break;
+ case 5:
+ if (IsBGMStopped())
+ {
+ sNextMapMusic = 0;
+ sMapMusicState = 0;
+ }
+ break;
+ case 6:
+ if (IsBGMStopped() && IsFanfareTaskInactive())
+ {
+ sCurrentMapMusic = sNextMapMusic;
+ sNextMapMusic = 0;
+ sMapMusicState = 2;
+ PlayBGM(sCurrentMapMusic);
+ }
+ break;
+ case 7:
+ if (IsBGMStopped() && IsFanfareTaskInactive())
+ {
+ FadeInNewBGM(sNextMapMusic, sMapMusicFadeInSpeed);
+ sCurrentMapMusic = sNextMapMusic;
+ sNextMapMusic = 0;
+ sMapMusicState = 2;
+ sMapMusicFadeInSpeed = 0;
+ }
+ break;
+ }
+}
+
+void ResetMapMusic(void)
+{
+ sCurrentMapMusic = 0;
+ sNextMapMusic = 0;
+ sMapMusicState = 0;
+ sMapMusicFadeInSpeed = 0;
+}
+
+u16 GetCurrentMapMusic(void)
+{
+ return sCurrentMapMusic;
+}
+
+void PlayNewMapMusic(u16 songNum)
+{
+ sCurrentMapMusic = songNum;
+ sNextMapMusic = 0;
+ sMapMusicState = 1;
+}
+
+void StopMapMusic(void)
+{
+ sCurrentMapMusic = 0;
+ sNextMapMusic = 0;
+ sMapMusicState = 1;
+}
+
+void FadeOutMapMusic(u8 speed)
+{
+ if (IsNotWaitingForBGMStop())
+ FadeOutBGM(speed);
+ sCurrentMapMusic = 0;
+ sNextMapMusic = 0;
+ sMapMusicState = 5;
+}
+
+void FadeOutAndPlayNewMapMusic(u16 songNum, u8 speed)
+{
+ FadeOutMapMusic(speed);
+ sCurrentMapMusic = 0;
+ sNextMapMusic = songNum;
+ sMapMusicState = 6;
+}
+
+void FadeOutAndFadeInNewMapMusic(u16 songNum, u8 fadeOutSpeed, u8 fadeInSpeed)
+{
+ FadeOutMapMusic(fadeOutSpeed);
+ sCurrentMapMusic = 0;
+ sNextMapMusic = songNum;
+ sMapMusicState = 7;
+ sMapMusicFadeInSpeed = fadeInSpeed;
+}
+
+void FadeInNewMapMusic(u16 songNum, u8 speed)
+{
+ FadeInNewBGM(songNum, speed);
+ sCurrentMapMusic = songNum;
+ sNextMapMusic = 0;
+ sMapMusicState = 2;
+ sMapMusicFadeInSpeed = 0;
+}
+
+bool8 IsNotWaitingForBGMStop(void)
+{
+ if (sMapMusicState == 6)
+ return FALSE;
+ if (sMapMusicState == 5)
+ return FALSE;
+ if (sMapMusicState == 7)
+ return FALSE;
+ return TRUE;
+}
+
+void PlayFanfareByFanfareNum(u8 fanfareNum)
+{
+ u16 songNum;
+
+ if(gUnknown_203ADFA == 2)
+ {
+ sFanfareCounter = 0xFF;
+ }
+ else
+ {
+ m4aMPlayStop(&gMPlayInfo_BGM);
+ songNum = sFanfares[fanfareNum].songNum;
+ sFanfareCounter = sFanfares[fanfareNum].duration;
+ m4aSongNumStart(songNum);
+ }
+}
+
+bool8 WaitFanfare(bool8 stop)
+{
+ if (sFanfareCounter)
+ {
+ sFanfareCounter--;
+ return FALSE;
+ }
+ else
+ {
+ if (!stop)
+ m4aMPlayContinue(&gMPlayInfo_BGM);
+ else
+ m4aSongNumStart(MUS_DUMMY);
+
+ return TRUE;
+ }
+}
+
+void StopFanfareByFanfareNum(u8 fanfareNum)
+{
+ m4aSongNumStop(sFanfares[fanfareNum].songNum);
+}
+
+void PlayFanfare(u16 songNum)
+{
+ s32 i;
+ for (i = 0; (u32)i < 14; i++)
+ {
+ if (sFanfares[i].songNum == songNum)
+ {
+ PlayFanfareByFanfareNum(i);
+ CreateFanfareTask();
+ return;
+ }
+ }
+
+ PlayFanfareByFanfareNum(0);
+ CreateFanfareTask();
+}
+
+bool8 IsFanfareTaskInactive(void)
+{
+ if (FuncIsActiveTask(Task_Fanfare) == TRUE)
+ return FALSE;
+ return TRUE;
+}
+
+static void Task_Fanfare(u8 taskId)
+{
+ if (sFanfareCounter)
+ {
+ sFanfareCounter--;
+ }
+ else
+ {
+ m4aMPlayContinue(&gMPlayInfo_BGM);
+ DestroyTask(taskId);
+ }
+}
+
+static void CreateFanfareTask(void)
+{
+ if (FuncIsActiveTask(Task_Fanfare) != TRUE)
+ CreateTask(Task_Fanfare, 80);
+}
+
+void FadeInNewBGM(u16 songNum, u8 speed)
+{
+ if (gDisableMusic)
+ songNum = 0;
+ if (songNum == 0xFFFF)
+ songNum = 0;
+ m4aSongNumStart(songNum);
+ m4aMPlayImmInit(&gMPlayInfo_BGM);
+ m4aMPlayVolumeControl(&gMPlayInfo_BGM, 0xFFFF, 0);
+ m4aSongNumStop(songNum);
+ m4aMPlayFadeIn(&gMPlayInfo_BGM, speed);
+}
+
+void FadeOutBGMTemporarily(u8 speed)
+{
+ m4aMPlayFadeOutTemporarily(&gMPlayInfo_BGM, speed);
+}
+
+bool8 IsBGMPausedOrStopped(void)
+{
+ if (gMPlayInfo_BGM.status & MUSICPLAYER_STATUS_PAUSE)
+ return TRUE;
+ if (!(gMPlayInfo_BGM.status & MUSICPLAYER_STATUS_TRACK))
+ return TRUE;
+ return FALSE;
+}
+
+void FadeInBGM(u8 speed)
+{
+ m4aMPlayFadeIn(&gMPlayInfo_BGM, speed);
+}
+
+void FadeOutBGM(u8 speed)
+{
+ m4aMPlayFadeOut(&gMPlayInfo_BGM, speed);
+}
+
+bool8 IsBGMStopped(void)
+{
+ if (!(gMPlayInfo_BGM.status & MUSICPLAYER_STATUS_TRACK))
+ return TRUE;
+ return FALSE;
+}
+
+void PlayCry1(u16 species, s8 pan)
+{
+ m4aMPlayVolumeControl(&gMPlayInfo_BGM, 0xFFFF, 85);
+ PlayCryInternal(species, pan, CRY_VOLUME, 10, 0);
+ gPokemonCryBGMDuckingCounter = 2;
+ RestoreBGMVolumeAfterPokemonCry();
+}
+
+void PlayCry2(u16 species, s8 pan, s8 volume, u8 priority)
+{
+ PlayCryInternal(species, pan, volume, priority, 0);
+}
+
+void PlayCry3(u16 species, s8 pan, u8 mode)
+{
+ if (mode == 1)
+ {
+ PlayCryInternal(species, pan, CRY_VOLUME, 10, 1);
+ }
+ else
+ {
+ m4aMPlayVolumeControl(&gMPlayInfo_BGM, 0xFFFF, 85);
+ PlayCryInternal(species, pan, CRY_VOLUME, 10, mode);
+ gPokemonCryBGMDuckingCounter = 2;
+ RestoreBGMVolumeAfterPokemonCry();
+ }
+}
+
+void PlayCry4(u16 species, s8 pan, u8 mode)
+{
+ if (mode == 1)
+ {
+ PlayCryInternal(species, pan, CRY_VOLUME, 10, 1);
+ }
+ else
+ {
+ if (!(gBattleTypeFlags & BATTLE_TYPE_MULTI))
+ m4aMPlayVolumeControl(&gMPlayInfo_BGM, 0xFFFF, 85);
+ PlayCryInternal(species, pan, CRY_VOLUME, 10, mode);
+ }
+}
+
+// PlayCry5 and 6 are not in FR/LG.
+
+void PlayCry7(u16 species, u8 mode) // exclusive to FR/LG
+{
+ if((u8)(gUnknown_203ADFA - 2) >= 2)
+ {
+ m4aMPlayVolumeControl(&gMPlayInfo_BGM, 0xFFFF, 85);
+ PlayCryInternal(species, 0, CRY_VOLUME, 10, mode);
+ }
+ gPokemonCryBGMDuckingCounter = 2;
+ RestoreBGMVolumeAfterPokemonCry();
+}
+
+void PlayCryInternal(u16 species, s8 pan, s8 volume, u8 priority, u8 mode)
+{
+ bool32 v0;
+ u32 release;
+ u32 length;
+ u32 pitch;
+ u32 chorus;
+ u32 index;
+ u8 table;
+
+ species--;
+ length = 140;
+ v0 = FALSE;
+ release = 0;
+ pitch = 15360;
+ chorus = 0;
+
+ switch (mode)
+ {
+ case 0:
+ break;
+ case 1:
+ length = 20;
+ release = 225;
+ break;
+ case 2:
+ release = 225;
+ pitch = 15600;
+ chorus = 20;
+ volume = 90;
+ break;
+ case 3:
+ length = 50;
+ release = 200;
+ pitch = 15800;
+ chorus = 20;
+ volume = 90;
+ break;
+ case 4:
+ length = 25;
+ v0 = TRUE;
+ release = 100;
+ pitch = 15600;
+ chorus = 192;
+ volume = 90;
+ break;
+ case 5:
+ release = 200;
+ pitch = 14440;
+ break;
+ case 6: // _08072044
+ release = 220;
+ pitch = 15555;
+ chorus = 192;
+ volume = 90; // FR/LG changed this from 70 to 90
+ break;
+ case 7:
+ length = 10;
+ release = 100;
+ pitch = 14848;
+ break;
+ case 8:
+ length = 60;
+ release = 225;
+ pitch = 15616;
+ break;
+ case 9:
+ length = 15;
+ v0 = TRUE;
+ release = 125;
+ pitch = 15200;
+ break;
+ case 10:
+ length = 100;
+ release = 225;
+ pitch = 15200;
+ break;
+ case 12:
+ length = 20;
+ release = 225;
+ case 11:
+ pitch = 15000;
+ break;
+ }
+
+ SetPokemonCryVolume(volume);
+ SetPokemonCryPanpot(pan);
+ SetPokemonCryPitch(pitch);
+ SetPokemonCryLength(length);
+ SetPokemonCryProgress(0);
+ SetPokemonCryRelease(release);
+ SetPokemonCryChorus(chorus);
+ SetPokemonCryPriority(priority);
+
+ // This is a fancy way to get a cry of a pokemon.
+ // It creates 4 sets of 128 mini cry tables.
+ // If you wish to expand pokemon, you need to
+ // append new cases to the switch.
+ species = SpeciesToCryId(species);
+ index = species & 0x7F;
+ table = species / 128;
+
+ switch (table)
+ {
+ case 0:
+ gMPlay_PokemonCry = SetPokemonCryTone(
+ v0 ? &gCryTable2[(128 * 0) + index] : &gCryTable[(128 * 0) + index]);
+ break;
+ case 1:
+ gMPlay_PokemonCry = SetPokemonCryTone(
+ v0 ? &gCryTable2[(128 * 1) + index] : &gCryTable[(128 * 1) + index]);
+ break;
+ case 2:
+ gMPlay_PokemonCry = SetPokemonCryTone(
+ v0 ? &gCryTable2[(128 * 2) + index] : &gCryTable[(128 * 2) + index]);
+ break;
+ case 3:
+ gMPlay_PokemonCry = SetPokemonCryTone(
+ v0 ? &gCryTable2[(128 * 3) + index] : &gCryTable[(128 * 3) + index]);
+ break;
+ }
+}
+
+bool8 IsCryFinished(void)
+{
+ if (FuncIsActiveTask(Task_DuckBGMForPokemonCry) == TRUE)
+ {
+ return FALSE;
+ }
+ else
+ {
+ ClearPokemonCrySongs();
+ return TRUE;
+ }
+}
+
+void StopCryAndClearCrySongs(void)
+{
+ m4aMPlayStop(gMPlay_PokemonCry);
+ ClearPokemonCrySongs();
+}
+
+void StopCry(void)
+{
+ m4aMPlayStop(gMPlay_PokemonCry);
+}
+
+bool8 IsCryPlayingOrClearCrySongs(void)
+{
+ if (IsPokemonCryPlaying(gMPlay_PokemonCry))
+ {
+ return TRUE;
+ }
+ else
+ {
+ ClearPokemonCrySongs();
+ return FALSE;
+ }
+}
+
+bool8 IsCryPlaying(void)
+{
+ if (IsPokemonCryPlaying(gMPlay_PokemonCry))
+ return TRUE;
+ else
+ return FALSE;
+}
+
+static void Task_DuckBGMForPokemonCry(u8 taskId)
+{
+ if (gPokemonCryBGMDuckingCounter)
+ {
+ gPokemonCryBGMDuckingCounter--;
+ return;
+ }
+
+ if (!IsPokemonCryPlaying(gMPlay_PokemonCry))
+ {
+ m4aMPlayVolumeControl(&gMPlayInfo_BGM, 0xFFFF, 256);
+ DestroyTask(taskId);
+ }
+}
+
+static void RestoreBGMVolumeAfterPokemonCry(void)
+{
+ if (FuncIsActiveTask(Task_DuckBGMForPokemonCry) != TRUE)
+ CreateTask(Task_DuckBGMForPokemonCry, 80);
+}
+
+void PlayBGM(u16 songNum)
+{
+ if (gDisableMusic)
+ songNum = 0;
+ if (songNum == 0xFFFF)
+ songNum = 0;
+ m4aSongNumStart(songNum);
+}
+
+void PlaySE(u16 songNum)
+{
+ if(gUnknown_2031DD8 == 0 && gUnknown_203ADFA != 2)
+ m4aSongNumStart(songNum);
+}
+
+void PlaySE12WithPanning(u16 songNum, s8 pan)
+{
+ m4aSongNumStart(songNum);
+ m4aMPlayImmInit(&gMPlayInfo_SE1);
+ m4aMPlayImmInit(&gMPlayInfo_SE2);
+ m4aMPlayPanpotControl(&gMPlayInfo_SE1, 0xFFFF, pan);
+ m4aMPlayPanpotControl(&gMPlayInfo_SE2, 0xFFFF, pan);
+}
+
+void PlaySE1WithPanning(u16 songNum, s8 pan)
+{
+ m4aSongNumStart(songNum);
+ m4aMPlayImmInit(&gMPlayInfo_SE1);
+ m4aMPlayPanpotControl(&gMPlayInfo_SE1, 0xFFFF, pan);
+}
+
+void PlaySE2WithPanning(u16 songNum, s8 pan)
+{
+ m4aSongNumStart(songNum);
+ m4aMPlayImmInit(&gMPlayInfo_SE2);
+ m4aMPlayPanpotControl(&gMPlayInfo_SE2, 0xFFFF, pan);
+}
+
+void SE12PanpotControl(s8 pan)
+{
+ m4aMPlayPanpotControl(&gMPlayInfo_SE1, 0xFFFF, pan);
+ m4aMPlayPanpotControl(&gMPlayInfo_SE2, 0xFFFF, pan);
+}
+
+bool8 IsSEPlaying(void)
+{
+ if ((gMPlayInfo_SE1.status & MUSICPLAYER_STATUS_PAUSE) && (gMPlayInfo_SE2.status & MUSICPLAYER_STATUS_PAUSE))
+ return FALSE;
+ if (!(gMPlayInfo_SE1.status & MUSICPLAYER_STATUS_TRACK) && !(gMPlayInfo_SE2.status & MUSICPLAYER_STATUS_TRACK))
+ return FALSE;
+ return TRUE;
+}
+
+bool8 IsBGMPlaying(void)
+{
+ if (gMPlayInfo_BGM.status & MUSICPLAYER_STATUS_PAUSE)
+ return FALSE;
+ if (!(gMPlayInfo_BGM.status & MUSICPLAYER_STATUS_TRACK))
+ return FALSE;
+ return TRUE;
+}
+
+bool8 IsSpecialSEPlaying(void)
+{
+ if (gMPlayInfo_SE3.status & MUSICPLAYER_STATUS_PAUSE)
+ return FALSE;
+ if (!(gMPlayInfo_SE3.status & MUSICPLAYER_STATUS_TRACK))
+ return FALSE;
+ return TRUE;
+}
+
+void sub_8072474(u16 volume)
+{
+ gUnknown_203F174 = 1;
+ m4aMPlayVolumeControl(&gMPlayInfo_BGM, 0xFFFF, volume);
+}
+
+void sub_807249C(void)
+{
+ gUnknown_203F174 = 0;
+ m4aMPlayVolumeControl(&gMPlayInfo_BGM, 0xFFFF, 256);
+}
diff --git a/src/task.c b/src/task.c
new file mode 100644
index 000000000..fafa7c70d
--- /dev/null
+++ b/src/task.c
@@ -0,0 +1,219 @@
+#include "global.h"
+#include "task.h"
+
+#define HEAD_SENTINEL 0xFE
+#define TAIL_SENTINEL 0xFF
+
+struct Task gTasks[NUM_TASKS];
+
+static void InsertTask(u8 newTaskId);
+static u8 FindFirstActiveTask();
+
+void ResetTasks(void)
+{
+ u8 i;
+
+ for (i = 0; i < NUM_TASKS; i++)
+ {
+ gTasks[i].isActive = FALSE;
+ gTasks[i].func = TaskDummy;
+ gTasks[i].prev = i;
+ gTasks[i].next = i + 1;
+ gTasks[i].priority = -1;
+ memset(gTasks[i].data, 0, sizeof(gTasks[i].data));
+ }
+
+ gTasks[0].prev = HEAD_SENTINEL;
+ gTasks[NUM_TASKS - 1].next = TAIL_SENTINEL;
+}
+
+u8 CreateTask(TaskFunc func, u8 priority)
+{
+ u8 i;
+
+ for (i = 0; i < NUM_TASKS; i++)
+ {
+ if (!gTasks[i].isActive)
+ {
+ gTasks[i].func = func;
+ gTasks[i].priority = priority;
+ InsertTask(i);
+ memset(gTasks[i].data, 0, sizeof(gTasks[i].data));
+ gTasks[i].isActive = TRUE;
+ return i;
+ }
+ }
+
+ return 0;
+}
+
+static void InsertTask(u8 newTaskId)
+{
+ u8 taskId = FindFirstActiveTask();
+
+ if (taskId == NUM_TASKS)
+ {
+ // The new task is the only task.
+ gTasks[newTaskId].prev = HEAD_SENTINEL;
+ gTasks[newTaskId].next = TAIL_SENTINEL;
+ return;
+ }
+
+ while (1)
+ {
+ if (gTasks[newTaskId].priority < gTasks[taskId].priority)
+ {
+ // We've found a task with a higher priority value,
+ // so we insert the new task before it.
+ gTasks[newTaskId].prev = gTasks[taskId].prev;
+ gTasks[newTaskId].next = taskId;
+ if (gTasks[taskId].prev != HEAD_SENTINEL)
+ gTasks[gTasks[taskId].prev].next = newTaskId;
+ gTasks[taskId].prev = newTaskId;
+ return;
+ }
+ if (gTasks[taskId].next == TAIL_SENTINEL)
+ {
+ // We've reached the end.
+ gTasks[newTaskId].prev = taskId;
+ gTasks[newTaskId].next = gTasks[taskId].next;
+ gTasks[taskId].next = newTaskId;
+ return;
+ }
+ taskId = gTasks[taskId].next;
+ }
+}
+
+void DestroyTask(u8 taskId)
+{
+ if (gTasks[taskId].isActive)
+ {
+ gTasks[taskId].isActive = FALSE;
+
+ if (gTasks[taskId].prev == HEAD_SENTINEL)
+ {
+ if (gTasks[taskId].next != TAIL_SENTINEL)
+ gTasks[gTasks[taskId].next].prev = HEAD_SENTINEL;
+ }
+ else
+ {
+ if (gTasks[taskId].next == TAIL_SENTINEL)
+ {
+ gTasks[gTasks[taskId].prev].next = TAIL_SENTINEL;
+ }
+ else
+ {
+ gTasks[gTasks[taskId].prev].next = gTasks[taskId].next;
+ gTasks[gTasks[taskId].next].prev = gTasks[taskId].prev;
+ }
+ }
+ }
+}
+
+void RunTasks(void)
+{
+ u8 taskId = FindFirstActiveTask();
+
+ if (taskId != NUM_TASKS)
+ {
+ do
+ {
+ gTasks[taskId].func(taskId);
+ taskId = gTasks[taskId].next;
+ } while (taskId != TAIL_SENTINEL);
+ }
+}
+
+static u8 FindFirstActiveTask()
+{
+ u8 taskId;
+
+ for (taskId = 0; taskId < NUM_TASKS; taskId++)
+ if (gTasks[taskId].isActive == TRUE && gTasks[taskId].prev == HEAD_SENTINEL)
+ break;
+
+ return taskId;
+}
+
+void TaskDummy(u8 taskId)
+{
+}
+
+#define TASK_DATA_OP(taskId, offset, op) \
+{ \
+ u32 tasksAddr = (u32)gTasks; \
+ u32 addr = taskId * sizeof(struct Task) + offset; \
+ u32 dataAddr = tasksAddr + offsetof(struct Task, data); \
+ addr += dataAddr; \
+ op; \
+}
+
+void SetTaskFuncWithFollowupFunc(u8 taskId, TaskFunc func, TaskFunc followupFunc)
+{
+ TASK_DATA_OP(taskId, 28, *((u16 *)addr) = (u32)followupFunc)
+ TASK_DATA_OP(taskId, 30, *((u16 *)addr) = (u32)followupFunc >> 16)
+ gTasks[taskId].func = func;
+}
+
+void SwitchTaskToFollowupFunc(u8 taskId)
+{
+ s32 func;
+
+ gTasks[taskId].func = NULL;
+
+ TASK_DATA_OP(taskId, 28, func = *((u16 *)addr))
+ TASK_DATA_OP(taskId, 30, func |= *((s16 *)addr) << 16)
+
+ gTasks[taskId].func = (TaskFunc)func;
+}
+
+bool8 FuncIsActiveTask(TaskFunc func)
+{
+ u8 i;
+
+ for (i = 0; i < NUM_TASKS; i++)
+ if (gTasks[i].isActive == TRUE && gTasks[i].func == func)
+ return TRUE;
+
+ return FALSE;
+}
+
+u8 FindTaskIdByFunc(TaskFunc func)
+{
+ s32 i;
+
+ for (i = 0; i < NUM_TASKS; i++)
+ if (gTasks[i].isActive == TRUE && gTasks[i].func == func)
+ return (u8)i;
+
+ return -1;
+}
+
+u8 GetTaskCount(void)
+{
+ u8 i;
+ u8 count = 0;
+
+ for (i = 0; i < NUM_TASKS; i++)
+ if (gTasks[i].isActive == TRUE)
+ count++;
+
+ return count;
+}
+
+void SetWordTaskArg(u8 taskId, u8 dataElem, u32 value)
+{
+ if (dataElem <= 14)
+ {
+ gTasks[taskId].data[dataElem] = value;
+ gTasks[taskId].data[dataElem + 1] = value >> 16;
+ }
+}
+
+u32 GetWordTaskArg(u8 taskId, u8 dataElem)
+{
+ if (dataElem <= 14)
+ return (u16)gTasks[taskId].data[dataElem] | (gTasks[taskId].data[dataElem + 1] << 16);
+ else
+ return 0;
+}
diff --git a/src/text.c b/src/text.c
index 76c6dba63..7832d86f3 100644
--- a/src/text.c
+++ b/src/text.c
@@ -680,17 +680,17 @@ _08005A84:\n\
bl FillWindowPixelBuffer\n\
b _0800589E\n\
_08005A96:\n\
- ldr r0, _08005AA0 @ =gMPlay_BGM\n\
+ ldr r0, _08005AA0 @ =gMPlayInfo_BGM\n\
bl m4aMPlayStop\n\
b _0800589E\n\
.align 2, 0\n\
-_08005AA0: .4byte gMPlay_BGM\n\
+_08005AA0: .4byte gMPlayInfo_BGM\n\
_08005AA4:\n\
- ldr r0, _08005AAC @ =gMPlay_BGM\n\
+ ldr r0, _08005AAC @ =gMPlayInfo_BGM\n\
bl m4aMPlayContinue\n\
b _0800589E\n\
.align 2, 0\n\
-_08005AAC: .4byte gMPlay_BGM\n\
+_08005AAC: .4byte gMPlayInfo_BGM\n\
_08005AB0:\n\
ldr r0, [r6]\n\
ldrb r4, [r0]\n\
generated by cgit v1.2.3 (git 2.25.1) at 2025-05-17 10:12:58 +0000