ninjdai/pokeemerald
1
0
Fork 0
mirror of https://github.com/Ninjdai1/pokeemerald.git synced 2024-12-27 04:04:17 +01:00
Code Issues Packages Projects Releases Wiki Activity
4941e2602a
pokeemerald/src/battle_ai_script_commands.c
GriffinR 18319e8da3 Misc missing constant use
2023-08-10 01:42:18 -04:00

2273 lines
66 KiB
C
Raw Blame History

#include "global.h"
#include "battle.h"
#include "battle_anim.h"
#include "battle_ai_script_commands.h"
#include "battle_factory.h"
#include "battle_setup.h"
#include "data.h"
#include "item.h"
#include "pokemon.h"
#include "random.h"
#include "recorded_battle.h"
#include "util.h"
#include "constants/abilities.h"
#include "constants/battle_ai.h"
#include "constants/battle_move_effects.h"
#include "constants/items.h"
#include "constants/moves.h"
#define AI_ACTION_DONE (1 << 0)
#define AI_ACTION_FLEE (1 << 1)
#define AI_ACTION_WATCH (1 << 2)
#define AI_ACTION_DO_NOT_ATTACK (1 << 3)
#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
};
/*
gAIScriptPtr is a pointer to the next battle AI cmd command to read.
when a command finishes processing, gAIScriptPtr is incremented by
the number of bytes that the current command had reserved for arguments
in order to read the next command correctly. refer to battle_ai_scripts.s for the
AI scripts.
*/
extern const u8 *const gBattleAI_ScriptsTable[];
static u8 ChooseMoveOrAction_Singles(void);
static u8 ChooseMoveOrAction_Doubles(void);
static void RecordLastUsedMoveByTarget(void);
static void BattleAI_DoAIProcessing(void);
static void AIStackPushVar(const u8 *);
static bool8 AIStackPop(void);
static void Cmd_if_random_less_than(void);
static void Cmd_if_random_greater_than(void);
static void Cmd_if_random_equal(void);
static void Cmd_if_random_not_equal(void);
static void Cmd_score(void);
static void Cmd_if_hp_less_than(void);
static void Cmd_if_hp_more_than(void);
static void Cmd_if_hp_equal(void);
static void Cmd_if_hp_not_equal(void);
static void Cmd_if_status(void);
static void Cmd_if_not_status(void);
static void Cmd_if_status2(void);
static void Cmd_if_not_status2(void);
static void Cmd_if_status3(void);
static void Cmd_if_not_status3(void);
static void Cmd_if_side_affecting(void);
static void Cmd_if_not_side_affecting(void);
static void Cmd_if_less_than(void);
static void Cmd_if_more_than(void);
static void Cmd_if_equal(void);
static void Cmd_if_not_equal(void);
static void Cmd_if_less_than_ptr(void);
static void Cmd_if_more_than_ptr(void);
static void Cmd_if_equal_ptr(void);
static void Cmd_if_not_equal_ptr(void);
static void Cmd_if_move(void);
static void Cmd_if_not_move(void);
static void Cmd_if_in_bytes(void);
static void Cmd_if_not_in_bytes(void);
static void Cmd_if_in_hwords(void);
static void Cmd_if_not_in_hwords(void);
static void Cmd_if_user_has_attacking_move(void);
static void Cmd_if_user_has_no_attacking_moves(void);
static void Cmd_get_turn_count(void);
static void Cmd_get_type(void);
static void Cmd_get_considered_move_power(void);
static void Cmd_get_how_powerful_move_is(void);
static void Cmd_get_last_used_battler_move(void);
static void Cmd_if_equal_(void);
static void Cmd_if_not_equal_(void);
static void Cmd_if_user_goes(void);
static void Cmd_if_user_doesnt_go(void);
static void Cmd_nop_2A(void);
static void Cmd_nop_2B(void);
static void Cmd_count_usable_party_mons(void);
static void Cmd_get_considered_move(void);
static void Cmd_get_considered_move_effect(void);
static void Cmd_get_ability(void);
static void Cmd_get_highest_type_effectiveness(void);
static void Cmd_if_type_effectiveness(void);
static void Cmd_nop_32(void);
static void Cmd_nop_33(void);
static void Cmd_if_status_in_party(void);
static void Cmd_if_status_not_in_party(void);
static void Cmd_get_weather(void);
static void Cmd_if_effect(void);
static void Cmd_if_not_effect(void);
static void Cmd_if_stat_level_less_than(void);
static void Cmd_if_stat_level_more_than(void);
static void Cmd_if_stat_level_equal(void);
static void Cmd_if_stat_level_not_equal(void);
static void Cmd_if_can_faint(void);
static void Cmd_if_cant_faint(void);
static void Cmd_if_has_move(void);
static void Cmd_if_doesnt_have_move(void);
static void Cmd_if_has_move_with_effect(void);
static void Cmd_if_doesnt_have_move_with_effect(void);
static void Cmd_if_any_move_disabled_or_encored(void);
static void Cmd_if_curr_move_disabled_or_encored(void);
static void Cmd_flee(void);
static void Cmd_if_random_safari_flee(void);
static void Cmd_watch(void);
static void Cmd_get_hold_effect(void);
static void Cmd_get_gender(void);
static void Cmd_is_first_turn_for(void);
static void Cmd_get_stockpile_count(void);
static void Cmd_is_double_battle(void);
static void Cmd_get_used_held_item(void);
static void Cmd_get_move_type_from_result(void);
static void Cmd_get_move_power_from_result(void);
static void Cmd_get_move_effect_from_result(void);
static void Cmd_get_protect_count(void);
static void Cmd_nop_52(void);
static void Cmd_nop_53(void);
static void Cmd_nop_54(void);
static void Cmd_nop_55(void);
static void Cmd_nop_56(void);
static void Cmd_nop_57(void);
static void Cmd_call(void);
static void Cmd_goto(void);
static void Cmd_end(void);
static void Cmd_if_level_cond(void);
static void Cmd_if_target_taunted(void);
static void Cmd_if_target_not_taunted(void);
static void Cmd_check_ability(void);
static void Cmd_is_of_type(void);
static void Cmd_if_target_is_ally(void);
static void Cmd_if_flash_fired(void);
static void Cmd_if_holds_item(void);
// ewram
EWRAM_DATA const u8 *gAIScriptPtr = NULL;
EWRAM_DATA static u8 sBattler_AI = 0;
// const rom data
typedef void (*BattleAICmdFunc)(void);
static const BattleAICmdFunc sBattleAICmdTable[] =
{
Cmd_if_random_less_than, // 0x0
Cmd_if_random_greater_than, // 0x1
Cmd_if_random_equal, // 0x2
Cmd_if_random_not_equal, // 0x3
Cmd_score, // 0x4
Cmd_if_hp_less_than, // 0x5
Cmd_if_hp_more_than, // 0x6
Cmd_if_hp_equal, // 0x7
Cmd_if_hp_not_equal, // 0x8
Cmd_if_status, // 0x9
Cmd_if_not_status, // 0xA
Cmd_if_status2, // 0xB
Cmd_if_not_status2, // 0xC
Cmd_if_status3, // 0xD
Cmd_if_not_status3, // 0xE
Cmd_if_side_affecting, // 0xF
Cmd_if_not_side_affecting, // 0x10
Cmd_if_less_than, // 0x11
Cmd_if_more_than, // 0x12
Cmd_if_equal, // 0x13
Cmd_if_not_equal, // 0x14
Cmd_if_less_than_ptr, // 0x15
Cmd_if_more_than_ptr, // 0x16
Cmd_if_equal_ptr, // 0x17
Cmd_if_not_equal_ptr, // 0x18
Cmd_if_move, // 0x19
Cmd_if_not_move, // 0x1A
Cmd_if_in_bytes, // 0x1B
Cmd_if_not_in_bytes, // 0x1C
Cmd_if_in_hwords, // 0x1D
Cmd_if_not_in_hwords, // 0x1E
Cmd_if_user_has_attacking_move, // 0x1F
Cmd_if_user_has_no_attacking_moves, // 0x20
Cmd_get_turn_count, // 0x21
Cmd_get_type, // 0x22
Cmd_get_considered_move_power, // 0x23
Cmd_get_how_powerful_move_is, // 0x24
Cmd_get_last_used_battler_move, // 0x25
Cmd_if_equal_, // 0x26
Cmd_if_not_equal_, // 0x27
Cmd_if_user_goes, // 0x28
Cmd_if_user_doesnt_go, // 0x29
Cmd_nop_2A, // 0x2A
Cmd_nop_2B, // 0x2B
Cmd_count_usable_party_mons, // 0x2C
Cmd_get_considered_move, // 0x2D
Cmd_get_considered_move_effect, // 0x2E
Cmd_get_ability, // 0x2F
Cmd_get_highest_type_effectiveness, // 0x30
Cmd_if_type_effectiveness, // 0x31
Cmd_nop_32, // 0x32
Cmd_nop_33, // 0x33
Cmd_if_status_in_party, // 0x34
Cmd_if_status_not_in_party, // 0x35
Cmd_get_weather, // 0x36
Cmd_if_effect, // 0x37
Cmd_if_not_effect, // 0x38
Cmd_if_stat_level_less_than, // 0x39
Cmd_if_stat_level_more_than, // 0x3A
Cmd_if_stat_level_equal, // 0x3B
Cmd_if_stat_level_not_equal, // 0x3C
Cmd_if_can_faint, // 0x3D
Cmd_if_cant_faint, // 0x3E
Cmd_if_has_move, // 0x3F
Cmd_if_doesnt_have_move, // 0x40
Cmd_if_has_move_with_effect, // 0x41
Cmd_if_doesnt_have_move_with_effect, // 0x42
Cmd_if_any_move_disabled_or_encored, // 0x43
Cmd_if_curr_move_disabled_or_encored, // 0x44
Cmd_flee, // 0x45
Cmd_if_random_safari_flee, // 0x46
Cmd_watch, // 0x47
Cmd_get_hold_effect, // 0x48
Cmd_get_gender, // 0x49
Cmd_is_first_turn_for, // 0x4A
Cmd_get_stockpile_count, // 0x4B
Cmd_is_double_battle, // 0x4C
Cmd_get_used_held_item, // 0x4D
Cmd_get_move_type_from_result, // 0x4E
Cmd_get_move_power_from_result, // 0x4F
Cmd_get_move_effect_from_result, // 0x50
Cmd_get_protect_count, // 0x51
Cmd_nop_52, // 0x52
Cmd_nop_53, // 0x53
Cmd_nop_54, // 0x54
Cmd_nop_55, // 0x55
Cmd_nop_56, // 0x56
Cmd_nop_57, // 0x57
Cmd_call, // 0x58
Cmd_goto, // 0x59
Cmd_end, // 0x5A
Cmd_if_level_cond, // 0x5B
Cmd_if_target_taunted, // 0x5C
Cmd_if_target_not_taunted, // 0x5D
Cmd_if_target_is_ally, // 0x5E
Cmd_is_of_type, // 0x5F
Cmd_check_ability, // 0x60
Cmd_if_flash_fired, // 0x61
Cmd_if_holds_item, // 0x62
};
// For the purposes of determining the most powerful move in a moveset, these
// moves are treated the same as having a power of 0 or 1
#define IGNORED_MOVES_END 0xFFFF
static const u16 sIgnoredPowerfulMoveEffects[] =
{
EFFECT_EXPLOSION,
EFFECT_DREAM_EATER,
EFFECT_RAZOR_WIND,
EFFECT_SKY_ATTACK,
EFFECT_RECHARGE,
EFFECT_SKULL_BASH,
EFFECT_SOLAR_BEAM,
EFFECT_SPIT_UP,
EFFECT_FOCUS_PUNCH,
EFFECT_SUPERPOWER,
EFFECT_ERUPTION,
EFFECT_OVERHEAT,
IGNORED_MOVES_END
};
void BattleAI_HandleItemUseBeforeAISetup(u8 defaultScoreMoves)
{
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.
if ((gBattleTypeFlags & BATTLE_TYPE_TRAINER)
&& !(gBattleTypeFlags & (BATTLE_TYPE_LINK | BATTLE_TYPE_SAFARI | BATTLE_TYPE_BATTLE_TOWER
| BATTLE_TYPE_EREADER_TRAINER | BATTLE_TYPE_SECRET_BASE | BATTLE_TYPE_FRONTIER
| BATTLE_TYPE_INGAME_PARTNER | BATTLE_TYPE_RECORDED_LINK)
)
)
{
for (i = 0; i < MAX_TRAINER_ITEMS; i++)
{
if (gTrainers[gTrainerBattleOpponent_A].items[i] != ITEM_NONE)
{
BATTLE_HISTORY->trainerItems[BATTLE_HISTORY->itemsNo] = gTrainers[gTrainerBattleOpponent_A].items[i];
BATTLE_HISTORY->itemsNo++;
}
}
}
BattleAI_SetupAIData(defaultScoreMoves);
}
void BattleAI_SetupAIData(u8 defaultScoreMoves)
{
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;
// Conditional score reset, unlike Ruby.
for (i = 0; i < MAX_MON_MOVES; i++)
{
if (defaultScoreMoves & 1)
AI_THINKING_STRUCT->score[i] = 100;
else
AI_THINKING_STRUCT->score[i] = 0;
defaultScoreMoves >>= 1;
}
moveLimitations = CheckMoveLimitations(gActiveBattler, 0, MOVE_LIMITATIONS_ALL);
// Ignore moves that aren't possible to use.
for (i = 0; i < MAX_MON_MOVES; 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) + BATTLE_OPPOSITE(GetBattlerSide(gActiveBattler));
if (gAbsentBattlerFlags & gBitTable[gBattlerTarget])
gBattlerTarget ^= BIT_FLANK;
}
// There's only one choice in single battles.
else
{
gBattlerTarget = BATTLE_OPPOSITE(sBattler_AI);
}
// Choose proper trainer ai scripts.
if (gBattleTypeFlags & BATTLE_TYPE_RECORDED)
AI_THINKING_STRUCT->aiFlags = GetAiScriptsInRecordedBattle();
else if (gBattleTypeFlags & BATTLE_TYPE_SAFARI)
AI_THINKING_STRUCT->aiFlags = AI_SCRIPT_SAFARI;
else if (gBattleTypeFlags & BATTLE_TYPE_ROAMER)
AI_THINKING_STRUCT->aiFlags = AI_SCRIPT_ROAMING;
else if (gBattleTypeFlags & BATTLE_TYPE_FIRST_BATTLE)
AI_THINKING_STRUCT->aiFlags = AI_SCRIPT_FIRST_BATTLE;
else if (gBattleTypeFlags & BATTLE_TYPE_FACTORY)
AI_THINKING_STRUCT->aiFlags = GetAiScriptsInBattleFactory();
else if (gBattleTypeFlags & (BATTLE_TYPE_FRONTIER | BATTLE_TYPE_EREADER_TRAINER | BATTLE_TYPE_TRAINER_HILL | BATTLE_TYPE_SECRET_BASE))
AI_THINKING_STRUCT->aiFlags = AI_SCRIPT_CHECK_BAD_MOVE | AI_SCRIPT_CHECK_VIABILITY | AI_SCRIPT_TRY_TO_FAINT;
else if (gBattleTypeFlags & BATTLE_TYPE_TWO_OPPONENTS)
AI_THINKING_STRUCT->aiFlags = gTrainers[gTrainerBattleOpponent_A].aiFlags | gTrainers[gTrainerBattleOpponent_B].aiFlags;
else
AI_THINKING_STRUCT->aiFlags = gTrainers[gTrainerBattleOpponent_A].aiFlags;
if (gBattleTypeFlags & BATTLE_TYPE_DOUBLE)
AI_THINKING_STRUCT->aiFlags |= AI_SCRIPT_DOUBLE_BATTLE; // act smart in doubles and don't attack your partner
}
u8 BattleAI_ChooseMoveOrAction(void)
{
u16 savedCurrentMove = gCurrentMove;
u8 ret;
if (!(gBattleTypeFlags & BATTLE_TYPE_DOUBLE))
ret = ChooseMoveOrAction_Singles();
else
ret = ChooseMoveOrAction_Doubles();
gCurrentMove = savedCurrentMove;
return ret;
}
static u8 ChooseMoveOrAction_Singles(void)
{
u8 currentMoveArray[MAX_MON_MOVES];
u8 consideredMoveArray[MAX_MON_MOVES];
u8 numOfBestMoves;
s32 i;
RecordLastUsedMoveByTarget();
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;
}
// Check special AI actions.
if (AI_THINKING_STRUCT->aiAction & AI_ACTION_FLEE)
return AI_CHOICE_FLEE;
if (AI_THINKING_STRUCT->aiAction & AI_ACTION_WATCH)
return AI_CHOICE_WATCH;
numOfBestMoves = 1;
currentMoveArray[0] = AI_THINKING_STRUCT->score[0];
consideredMoveArray[0] = 0;
for (i = 1; i < MAX_MON_MOVES; i++)
{
if (gBattleMons[sBattler_AI].moves[i] != MOVE_NONE)
{
// In ruby, the order of these if statements is reversed.
if (currentMoveArray[0] == AI_THINKING_STRUCT->score[i])
{
currentMoveArray[numOfBestMoves] = AI_THINKING_STRUCT->score[i];
consideredMoveArray[numOfBestMoves++] = i;
}
if (currentMoveArray[0] < AI_THINKING_STRUCT->score[i])
{
numOfBestMoves = 1;
currentMoveArray[0] = AI_THINKING_STRUCT->score[i];
consideredMoveArray[0] = i;
}
}
}
return consideredMoveArray[Random() % numOfBestMoves];
}
static u8 ChooseMoveOrAction_Doubles(void)
{
s32 i;
s32 j;
#ifndef BUGFIX
s32 scriptsToRun;
#else
// the value assigned to this is a u32 (aiFlags)
// this becomes relevant because aiFlags can have bit 31 set
// and scriptsToRun is shifted
// this never happens in the vanilla game because bit 31 is
// only set when it's the first battle
u32 scriptsToRun;
#endif
s16 bestMovePointsForTarget[MAX_BATTLERS_COUNT];
s8 mostViableTargetsArray[MAX_BATTLERS_COUNT];
u8 actionOrMoveIndex[MAX_BATTLERS_COUNT];
u8 mostViableMovesScores[MAX_MON_MOVES];
u8 mostViableMovesIndices[MAX_MON_MOVES];
s32 mostViableTargetsNo;
s32 mostViableMovesNo;
s16 mostMovePoints;
for (i = 0; i < MAX_BATTLERS_COUNT; i++)
{
if (i == sBattler_AI || gBattleMons[i].hp == 0)
{
actionOrMoveIndex[i] = 0xFF;
bestMovePointsForTarget[i] = -1;
}
else
{
if (gBattleTypeFlags & BATTLE_TYPE_PALACE)
BattleAI_SetupAIData(gBattleStruct->palaceFlags >> 4);
else
BattleAI_SetupAIData((1 << MAX_MON_MOVES) - 1);
gBattlerTarget = i;
if ((i & BIT_SIDE) != (sBattler_AI & BIT_SIDE))
RecordLastUsedMoveByTarget();
AI_THINKING_STRUCT->aiLogicId = 0;
AI_THINKING_STRUCT->movesetIndex = 0;
scriptsToRun = AI_THINKING_STRUCT->aiFlags;
while (scriptsToRun != 0)
{
if (scriptsToRun & 1)
{
AI_THINKING_STRUCT->aiState = AIState_SettingUp;
BattleAI_DoAIProcessing();
}
scriptsToRun >>= 1;
AI_THINKING_STRUCT->aiLogicId++;
AI_THINKING_STRUCT->movesetIndex = 0;
}
if (AI_THINKING_STRUCT->aiAction & AI_ACTION_FLEE)
{
actionOrMoveIndex[i] = AI_CHOICE_FLEE;
}
else if (AI_THINKING_STRUCT->aiAction & AI_ACTION_WATCH)
{
actionOrMoveIndex[i] = AI_CHOICE_WATCH;
}
else
{
mostViableMovesScores[0] = AI_THINKING_STRUCT->score[0];
mostViableMovesIndices[0] = 0;
mostViableMovesNo = 1;
for (j = 1; j < MAX_MON_MOVES; j++)
{
if (gBattleMons[sBattler_AI].moves[j] != 0)
{
if (mostViableMovesScores[0] == AI_THINKING_STRUCT->score[j])
{
mostViableMovesScores[mostViableMovesNo] = AI_THINKING_STRUCT->score[j];
mostViableMovesIndices[mostViableMovesNo] = j;
mostViableMovesNo++;
}
if (mostViableMovesScores[0] < AI_THINKING_STRUCT->score[j])
{
mostViableMovesScores[0] = AI_THINKING_STRUCT->score[j];
mostViableMovesIndices[0] = j;
mostViableMovesNo = 1;
}
}
}
actionOrMoveIndex[i] = mostViableMovesIndices[Random() % mostViableMovesNo];
bestMovePointsForTarget[i] = mostViableMovesScores[0];
// Don't use a move against ally if it has less than 100 points.
if (i == BATTLE_PARTNER(sBattler_AI) && bestMovePointsForTarget[i] < 100)
{
bestMovePointsForTarget[i] = -1;
mostViableMovesScores[0] = mostViableMovesScores[0]; // Needed to match.
}
}
}
}
mostMovePoints = bestMovePointsForTarget[0];
mostViableTargetsArray[0] = 0;
mostViableTargetsNo = 1;
for (i = 1; i < MAX_BATTLERS_COUNT; i++)
{
if (mostMovePoints == bestMovePointsForTarget[i])
{
mostViableTargetsArray[mostViableTargetsNo] = i;
mostViableTargetsNo++;
}
if (mostMovePoints < bestMovePointsForTarget[i])
{
mostMovePoints = bestMovePointsForTarget[i];
mostViableTargetsArray[0] = i;
mostViableTargetsNo = 1;
}
}
gBattlerTarget = mostViableTargetsArray[Random() % mostViableTargetsNo];
return actionOrMoveIndex[gBattlerTarget];
}
static 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 = gBattleAI_ScriptsTable[AI_THINKING_STRUCT->aiLogicId]; // set AI ptr to logic ID.
if (gBattleMons[sBattler_AI].pp[AI_THINKING_STRUCT->movesetIndex] == 0)
{
AI_THINKING_STRUCT->moveConsidered = 0;
}
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;
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))
AI_THINKING_STRUCT->aiState = AIState_SettingUp;
else
AI_THINKING_STRUCT->aiState++;
AI_THINKING_STRUCT->aiAction &= ~(AI_ACTION_DONE);
}
break;
}
}
}
static void RecordLastUsedMoveByTarget(void)
{
s32 i;
for (i = 0; i < MAX_MON_MOVES; i++)
{
if (BATTLE_HISTORY->usedMoves[gBattlerTarget].moves[i] == gLastMoves[gBattlerTarget])
break;
if (BATTLE_HISTORY->usedMoves[gBattlerTarget].moves[i] == MOVE_NONE)
{
BATTLE_HISTORY->usedMoves[gBattlerTarget].moves[i] = gLastMoves[gBattlerTarget];
break;
}
}
}
void ClearBattlerMoveHistory(u8 battlerId)
{
s32 i;
for (i = 0; i < MAX_MON_MOVES; i++)
BATTLE_HISTORY->usedMoves[battlerId].moves[i] = MOVE_NONE;
}
void RecordAbilityBattle(u8 battlerId, u8 abilityId)
{
BATTLE_HISTORY->abilities[battlerId] = abilityId;
}
void ClearBattlerAbilityHistory(u8 battlerId)
{
BATTLE_HISTORY->abilities[battlerId] = ABILITY_NONE;
}
void RecordItemEffectBattle(u8 battlerId, u8 itemEffect)
{
BATTLE_HISTORY->itemEffects[battlerId] = itemEffect;
}
void ClearBattlerItemEffectHistory(u8 battlerId)
{
BATTLE_HISTORY->itemEffects[battlerId] = 0;
}
static void Cmd_if_random_less_than(void)
{
u16 random = Random();
if (random % 256 < gAIScriptPtr[1])
gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 2);
else
gAIScriptPtr += 6;
}
static void Cmd_if_random_greater_than(void)
{
u16 random = Random();
if (random % 256 > gAIScriptPtr[1])
gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 2);
else
gAIScriptPtr += 6;
}
static void Cmd_if_random_equal(void)
{
u16 random = Random();
if (random % 256 == gAIScriptPtr[1])
gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 2);
else
gAIScriptPtr += 6;
}
static void Cmd_if_random_not_equal(void)
{
u16 random = Random();
if (random % 256 != gAIScriptPtr[1])
gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 2);
else
gAIScriptPtr += 6;
}
static void Cmd_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.
}
static void Cmd_if_hp_less_than(void)
{
u16 battlerId;
if (gAIScriptPtr[1] == AI_USER)
battlerId = sBattler_AI;
else
battlerId = gBattlerTarget;
if ((u32)(100 * gBattleMons[battlerId].hp / gBattleMons[battlerId].maxHP) < gAIScriptPtr[2])
gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 3);
else
gAIScriptPtr += 7;
}
static void Cmd_if_hp_more_than(void)
{
u16 battlerId;
if (gAIScriptPtr[1] == AI_USER)
battlerId = sBattler_AI;
else
battlerId = gBattlerTarget;
if ((u32)(100 * gBattleMons[battlerId].hp / gBattleMons[battlerId].maxHP) > gAIScriptPtr[2])
gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 3);
else
gAIScriptPtr += 7;
}
static void Cmd_if_hp_equal(void)
{
u16 battlerId;
if (gAIScriptPtr[1] == AI_USER)
battlerId = sBattler_AI;
else
battlerId = gBattlerTarget;
if ((u32)(100 * gBattleMons[battlerId].hp / gBattleMons[battlerId].maxHP) == gAIScriptPtr[2])
gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 3);
else
gAIScriptPtr += 7;
}
static void Cmd_if_hp_not_equal(void)
{
u16 battlerId;
if (gAIScriptPtr[1] == AI_USER)
battlerId = sBattler_AI;
else
battlerId = gBattlerTarget;
if ((u32)(100 * gBattleMons[battlerId].hp / gBattleMons[battlerId].maxHP) != gAIScriptPtr[2])
gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 3);
else
gAIScriptPtr += 7;
}
static void Cmd_if_status(void)
{
u16 battlerId;
u32 status;
if (gAIScriptPtr[1] == AI_USER)
battlerId = sBattler_AI;
else
battlerId = gBattlerTarget;
status = T1_READ_32(gAIScriptPtr + 2);
if (gBattleMons[battlerId].status1 & status)
gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 6);
else
gAIScriptPtr += 10;
}
static void Cmd_if_not_status(void)
{
u16 battlerId;
u32 status;
if (gAIScriptPtr[1] == AI_USER)
battlerId = sBattler_AI;
else
battlerId = gBattlerTarget;
status = T1_READ_32(gAIScriptPtr + 2);
if (!(gBattleMons[battlerId].status1 & status))
gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 6);
else
gAIScriptPtr += 10;
}
static void Cmd_if_status2(void)
{
u16 battlerId;
u32 status;
if (gAIScriptPtr[1] == AI_USER)
battlerId = sBattler_AI;
else
battlerId = gBattlerTarget;
status = T1_READ_32(gAIScriptPtr + 2);
if ((gBattleMons[battlerId].status2 & status))
gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 6);
else
gAIScriptPtr += 10;
}
static void Cmd_if_not_status2(void)
{
u16 battlerId;
u32 status;
if (gAIScriptPtr[1] == AI_USER)
battlerId = sBattler_AI;
else
battlerId = gBattlerTarget;
status = T1_READ_32(gAIScriptPtr + 2);
if (!(gBattleMons[battlerId].status2 & status))
gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 6);
else
gAIScriptPtr += 10;
}
static void Cmd_if_status3(void)
{
u16 battlerId;
u32 status;
if (gAIScriptPtr[1] == AI_USER)
battlerId = sBattler_AI;
else
battlerId = gBattlerTarget;
status = T1_READ_32(gAIScriptPtr + 2);
if (gStatuses3[battlerId] & status)
gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 6);
else
gAIScriptPtr += 10;
}
static void Cmd_if_not_status3(void)
{
u16 battlerId;
u32 status;
if (gAIScriptPtr[1] == AI_USER)
battlerId = sBattler_AI;
else
battlerId = gBattlerTarget;
status = T1_READ_32(gAIScriptPtr + 2);
if (!(gStatuses3[battlerId] & status))
gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 6);
else
gAIScriptPtr += 10;
}
static void Cmd_if_side_affecting(void)
{
u16 battlerId;
u32 side, status;
if (gAIScriptPtr[1] == AI_USER)
battlerId = sBattler_AI;
else
battlerId = gBattlerTarget;
side = GET_BATTLER_SIDE(battlerId);
status = T1_READ_32(gAIScriptPtr + 2);
if (gSideStatuses[side] & status)
gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 6);
else
gAIScriptPtr += 10;
}
static void Cmd_if_not_side_affecting(void)
{
u16 battlerId;
u32 side, status;
if (gAIScriptPtr[1] == AI_USER)
battlerId = sBattler_AI;
else
battlerId = gBattlerTarget;
side = GET_BATTLER_SIDE(battlerId);
status = T1_READ_32(gAIScriptPtr + 2);
if (!(gSideStatuses[side] & status))
gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 6);
else
gAIScriptPtr += 10;
}
static void Cmd_if_less_than(void)
{
if (AI_THINKING_STRUCT->funcResult < gAIScriptPtr[1])
gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 2);
else
gAIScriptPtr += 6;
}
static void Cmd_if_more_than(void)
{
if (AI_THINKING_STRUCT->funcResult > gAIScriptPtr[1])
gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 2);
else
gAIScriptPtr += 6;
}
static void Cmd_if_equal(void)
{
if (AI_THINKING_STRUCT->funcResult == gAIScriptPtr[1])
gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 2);
else
gAIScriptPtr += 6;
}
static void Cmd_if_not_equal(void)
{
if (AI_THINKING_STRUCT->funcResult != gAIScriptPtr[1])
gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 2);
else
gAIScriptPtr += 6;
}
static void Cmd_if_less_than_ptr(void)
{
const u8 *value = T1_READ_PTR(gAIScriptPtr + 1);
if (AI_THINKING_STRUCT->funcResult < *value)
gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 5);
else
gAIScriptPtr += 9;
}
static void Cmd_if_more_than_ptr(void)
{
const u8 *value = T1_READ_PTR(gAIScriptPtr + 1);
if (AI_THINKING_STRUCT->funcResult > *value)
gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 5);
else
gAIScriptPtr += 9;
}
static void Cmd_if_equal_ptr(void)
{
const u8 *value = T1_READ_PTR(gAIScriptPtr + 1);
if (AI_THINKING_STRUCT->funcResult == *value)
gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 5);
else
gAIScriptPtr += 9;
}
static void Cmd_if_not_equal_ptr(void)
{
const u8 *value = T1_READ_PTR(gAIScriptPtr + 1);
if (AI_THINKING_STRUCT->funcResult != *value)
gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 5);
else
gAIScriptPtr += 9;
}
static void Cmd_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 Cmd_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 Cmd_if_in_bytes(void)
{
const 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 Cmd_if_not_in_bytes(void)
{
const 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 Cmd_if_in_hwords(void)
{
const u16 *ptr = (const 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 Cmd_if_not_in_hwords(void)
{
const u16 *ptr = (const 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 Cmd_if_user_has_attacking_move(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 Cmd_if_user_has_no_attacking_moves(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 Cmd_get_turn_count(void)
{
AI_THINKING_STRUCT->funcResult = gBattleResults.battleTurnCounter;
gAIScriptPtr += 1;
}
static void Cmd_get_type(void)
{
u8 typeVar = gAIScriptPtr[1];
switch (typeVar)
{
case AI_TYPE1_USER: // AI user primary type
AI_THINKING_STRUCT->funcResult = gBattleMons[sBattler_AI].type1;
break;
case AI_TYPE1_TARGET: // target primary type
AI_THINKING_STRUCT->funcResult = gBattleMons[gBattlerTarget].type1;
break;
case AI_TYPE2_USER: // AI user secondary type
AI_THINKING_STRUCT->funcResult = gBattleMons[sBattler_AI].type2;
break;
case AI_TYPE2_TARGET: // target secondary type
AI_THINKING_STRUCT->funcResult = gBattleMons[gBattlerTarget].type2;
break;
case AI_TYPE_MOVE: // type of move being pointed to
AI_THINKING_STRUCT->funcResult = gBattleMoves[AI_THINKING_STRUCT->moveConsidered].type;
break;
}
gAIScriptPtr += 2;
}
static u8 BattleAI_GetWantedBattler(u8 wantedBattler)
{
switch (wantedBattler)
{
case AI_USER:
return sBattler_AI;
case AI_TARGET:
default:
return gBattlerTarget;
case AI_USER_PARTNER:
return BATTLE_PARTNER(sBattler_AI);
case AI_TARGET_PARTNER:
return BATTLE_PARTNER(gBattlerTarget);
}
}
static void Cmd_is_of_type(void)
{
u8 battlerId = BattleAI_GetWantedBattler(gAIScriptPtr[1]);
if (IS_BATTLER_OF_TYPE(battlerId, gAIScriptPtr[2]))
AI_THINKING_STRUCT->funcResult = TRUE;
else
AI_THINKING_STRUCT->funcResult = FALSE;
gAIScriptPtr += 3;
}
static void Cmd_get_considered_move_power(void)
{
AI_THINKING_STRUCT->funcResult = gBattleMoves[AI_THINKING_STRUCT->moveConsidered].power;
gAIScriptPtr += 1;
}
static void Cmd_get_how_powerful_move_is(void)
{
s32 i, checkedMove;
s32 moveDmgs[MAX_MON_MOVES];
for (i = 0; sIgnoredPowerfulMoveEffects[i] != IGNORED_MOVES_END; i++)
{
if (gBattleMoves[AI_THINKING_STRUCT->moveConsidered].effect == sIgnoredPowerfulMoveEffects[i])
break;
}
if (gBattleMoves[AI_THINKING_STRUCT->moveConsidered].power > 1
&& sIgnoredPowerfulMoveEffects[i] == IGNORED_MOVES_END)
{
gDynamicBasePower = 0;
*(&gBattleStruct->dynamicMoveType) = 0;
gBattleScripting.dmgMultiplier = 1;
gMoveResultFlags = 0;
gCritMultiplier = 1;
// Considered move has power and is not in sIgnoredPowerfulMoveEffects
// Check all other moves and calculate their power
for (checkedMove = 0; checkedMove < MAX_MON_MOVES; checkedMove++)
{
for (i = 0; sIgnoredPowerfulMoveEffects[i] != IGNORED_MOVES_END; i++)
{
if (gBattleMoves[gBattleMons[sBattler_AI].moves[checkedMove]].effect == sIgnoredPowerfulMoveEffects[i])
break;
}
if (gBattleMons[sBattler_AI].moves[checkedMove] != MOVE_NONE
&& sIgnoredPowerfulMoveEffects[i] == IGNORED_MOVES_END
&& gBattleMoves[gBattleMons[sBattler_AI].moves[checkedMove]].power > 1)
{
gCurrentMove = gBattleMons[sBattler_AI].moves[checkedMove];
AI_CalcDmg(sBattler_AI, gBattlerTarget);
TypeCalc(gCurrentMove, sBattler_AI, gBattlerTarget);
moveDmgs[checkedMove] = gBattleMoveDamage * AI_THINKING_STRUCT->simulatedRNG[checkedMove] / 100;
if (moveDmgs[checkedMove] == 0)
moveDmgs[checkedMove] = 1;
}
else
{
moveDmgs[checkedMove] = 0;
}
}
// Is the considered move the most powerful move available?
for (checkedMove = 0; checkedMove < MAX_MON_MOVES; checkedMove++)
{
if (moveDmgs[checkedMove] > moveDmgs[AI_THINKING_STRUCT->movesetIndex])
break;
}
if (checkedMove == MAX_MON_MOVES)
AI_THINKING_STRUCT->funcResult = MOVE_MOST_POWERFUL;
else
AI_THINKING_STRUCT->funcResult = MOVE_NOT_MOST_POWERFUL;
}
else
{
// Move has a power of 0/1, or is in the group sIgnoredPowerfulMoveEffects
AI_THINKING_STRUCT->funcResult = MOVE_POWER_OTHER;
}
gAIScriptPtr++;
}
static void Cmd_get_last_used_battler_move(void)
{
if (gAIScriptPtr[1] == AI_USER)
AI_THINKING_STRUCT->funcResult = gLastMoves[sBattler_AI];
else
AI_THINKING_STRUCT->funcResult = gLastMoves[gBattlerTarget];
gAIScriptPtr += 2;
}
static void Cmd_if_equal_(void) // Same as if_equal.
{
if (gAIScriptPtr[1] == AI_THINKING_STRUCT->funcResult)
gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 2);
else
gAIScriptPtr += 6;
}
static void Cmd_if_not_equal_(void) // Same as if_not_equal.
{
if (gAIScriptPtr[1] != AI_THINKING_STRUCT->funcResult)
gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 2);
else
gAIScriptPtr += 6;
}
static void Cmd_if_user_goes(void)
{
if (GetWhoStrikesFirst(sBattler_AI, gBattlerTarget, TRUE) == gAIScriptPtr[1])
gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 2);
else
gAIScriptPtr += 6;
}
static void Cmd_if_user_doesnt_go(void)
{
if (GetWhoStrikesFirst(sBattler_AI, gBattlerTarget, TRUE) != gAIScriptPtr[1])
gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 2);
else
gAIScriptPtr += 6;
}
static void Cmd_nop_2A(void)
{
}
static void Cmd_nop_2B(void)
{
}
static void Cmd_count_usable_party_mons(void)
{
u8 battlerId;
u8 battlerOnField1, battlerOnField2;
struct Pokemon *party;
s32 i;
AI_THINKING_STRUCT->funcResult = 0;
if (gAIScriptPtr[1] == AI_USER)
battlerId = sBattler_AI;
else
battlerId = gBattlerTarget;
if (GetBattlerSide(battlerId) == B_SIDE_PLAYER)
party = gPlayerParty;
else
party = gEnemyParty;
if (gBattleTypeFlags & BATTLE_TYPE_DOUBLE)
{
u32 position;
battlerOnField1 = gBattlerPartyIndexes[battlerId];
position = BATTLE_PARTNER(GetBattlerPosition(battlerId));
battlerOnField2 = gBattlerPartyIndexes[GetBattlerAtPosition(position)];
}
else // In singles there's only one battlerId by side.
{
battlerOnField1 = gBattlerPartyIndexes[battlerId];
battlerOnField2 = gBattlerPartyIndexes[battlerId];
}
for (i = 0; i < PARTY_SIZE; i++)
{
if (i != battlerOnField1 && i != battlerOnField2
&& GetMonData(&party[i], MON_DATA_HP) != 0
&& GetMonData(&party[i], MON_DATA_SPECIES_OR_EGG) != SPECIES_NONE
&& GetMonData(&party[i], MON_DATA_SPECIES_OR_EGG) != SPECIES_EGG)
{
AI_THINKING_STRUCT->funcResult++;
}
}
gAIScriptPtr += 2;
}
static void Cmd_get_considered_move(void)
{
AI_THINKING_STRUCT->funcResult = AI_THINKING_STRUCT->moveConsidered;
gAIScriptPtr += 1;
}
static void Cmd_get_considered_move_effect(void)
{
AI_THINKING_STRUCT->funcResult = gBattleMoves[AI_THINKING_STRUCT->moveConsidered].effect;
gAIScriptPtr += 1;
}
static void Cmd_get_ability(void)
{
u8 battlerId;
if (gAIScriptPtr[1] == AI_USER)
battlerId = sBattler_AI;
else
battlerId = gBattlerTarget;
if (gActiveBattler != battlerId)
{
if (BATTLE_HISTORY->abilities[battlerId] != 0)
{
AI_THINKING_STRUCT->funcResult = BATTLE_HISTORY->abilities[battlerId];
gAIScriptPtr += 2;
return;
}
// abilities that prevent fleeing.
if (gBattleMons[battlerId].ability == ABILITY_SHADOW_TAG
|| gBattleMons[battlerId].ability == ABILITY_MAGNET_PULL
|| gBattleMons[battlerId].ability == ABILITY_ARENA_TRAP)
{
AI_THINKING_STRUCT->funcResult = gBattleMons[battlerId].ability;
gAIScriptPtr += 2;
return;
}
if (gSpeciesInfo[gBattleMons[battlerId].species].abilities[0] != ABILITY_NONE)
{
if (gSpeciesInfo[gBattleMons[battlerId].species].abilities[1] != ABILITY_NONE)
{
// AI has no knowledge of opponent, so it guesses which ability.
if (Random() & 1)
AI_THINKING_STRUCT->funcResult = gSpeciesInfo[gBattleMons[battlerId].species].abilities[0];
else
AI_THINKING_STRUCT->funcResult = gSpeciesInfo[gBattleMons[battlerId].species].abilities[1];
}
else
{
AI_THINKING_STRUCT->funcResult = gSpeciesInfo[gBattleMons[battlerId].species].abilities[0]; // It's definitely ability 1.
}
}
else
{
AI_THINKING_STRUCT->funcResult = gSpeciesInfo[gBattleMons[battlerId].species].abilities[1]; // AI can't actually reach this part since no pokemon has ability 2 and no ability 1.
}
}
else
{
// The AI knows its own ability.
AI_THINKING_STRUCT->funcResult = gBattleMons[battlerId].ability;
}
gAIScriptPtr += 2;
}
static void Cmd_check_ability(void)
{
u32 battlerId = BattleAI_GetWantedBattler(gAIScriptPtr[1]);
u32 ability = gAIScriptPtr[2];
if (gAIScriptPtr[1] == AI_TARGET || gAIScriptPtr[1] == AI_TARGET_PARTNER)
{
if (BATTLE_HISTORY->abilities[battlerId] != ABILITY_NONE)
{
ability = BATTLE_HISTORY->abilities[battlerId];
AI_THINKING_STRUCT->funcResult = ability;
}
// Abilities that prevent fleeing.
else if (gBattleMons[battlerId].ability == ABILITY_SHADOW_TAG
|| gBattleMons[battlerId].ability == ABILITY_MAGNET_PULL
|| gBattleMons[battlerId].ability == ABILITY_ARENA_TRAP)
{
ability = gBattleMons[battlerId].ability;
}
else if (gSpeciesInfo[gBattleMons[battlerId].species].abilities[0] != ABILITY_NONE)
{
if (gSpeciesInfo[gBattleMons[battlerId].species].abilities[1] != ABILITY_NONE)
{
u8 abilityDummyVariable = ability; // Needed to match.
if (gSpeciesInfo[gBattleMons[battlerId].species].abilities[0] != abilityDummyVariable
&& gSpeciesInfo[gBattleMons[battlerId].species].abilities[1] != abilityDummyVariable)
{
ability = gSpeciesInfo[gBattleMons[battlerId].species].abilities[0];
}
else
{
ability = ABILITY_NONE;
}
}
else
{
ability = gSpeciesInfo[gBattleMons[battlerId].species].abilities[0];
}
}
else
{
ability = gSpeciesInfo[gBattleMons[battlerId].species].abilities[1]; // AI can't actually reach this part since no pokemon has ability 2 and no ability 1.
}
}
else
{
// The AI knows its own or partner's ability.
ability = gBattleMons[battlerId].ability;
}
if (ability == 0)
AI_THINKING_STRUCT->funcResult = 2; // Unable to answer.
else if (ability == gAIScriptPtr[2])
AI_THINKING_STRUCT->funcResult = 1; // Pokemon has the ability we wanted to check.
else
AI_THINKING_STRUCT->funcResult = 0; // Pokemon doesn't have the ability we wanted to check.
gAIScriptPtr += 3;
}
static void Cmd_get_highest_type_effectiveness(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 < MAX_MON_MOVES; i++)
{
gBattleMoveDamage = 40;
gCurrentMove = gBattleMons[sBattler_AI].moves[i];
if (gCurrentMove != MOVE_NONE)
{
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 Cmd_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 Cmd_nop_32(void)
{
}
static void Cmd_nop_33(void)
{
}
static void Cmd_if_status_in_party(void)
{
struct Pokemon *party;
s32 i;
u32 statusToCompareTo;
u8 battlerId;
switch (gAIScriptPtr[1])
{
case AI_USER:
battlerId = sBattler_AI;
break;
default:
battlerId = gBattlerTarget;
break;
}
party = (GetBattlerSide(battlerId) == B_SIDE_PLAYER) ? gPlayerParty : gEnemyParty;
statusToCompareTo = T1_READ_32(gAIScriptPtr + 2);
for (i = 0; i < PARTY_SIZE; 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);
return;
}
}
gAIScriptPtr += 10;
}
static void Cmd_if_status_not_in_party(void)
{
struct Pokemon *party;
s32 i;
u32 statusToCompareTo;
u8 battlerId;
switch(gAIScriptPtr[1])
{
case 1:
battlerId = sBattler_AI;
break;
default:
battlerId = gBattlerTarget;
break;
}
party = (GetBattlerSide(battlerId) == B_SIDE_PLAYER) ? gPlayerParty : gEnemyParty;
statusToCompareTo = T1_READ_32(gAIScriptPtr + 2);
for (i = 0; i < PARTY_SIZE; 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 += 10;
#ifdef UBFIX
return;
#endif
}
}
gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 6);
}
static void Cmd_get_weather(void)
{
if (gBattleWeather & B_WEATHER_RAIN)
AI_THINKING_STRUCT->funcResult = AI_WEATHER_RAIN;
if (gBattleWeather & B_WEATHER_SANDSTORM)
AI_THINKING_STRUCT->funcResult = AI_WEATHER_SANDSTORM;
if (gBattleWeather & B_WEATHER_SUN)
AI_THINKING_STRUCT->funcResult = AI_WEATHER_SUN;
if (gBattleWeather & B_WEATHER_HAIL)
AI_THINKING_STRUCT->funcResult = AI_WEATHER_HAIL;
gAIScriptPtr += 1;
}
static void Cmd_if_effect(void)
{
if (gBattleMoves[AI_THINKING_STRUCT->moveConsidered].effect == gAIScriptPtr[1])
gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 2);
else
gAIScriptPtr += 6;
}
static void Cmd_if_not_effect(void)
{
if (gBattleMoves[AI_THINKING_STRUCT->moveConsidered].effect != gAIScriptPtr[1])
gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 2);
else
gAIScriptPtr += 6;
}
static void Cmd_if_stat_level_less_than(void)
{
u32 battlerId;
if (gAIScriptPtr[1] == AI_USER)
battlerId = sBattler_AI;
else
battlerId = gBattlerTarget;
if (gBattleMons[battlerId].statStages[gAIScriptPtr[2]] < gAIScriptPtr[3])
gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 4);
else
gAIScriptPtr += 8;
}
static void Cmd_if_stat_level_more_than(void)
{
u32 battlerId;
if (gAIScriptPtr[1] == AI_USER)
battlerId = sBattler_AI;
else
battlerId = gBattlerTarget;
if (gBattleMons[battlerId].statStages[gAIScriptPtr[2]] > gAIScriptPtr[3])
gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 4);
else
gAIScriptPtr += 8;
}
static void Cmd_if_stat_level_equal(void)
{
u32 battlerId;
if (gAIScriptPtr[1] == AI_USER)
battlerId = sBattler_AI;
else
battlerId = gBattlerTarget;
if (gBattleMons[battlerId].statStages[gAIScriptPtr[2]] == gAIScriptPtr[3])
gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 4);
else
gAIScriptPtr += 8;
}
static void Cmd_if_stat_level_not_equal(void)
{
u32 battlerId;
if (gAIScriptPtr[1] == AI_USER)
battlerId = sBattler_AI;
else
battlerId = gBattlerTarget;
if (gBattleMons[battlerId].statStages[gAIScriptPtr[2]] != gAIScriptPtr[3])
gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 4);
else
gAIScriptPtr += 8;
}
static void Cmd_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 Cmd_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;
#ifdef BUGFIX
// Moves always do at least 1 damage.
if (gBattleMoveDamage == 0)
gBattleMoveDamage = 1;
#endif
if (gBattleMons[gBattlerTarget].hp > gBattleMoveDamage)
gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1);
else
gAIScriptPtr += 5;
}
static void Cmd_if_has_move(void)
{
s32 i;
const u16 *movePtr = (u16 *)(gAIScriptPtr + 2);
switch (gAIScriptPtr[1])
{
case AI_USER:
for (i = 0; i < MAX_MON_MOVES; i++)
{
if (gBattleMons[sBattler_AI].moves[i] == *movePtr)
break;
}
if (i == MAX_MON_MOVES)
gAIScriptPtr += 8;
else
gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 4);
break;
case AI_USER_PARTNER:
if (gBattleMons[BATTLE_PARTNER(sBattler_AI)].hp == 0)
{
gAIScriptPtr += 8;
break;
}
else
{
for (i = 0; i < MAX_MON_MOVES; i++)
{
if (gBattleMons[BATTLE_PARTNER(sBattler_AI)].moves[i] == *movePtr)
break;
}
}
if (i == MAX_MON_MOVES)
gAIScriptPtr += 8;
else
gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 4);
break;
case AI_TARGET:
case AI_TARGET_PARTNER:
for (i = 0; i < MAX_MON_MOVES; i++)
{
if (BATTLE_HISTORY->usedMoves[gBattlerTarget].moves[i] == *movePtr)
break;
}
if (i == MAX_MON_MOVES)
gAIScriptPtr += 8;
else
gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 4);
break;
}
}
static void Cmd_if_doesnt_have_move(void)
{
s32 i;
const u16 *movePtr = (u16 *)(gAIScriptPtr + 2);
switch(gAIScriptPtr[1])
{
case AI_USER:
case AI_USER_PARTNER: // UB: no separate check for user partner.
for (i = 0; i < MAX_MON_MOVES; i++)
{
if (gBattleMons[sBattler_AI].moves[i] == *movePtr)
break;
}
if (i != MAX_MON_MOVES)
gAIScriptPtr += 8;
else
gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 4);
break;
case AI_TARGET:
case AI_TARGET_PARTNER:
for (i = 0; i < MAX_MON_MOVES; i++)
{
if (BATTLE_HISTORY->usedMoves[gBattlerTarget].moves[i] == *movePtr)
break;
}
if (i != MAX_MON_MOVES)
gAIScriptPtr += 8;
else
gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 4);
break;
}
}
static void Cmd_if_has_move_with_effect(void)
{
s32 i;
switch (gAIScriptPtr[1])
{
case AI_USER:
case AI_USER_PARTNER:
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 AI_TARGET:
case AI_TARGET_PARTNER:
for (i = 0; i < MAX_MON_MOVES; i++)
{
// BUG: checks sBattler_AI instead of gBattlerTarget.
#ifndef BUGFIX
if (gBattleMons[sBattler_AI].moves[i] != 0 && gBattleMoves[BATTLE_HISTORY->usedMoves[gBattlerTarget].moves[i]].effect == gAIScriptPtr[2])
break;
#else
if (gBattleMons[gBattlerTarget].moves[i] != 0 && gBattleMoves[BATTLE_HISTORY->usedMoves[gBattlerTarget].moves[i]].effect == gAIScriptPtr[2])
break;
#endif
}
if (i == MAX_MON_MOVES)
gAIScriptPtr += 7;
else
gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 3);
break;
}
}
static void Cmd_if_doesnt_have_move_with_effect(void)
{
s32 i;
switch (gAIScriptPtr[1])
{
case AI_USER:
case AI_USER_PARTNER:
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 AI_TARGET:
case AI_TARGET_PARTNER:
for (i = 0; i < MAX_MON_MOVES; i++)
{
if (BATTLE_HISTORY->usedMoves[gBattlerTarget].moves[i] && gBattleMoves[BATTLE_HISTORY->usedMoves[gBattlerTarget].moves[i]].effect == gAIScriptPtr[2])
break;
}
if (i != MAX_MON_MOVES)
gAIScriptPtr += 7;
else
gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 3);
break;
}
}
static void Cmd_if_any_move_disabled_or_encored(void)
{
u8 battlerId;
if (gAIScriptPtr[1] == AI_USER)
battlerId = sBattler_AI;
else
battlerId = gBattlerTarget;
if (gAIScriptPtr[2] == 0)
{
if (gDisableStructs[battlerId].disabledMove == MOVE_NONE)
gAIScriptPtr += 7;
else
gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 3);
}
else if (gAIScriptPtr[2] != 1)
{
gAIScriptPtr += 7;
}
else
{
if (gDisableStructs[battlerId].encoredMove != MOVE_NONE)
gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 3);
else
gAIScriptPtr += 7;
}
}
static void Cmd_if_curr_move_disabled_or_encored(void)
{
switch (gAIScriptPtr[1])
{
case 0:
if (gDisableStructs[gActiveBattler].disabledMove == AI_THINKING_STRUCT->moveConsidered)
gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 2);
else
gAIScriptPtr += 6;
break;
case 1:
if (gDisableStructs[gActiveBattler].encoredMove == AI_THINKING_STRUCT->moveConsidered)
gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 2);
else
gAIScriptPtr += 6;
break;
default:
gAIScriptPtr += 6;
break;
}
}
static void Cmd_flee(void)
{
AI_THINKING_STRUCT->aiAction |= (AI_ACTION_DONE | AI_ACTION_FLEE | AI_ACTION_DO_NOT_ATTACK);
}
static void Cmd_if_random_safari_flee(void)
{
u8 safariFleeRate = gBattleStruct->safariEscapeFactor * 5; // Safari flee rate, from 0-20.
if ((u8)(Random() % 100) < safariFleeRate)
gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1);
else
gAIScriptPtr += 5;
}
static void Cmd_watch(void)
{
AI_THINKING_STRUCT->aiAction |= (AI_ACTION_DONE | AI_ACTION_WATCH | AI_ACTION_DO_NOT_ATTACK);
}
static void Cmd_get_hold_effect(void)
{
u8 battlerId;
if (gAIScriptPtr[1] == AI_USER)
battlerId = sBattler_AI;
else
battlerId = gBattlerTarget;
if (gActiveBattler != battlerId)
AI_THINKING_STRUCT->funcResult = ItemId_GetHoldEffect(BATTLE_HISTORY->itemEffects[battlerId]);
else
AI_THINKING_STRUCT->funcResult = ItemId_GetHoldEffect(gBattleMons[battlerId].item);
gAIScriptPtr += 2;
}
static void Cmd_if_holds_item(void)
{
u8 battlerId = BattleAI_GetWantedBattler(gAIScriptPtr[1]);
u16 item;
u8 itemLo, itemHi;
if ((battlerId & BIT_SIDE) == (sBattler_AI & BIT_SIDE))
item = gBattleMons[battlerId].item;
else
item = BATTLE_HISTORY->itemEffects[battlerId];
itemHi = gAIScriptPtr[2];
itemLo = gAIScriptPtr[3];
#ifdef BUGFIX
// This bug doesn't affect the vanilla game because this script command
// is only used to check ITEM_PERSIM_BERRY, whose high byte happens to
// be 0.
if (((itemHi << 8) | itemLo) == item)
#else
if ((itemLo | itemHi) == item)
#endif
gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 4);
else
gAIScriptPtr += 8;
}
static void Cmd_get_gender(void)
{
u8 battlerId;
if (gAIScriptPtr[1] == AI_USER)
battlerId = sBattler_AI;
else
battlerId = gBattlerTarget;
AI_THINKING_STRUCT->funcResult = GetGenderFromSpeciesAndPersonality(gBattleMons[battlerId].species, gBattleMons[battlerId].personality);
gAIScriptPtr += 2;
}
static void Cmd_is_first_turn_for(void)
{
u8 battlerId;
if (gAIScriptPtr[1] == AI_USER)
battlerId = sBattler_AI;
else
battlerId = gBattlerTarget;
AI_THINKING_STRUCT->funcResult = gDisableStructs[battlerId].isFirstTurn;
gAIScriptPtr += 2;
}
static void Cmd_get_stockpile_count(void)
{
u8 battlerId;
if (gAIScriptPtr[1] == AI_USER)
battlerId = sBattler_AI;
else
battlerId = gBattlerTarget;
AI_THINKING_STRUCT->funcResult = gDisableStructs[battlerId].stockpileCounter;
gAIScriptPtr += 2;
}
static void Cmd_is_double_battle(void)
{
AI_THINKING_STRUCT->funcResult = gBattleTypeFlags & BATTLE_TYPE_DOUBLE;
gAIScriptPtr += 1;
}
static void Cmd_get_used_held_item(void)
{
u8 battlerId;
if (gAIScriptPtr[1] == AI_USER)
battlerId = sBattler_AI;
else
battlerId = gBattlerTarget;
AI_THINKING_STRUCT->funcResult = *(u8 *)&gBattleStruct->usedHeldItems[battlerId];
gAIScriptPtr += 2;
}
static void Cmd_get_move_type_from_result(void)
{
AI_THINKING_STRUCT->funcResult = gBattleMoves[AI_THINKING_STRUCT->funcResult].type;
gAIScriptPtr += 1;
}
static void Cmd_get_move_power_from_result(void)
{
AI_THINKING_STRUCT->funcResult = gBattleMoves[AI_THINKING_STRUCT->funcResult].power;
gAIScriptPtr += 1;
}
static void Cmd_get_move_effect_from_result(void)
{
AI_THINKING_STRUCT->funcResult = gBattleMoves[AI_THINKING_STRUCT->funcResult].effect;
gAIScriptPtr += 1;
}
static void Cmd_get_protect_count(void)
{
u8 battlerId;
if (gAIScriptPtr[1] == AI_USER)
battlerId = sBattler_AI;
else
battlerId = gBattlerTarget;
AI_THINKING_STRUCT->funcResult = gDisableStructs[battlerId].protectUses;
gAIScriptPtr += 2;
}
static void Cmd_nop_52(void)
{
}
static void Cmd_nop_53(void)
{
}
static void Cmd_nop_54(void)
{
}
static void Cmd_nop_55(void)
{
}
static void Cmd_nop_56(void)
{
}
static void Cmd_nop_57(void)
{
}
static void Cmd_call(void)
{
AIStackPushVar(gAIScriptPtr + 5);
gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1);
}
static void Cmd_goto(void)
{
gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1);
}
static void Cmd_end(void)
{
if (AIStackPop() == 0)
AI_THINKING_STRUCT->aiAction |= AI_ACTION_DONE;
}
static void Cmd_if_level_cond(void)
{
switch (gAIScriptPtr[1])
{
case 0: // greater than
if (gBattleMons[sBattler_AI].level > gBattleMons[gBattlerTarget].level)
gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 2);
else
gAIScriptPtr += 6;
break;
case 1: // less than
if (gBattleMons[sBattler_AI].level < gBattleMons[gBattlerTarget].level)
gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 2);
else
gAIScriptPtr += 6;
break;
case 2: // equal
if (gBattleMons[sBattler_AI].level == gBattleMons[gBattlerTarget].level)
gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 2);
else
gAIScriptPtr += 6;
break;
}
}
static void Cmd_if_target_taunted(void)
{
if (gDisableStructs[gBattlerTarget].tauntTimer != 0)
gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1);
else
gAIScriptPtr += 5;
}
static void Cmd_if_target_not_taunted(void)
{
if (gDisableStructs[gBattlerTarget].tauntTimer == 0)
gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1);
else
gAIScriptPtr += 5;
}
static void Cmd_if_target_is_ally(void)
{
if ((sBattler_AI & BIT_SIDE) == (gBattlerTarget & BIT_SIDE))
gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1);
else
gAIScriptPtr += 5;
}
static void Cmd_if_flash_fired(void)
{
u8 battlerId = BattleAI_GetWantedBattler(gAIScriptPtr[1]);
if (gBattleResources->flags->flags[battlerId] & RESOURCE_FLAG_FLASH_FIRE)
gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 2);
else
gAIScriptPtr += 6;
}
static void AIStackPushVar(const u8 *var)
{
gBattleResources->AI_ScriptsStack->ptr[gBattleResources->AI_ScriptsStack->size++] = var;
}
static void AIStackPushVar_cursor(void)
{
gBattleResources->AI_ScriptsStack->ptr[gBattleResources->AI_ScriptsStack->size++] = gAIScriptPtr;
}
static 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;
}
}
View Git Blame Copy Permalink