2277 lines
66 KiB
C
2277 lines
66 KiB
C
#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/moves.h"
|
|
|
|
#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
|
|
};
|
|
|
|
/*
|
|
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
|
|
};
|
|
|
|
// code
|
|
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] != 0)
|
|
{
|
|
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) + (GetBattlerSide(gActiveBattler) ^ BIT_SIDE);
|
|
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.
|
|
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 == (sBattler_AI ^ BIT_FLANK) && 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 sBattler_AI ^ BIT_FLANK;
|
|
case AI_TARGET_PARTNER:
|
|
return gBattlerTarget ^ BIT_FLANK;
|
|
}
|
|
}
|
|
|
|
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 = GetBattlerPosition(battlerId) ^ BIT_FLANK;
|
|
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_SPECIES2) != SPECIES_NONE
|
|
&& GetMonData(&party[i], MON_DATA_SPECIES2) != 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 (gBaseStats[gBattleMons[battlerId].species].abilities[0] != ABILITY_NONE)
|
|
{
|
|
if (gBaseStats[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 = gBaseStats[gBattleMons[battlerId].species].abilities[0];
|
|
else
|
|
AI_THINKING_STRUCT->funcResult = gBaseStats[gBattleMons[battlerId].species].abilities[1];
|
|
}
|
|
else
|
|
{
|
|
AI_THINKING_STRUCT->funcResult = gBaseStats[gBattleMons[battlerId].species].abilities[0]; // It's definitely ability 1.
|
|
}
|
|
}
|
|
else
|
|
{
|
|
AI_THINKING_STRUCT->funcResult = gBaseStats[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 (gBaseStats[gBattleMons[battlerId].species].abilities[0] != ABILITY_NONE)
|
|
{
|
|
if (gBaseStats[gBattleMons[battlerId].species].abilities[1] != ABILITY_NONE)
|
|
{
|
|
u8 abilityDummyVariable = ability; // Needed to match.
|
|
if (gBaseStats[gBattleMons[battlerId].species].abilities[0] != abilityDummyVariable
|
|
&& gBaseStats[gBattleMons[battlerId].species].abilities[1] != abilityDummyVariable)
|
|
{
|
|
ability = gBaseStats[gBattleMons[battlerId].species].abilities[0];
|
|
}
|
|
else
|
|
{
|
|
ability = ABILITY_NONE;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ability = gBaseStats[gBattleMons[battlerId].species].abilities[0];
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ability = gBaseStats[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[sBattler_AI ^ BIT_FLANK].hp == 0)
|
|
{
|
|
gAIScriptPtr += 8;
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
for (i = 0; i < MAX_MON_MOVES; i++)
|
|
{
|
|
if (gBattleMons[sBattler_AI ^ BIT_FLANK].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;
|
|
}
|
|
}
|