Decomped DecideAttack()

1 files changed, 289 insertions, 43 deletions

diff --git a/src/dungeon_ai_attack.c b/src/dungeon_ai_attack.c
index 5794038..e695422 100644
--- a/src/dungeon_ai_attack.c
+++ b/src/dungeon_ai_attack.c
@@ -1,76 +1,322 @@
 #include "global.h"
 #include "dungeon_ai_attack.h"
 
+#include "constants/direction.h"
+#include "constants/dungeon_action.h"
 #include "constants/iq_skill.h"
-#include "dungeon_global_data.h"
-#include "dungeon_map_access.h"
+#include "constants/move_id.h"
+#include "constants/status.h"
+#include "constants/tactic.h"
+#include "constants/type.h"
+#include "dungeon_action.h"
+#include "dungeon_ai.h"
+#include "dungeon_capabilities_1.h"
+#include "dungeon_pokemon_attributes.h"
 #include "dungeon_pokemon_attributes_1.h"
-#include "dungeon_util.h"
+#include "dungeon_random.h"
+#include "dungeon_random_1.h"
+#include "moves.h"
+#include "status_checks.h"
 
-bool8 IsTargetStraightAhead(struct DungeonEntity *pokemon, struct DungeonEntity *targetPokemon, s32 facingDir, s32 maxRange)
+#define REGULAR_ATTACK_INDEX 4
+
+const s16 gRegularAttackWeights[] = {100, 20, 30, 40, 50};
+
+struct MoveTargetResults
+{
+    bool8 moveUsable;
+    u8 targetDir;
+    s32 moveWeight;
+};
+
+extern bool8 IsChargeMove(struct DungeonEntity*, struct PokemonMove*);
+extern void TargetTileInFront(struct DungeonEntity*);
+extern s32 FindMoveTarget(struct MoveTargetResults*, struct DungeonEntity*, struct PokemonMove*);
+extern bool8 IsMoveUsable(struct DungeonEntity*, s32, bool8);
+extern bool8 TargetRegularAttack(struct DungeonEntity*, u32*, bool8);
+
+void DecideAttack(struct DungeonEntity *pokemon)
 {
-    s32 posDiffX = pokemon->posWorld.x - targetPokemon->posWorld.x;
-    s32 effectiveMaxRange;
-    if (posDiffX < 0)
+    struct DungeonEntityData *pokemonData = pokemon->entityData;
+    s32 i;
+    s32 chargeStatus = CHARGING_STATUS_CHARGE;
+    struct MoveTargetResults moveTargetResults[MAX_MON_MOVES + 1];
+    bool8 willNotUnlinkMove[MAX_MON_MOVES];
+    s32 randomWeight;
+    bool8 hasPPChecker;
+    s32 numUsableMoves;
+    s32 total;
+    s32 weightCounter;
+    bool8 hasWeakTypePicker;
+    s32 regularAttackTargetDir;
+    bool8 canTargetRegularAttack;
+    s32 maxWeight;
+    if (CannotAttack(pokemon, FALSE) ||
+        ShouldAvoidEnemiesAndShowEffect(pokemon, TRUE) ||
+        HasTactic(pokemon, TACTIC_KEEP_YOUR_DISTANCE) ||
+        (pokemonData->volatileStatus == VOLATILE_STATUS_CONFUSED && RollPercentChance(gConfusedAttackChance)))
     {
-        posDiffX = -posDiffX;
+        return;
     }
-    effectiveMaxRange = pokemon->posWorld.y - targetPokemon->posWorld.y;
-    if (effectiveMaxRange < 0)
+    if (pokemonData->chargingStatus != CHARGING_STATUS_NONE)
     {
-        effectiveMaxRange = -effectiveMaxRange;
+        for (i = 0; i < MAX_MON_MOVES; i++)
+        {
+            if (pokemonData->moves[i].moveFlags & MOVE_FLAG_EXISTS &&
+                IsChargeMove(pokemon, &pokemonData->moves[i]) &&
+                pokemonData->chargingStatusMoveIndex == i)
+            {
+                s32 chosenMoveIndex;
+                SetAction(&pokemonData->action, DUNGEON_ACTION_USE_MOVE_AI);
+                chosenMoveIndex = i;
+                if (i > 0 && pokemonData->moves[i].moveFlags & MOVE_FLAG_LINKED)
+                {
+                    while (--chosenMoveIndex > 0)
+                    {
+                        if (!(pokemonData->moves[chosenMoveIndex].moveFlags & MOVE_FLAG_LINKED))
+                        {
+                            break;
+                        }
+                    }
+                }
+                pokemonData->action.actionUseIndex = chosenMoveIndex;
+                TargetTileInFront(pokemon);
+                return;
+            }
+        }
     }
-    if (effectiveMaxRange < posDiffX)
+    total = 0;
+    numUsableMoves = 0;
+    for (i = 0; i < MAX_MON_MOVES; i++)
     {
-        effectiveMaxRange = posDiffX;
+        struct PokemonMove *move = &pokemonData->moves[i];
+        if (pokemonData->moves[i].moveFlags & MOVE_FLAG_EXISTS)
+        {
+            if (pokemonData->moves[i].moveFlags & MOVE_FLAG_ENABLED)
+            {
+                numUsableMoves++;
+            }
+            total += move->PP;
+        }
+    }
+    if (total == 0)
+    {
+        struct PokemonMove struggle;
+        InitPokemonMove(&struggle, MOVE_STRUGGLE);
+        FindMoveTarget(&moveTargetResults[0], pokemon, &struggle);
+        if (moveTargetResults[0].moveUsable)
+        {
+            SetAction(&pokemonData->action, DUNGEON_ACTION_STRUGGLE);
+            pokemonData->action.facingDir = moveTargetResults[0].targetDir & DIRECTION_MASK;
+            TargetTileInFront(pokemon);
+        }
+        return;
     }
-    if (effectiveMaxRange > maxRange)
+    hasWeakTypePicker = HasIQSkill(pokemon, IQ_SKILL_WEAK_TYPE_PICKER);
+    hasPPChecker = HasIQSkill(pokemon, IQ_SKILL_PP_CHECKER) != FALSE;
+    total = 0;
+    for (i = 0; i < MAX_MON_MOVES; i++)
     {
-        effectiveMaxRange = maxRange;
+        willNotUnlinkMove[i] = TRUE;
     }
-    if (!HasIQSkill(pokemon, IQ_SKILL_COURSE_CHECKER))
+    if (hasPPChecker)
     {
-        // BUG: effectiveMaxRange is already capped at maxRange, so this condition always evaluates to TRUE.
-        // The AI also has range checks elsewhere, so this doesn't become an issue in most cases.
-        // If the AI has the Long Toss or Pierce statuses and Course Checker is disabled,
-        // this incorrect check causes the AI to throw items at targets further than 10 tiles away.
-        if (effectiveMaxRange <= maxRange)
+        s32 minPP = 99;
+        s32 linkedMoveStartIndex = 0;
+        // Linked moves unlink if any move in the chain runs out of PP.
+        // With PP Checker, the AI avoids this by not using linked moves if any move in the chain has 1 PP left.
+        // This requires a separate check from the 0-PP check used for unlinked moves.
+        for (i = 0; i < MAX_MON_MOVES; i++)
         {
-            return TRUE;
+            struct PokemonMove *move = &pokemonData->moves[i];
+            if (!(move->moveFlags & MOVE_FLAG_EXISTS))
+            {
+                break;
+            }
+            if (i != 0 && !(move->moveFlags & MOVE_FLAG_LINKED))
+            {
+                if (linkedMoveStartIndex + 1 < i && minPP <= 1 && linkedMoveStartIndex + 1 <= i)
+                {
+                    s32 j;
+                    for (j = linkedMoveStartIndex; j < i; j++)
+                    {
+                        willNotUnlinkMove[j] = FALSE;
+                    }
+                }
+                minPP = move->PP;
+                linkedMoveStartIndex = i;
+            }
+            else
+            {
+                s32 newMinPP = move->PP;
+                if (newMinPP > minPP)
+                {
+                    newMinPP = minPP;
+                }
+                minPP = newMinPP;
+            }
+        }
+        if (linkedMoveStartIndex + 1 < i && minPP <= 1 && linkedMoveStartIndex + 1 <= i)
+        {
+            s32 j;
+            for (j = linkedMoveStartIndex; j < i; j++)
+            {
+                willNotUnlinkMove[j] = FALSE;
+            }
         }
     }
-    else
+    for (i = 0; i < MAX_MON_MOVES; i++)
+    {
+        struct PokemonMove *move;
+        moveTargetResults[i].moveUsable = FALSE;
+        move = &pokemonData->moves[i];
+        if (move->moveFlags & MOVE_FLAG_EXISTS &&
+            willNotUnlinkMove[i] &&
+            IsMoveUsable(pokemon, i, hasPPChecker) &&
+            move->moveFlags & MOVE_FLAG_ENABLED)
+        {
+            moveTargetResults[i].moveUsable = TRUE;
+            if (pokemonData->chargingStatus == chargeStatus)
+            {
+                if (move->moveID == MOVE_CHARGE)
+                {
+                    moveTargetResults[i].moveWeight = 0;
+                    continue;
+                }
+                else if (GetMoveTypeForPokemon(pokemon, move) == TYPE_ELECTRIC)
+                {
+                    moveTargetResults[i].moveWeight = GetMoveWeight(move);
+                }
+                else
+                {
+                    moveTargetResults[i].moveWeight = 1;
+                }
+            }
+            else if (hasWeakTypePicker)
+            {
+                struct MoveTargetResults *results = &moveTargetResults[i];
+                results->moveWeight = FindMoveTarget(results, pokemon, move);
+            }
+            else
+            {
+                moveTargetResults[i].moveWeight = GetMoveWeight(move);
+            }
+            total += moveTargetResults[i].moveWeight;
+        }
+    }
+    moveTargetResults[REGULAR_ATTACK_INDEX].moveWeight = 0;
+    if (!HasIQSkill(pokemon, IQ_SKILL_EXCLUSIVE_MOVE_USER) && pokemonData->chargingStatus != chargeStatus)
+    {
+        moveTargetResults[REGULAR_ATTACK_INDEX].moveUsable = TRUE;
+        if (pokemonData->chargingStatus == chargeStatus)
+        {
+            // Never reached? Charge already skips the regular attack in the outer block.
+            moveTargetResults[REGULAR_ATTACK_INDEX].moveWeight = 1;
+        }
+        else if (hasWeakTypePicker)
+        {
+            moveTargetResults[REGULAR_ATTACK_INDEX].moveWeight = 2;
+        }
+        else
+        {
+            moveTargetResults[REGULAR_ATTACK_INDEX].moveWeight = gRegularAttackWeights[numUsableMoves];
+        }
+        total += moveTargetResults[REGULAR_ATTACK_INDEX].moveWeight;
+    }
+    if (hasWeakTypePicker)
     {
-        s32 currentPosX = pokemon->posWorld.x;
-        s32 currentPosY = pokemon->posWorld.y;
-        s32 adjacentTileOffsetX = gAdjacentTileOffsets[facingDir].x;
-        s32 adjacentTileOffsetY = gAdjacentTileOffsets[facingDir].y;
         s32 i;
-        for (i = 0; i <= effectiveMaxRange; i++)
+        maxWeight = 0;
+        total = 0;
+        for (i = 0; i < MAX_MON_MOVES + 1; i++)
         {
-            struct MapTile *mapTile;
-            currentPosX += adjacentTileOffsetX;
-            currentPosY += adjacentTileOffsetY;
-            if (currentPosX <= 0 || currentPosY <= 0 ||
-                currentPosX >= DUNGEON_MAX_SIZE_X - 1 || currentPosY >= DUNGEON_MAX_SIZE_Y - 1)
+            if (!moveTargetResults[i].moveUsable)
             {
-                break;
+                moveTargetResults[i].moveWeight = 0;
             }
-            while (0); // Extra label needed to swap branch locations in ASM.
-            mapTile = GetMapTileAtPosition(currentPosX, currentPosY);
-            if (!(mapTile->tileType & (TILE_TYPE_FLOOR | TILE_TYPE_LIQUID)))
+            else if (maxWeight < moveTargetResults[i].moveWeight)
             {
-                break;
+                maxWeight = moveTargetResults[i].moveWeight;
             }
-            if (mapTile->pokemon == targetPokemon)
+        }
+        for (i = 0; i < MAX_MON_MOVES + 1; i++)
+        {
+            if (moveTargetResults[i].moveUsable)
             {
-                return TRUE;
+                if (maxWeight != moveTargetResults[i].moveWeight)
+                {
+                    moveTargetResults[i].moveWeight = 0;
+                }
+                total += moveTargetResults[i].moveWeight;
             }
-            if (mapTile->pokemon != NULL)
+        }
+    }
+    if (total == 0)
+    {
+        return;
+    }
+    randomWeight = DungeonRandomCapped(total);
+    weightCounter = 0;
+    if (!HasIQSkill(pokemon, IQ_SKILL_EXCLUSIVE_MOVE_USER))
+    {
+        canTargetRegularAttack = TargetRegularAttack(pokemon, &regularAttackTargetDir, TRUE);
+    }
+    else
+    {
+        canTargetRegularAttack = FALSE;
+        regularAttackTargetDir = DIRECTION_SOUTH;
+    }
+    for (i = 0; i <= REGULAR_ATTACK_INDEX; i++)
+    {
+        if (moveTargetResults[i].moveUsable && moveTargetResults[i].moveWeight != 0)
+        {
+            weightCounter += moveTargetResults[i].moveWeight;
+            if (weightCounter >= randomWeight)
             {
-                break;
+                if (i == REGULAR_ATTACK_INDEX)
+                {
+                    if (canTargetRegularAttack)
+                    {
+                        SetAction(&pokemonData->action, DUNGEON_ACTION_REGULAR_ATTACK);
+                        pokemonData->action.facingDir = regularAttackTargetDir & DIRECTION_MASK;
+                        TargetTileInFront(pokemon);
+                    }
+                }
+                else
+                {
+                    FindMoveTarget(&moveTargetResults[i], pokemon, &pokemonData->moves[i]);
+                    if (moveTargetResults[i].moveUsable)
+                    {
+                        s32 chosenMoveIndex;
+                        SetAction(&pokemonData->action, DUNGEON_ACTION_USE_MOVE_AI);
+                        chosenMoveIndex = i;
+                        if (i > 0 && pokemonData->moves[i].moveFlags & MOVE_FLAG_LINKED)
+                        {
+                            while (--chosenMoveIndex > 0)
+                            {
+                                if (!(pokemonData->moves[chosenMoveIndex].moveFlags & MOVE_FLAG_LINKED))
+                                {
+                                    break;
+                                }
+                            }
+                        }
+                        pokemonData->action.facingDir = moveTargetResults[i].targetDir & DIRECTION_MASK;
+                        pokemonData->action.actionUseIndex = chosenMoveIndex;
+                        TargetTileInFront(pokemon);
+                    }
+                    else
+                    {
+                        break;
+                    }
+                }
+                return;
             }
         }
     }
-    return FALSE;
+    if (canTargetRegularAttack)
+    {
+        SetAction(&pokemonData->action, DUNGEON_ACTION_REGULAR_ATTACK);
+        pokemonData->action.facingDir = regularAttackTargetDir & DIRECTION_MASK;
+        TargetTileInFront(pokemon);
+    }
 }