pmdsky-debug-py 10.1.14__py3-none-any.whl → 10.1.15__py3-none-any.whl

pmdsky_debug_py/_release.py

@@ -1 +1 @@
-RELEASE = "v0.10.1+70cc918e1d"
+RELEASE = "v0.10.1+a4a9e51e2c"

pmdsky_debug_py/eu.py

@@ -3049,11 +3049,11 @@ class EuArm9Functions:
         None,
     )
 
-    IsMoveRangeString19 = Symbol(
+    IsMoveRangeStringUser = Symbol(
         [0x13CAC],
         [0x2013CAC],
         None,
-        "IsMoveRangeString19",
+        "IsMoveRangeStringUser",
         "Returns whether a move's range string is 19 ('User').\n\nr0: Move pointer\nreturn: True if the move's range string field has a value of 19.",
         None,
     )
@@ -9261,6 +9261,8 @@ class EuArm9Functions:
         "DirectoryFile_LoadDirectoryFile", LoadFileInPack
     )
 
+    IsMoveRangeString19 = _Deprecated("IsMoveRangeString19", IsMoveRangeStringUser)
+
     GetLowKickMultiplier = _Deprecated("GetLowKickMultiplier", GetWeightMultiplier)
 
 
@@ -26054,6 +26056,15 @@ class EuOverlay29Functions:
         None,
     )
 
+    CanMonsterMoveOrSwapWithAllyInDirection = Symbol(
+        [0x25004],
+        [0x2301B84],
+        None,
+        "CanMonsterMoveOrSwapWithAllyInDirection",
+        "Checks if the given monster can move in the specified direction. Includes if an allied or neutral monster is standing on an adjacent tile, as the monsters can swap places.\n\nReturns false if an enemy monster is standing on the target tile\n\nr0: Monster entity pointer\nr1: Direction to check\nreturn: bool",
+        None,
+    )
+
     CanAttackInDirection = Symbol(
         [0x250E0],
         [0x2301C60],
@@ -27962,12 +27973,21 @@ class EuOverlay29Functions:
         None,
     )
 
+    ResetAiCanAttackInDirection = Symbol(
+        [0x3D73C],
+        [0x231A2BC],
+        None,
+        "ResetAiCanAttackInDirection",
+        "Resets all entries in AI_CAN_ATTACK_IN_DIRECTION to false.\n\nNo params.",
+        None,
+    )
+
     AiConsiderMove = Symbol(
         [0x3D760],
         [0x231A2E0],
         None,
         "AiConsiderMove",
-        "The AI uses this function to check if a move has any potential targets, to calculate the list of potential targets and to calculate the move's special weight.\nThis weight will be higher if the pokémon has weak-type picker and the target is weak to the move (allies only, enemies always get a result of 1 even if the move is super effective). More things could affect the result.\nThis function also sets the flag can_be_used on the ai_possible_move struct if it makes sense to use it.\nMore research is needed. There's more documentation about this special weight. Does all the documented behavior happen in this function?\n\nr0: ai_possible_move struct for this move\nr1: Entity pointer\nr2: Move pointer\nreturn: Move's calculated special weight",
+        "The AI uses this function to check if a move has any potential targets, to calculate the list of potential targets and to calculate the move's special weight. The weight is calculated using WeightMoveWithIqSkills.\nThis function also sets the flag can_be_used on the ai_possible_move struct if it makes sense to use it.\n\nThe weight returned by this function is not the same as GetMoveAiWeight. If the AI does not have Weak-Type Picker, AiConsiderMove is called after the AI has selected which move it will use (using GetMoveAiWeight). It determines whether it makes sense for the AI to actually use the chosen move (i.e., whether targets are in range), and which direction the AI will use the move in if so. The return value of this function is not used anywhere in this case.\n\nIf the AI has Weak-Type Picker, the AI calls this function earlier in the AI logic to determine which move to use, using the returned special weight to find which move has the most advantageous type matchups.\n\nr0: ai_possible_move struct for this move\nr1: Entity pointer\nr2: Move pointer\nreturn: Move's calculated special weight",
         None,
     )
 
@@ -27989,6 +28009,15 @@ class EuOverlay29Functions:
         None,
     )
 
+    WeightMoveWithIqSkills = Symbol(
+        [0x3E244],
+        [0x231ADC4],
+        None,
+        "WeightMoveWithIqSkills",
+        "Calculates a move weight used for deciding which target the move should be used on. If the user is an ally, the target is an enemy Pokémon, and the user has Exp. Go-Getter, Efficiency Expert, or Weak-Type Picker enabled, this function calculates a move weight based on that IQ skill's functionality. Otherwise, this function returns a weight of 1.\n\nr0: User entity pointer\nr1: Move's AI range field\nr2: Target entity pointer\nr3: Move type\nreturn: Move weight for deciding move targeting.",
+        None,
+    )
+
     TargetRegularAttack = Symbol(
         [0x3E340],
         [0x231AEC0],
@@ -31353,8 +31382,8 @@ class EuOverlay29Data:
     )
 
     DIRECTIONAL_BIT_MASKS = Symbol(
-        [0x76824],
-        [0x23533A4],
+        [0x767FC, 0x76804, 0x7680C, 0x76814, 0x7681C, 0x76824],
+        [0x235337C, 0x2353384, 0x235338C, 0x2353394, 0x235339C, 0x23533A4],
         0x8,
         "DIRECTIONAL_BIT_MASKS",
         "An array of one-hot bit masks corresponding to each direction_id. Used alongside tile->walkable_neighbor_flags to determine whether it's possible to move to a tile.",
@@ -33470,6 +33499,42 @@ class EuRamData:
         "uint32_t[8]",
     )
 
+    AI_CAN_ATTACK_IN_DIRECTION = Symbol(
+        [0x37D618],
+        [0x237D618],
+        0x8,
+        "AI_CAN_ATTACK_IN_DIRECTION",
+        "[Runtime] Stores whether the AI can use an attack in each direction.",
+        "bool[8]",
+    )
+
+    AI_POTENTIAL_ATTACK_TARGET_DIRECTIONS = Symbol(
+        [0x37D620],
+        [0x237D620],
+        0x8,
+        "AI_POTENTIAL_ATTACK_TARGET_DIRECTIONS",
+        "[Runtime] Stores the directions that the AI can use an attack in. Parallel to AI_POTENTIAL_ATTACK_TARGET_WEIGHTS and AI_POTENTIAL_ATTACK_TARGETS.",
+        "struct direction_id_8[8]",
+    )
+
+    AI_POTENTIAL_ATTACK_TARGET_WEIGHTS = Symbol(
+        [0x37D628],
+        [0x237D628],
+        0x20,
+        "AI_POTENTIAL_ATTACK_TARGET_WEIGHTS",
+        "[Runtime] Stores the targeting weights for each direction the AI can use an attack in. Parallel to AI_POTENTIAL_ATTACK_TARGET_DIRECTIONS and AI_POTENTIAL_ATTACK_TARGETS.",
+        "uint32_t[8]",
+    )
+
+    AI_POTENTIAL_ATTACK_TARGETS = Symbol(
+        [0x37D648],
+        [0x237D648],
+        0x20,
+        "AI_POTENTIAL_ATTACK_TARGETS",
+        "[Runtime] Stores the target entity for each direction the AI can use an attack in. Parallel to AI_POTENTIAL_ATTACK_TARGET_DIRECTIONS and AI_POTENTIAL_ATTACK_TARGET_DIRECTIONS.",
+        "struct entity*[8]",
+    )
+
     ROLLOUT_ICE_BALL_MISSED = Symbol(
         [0x37D669],
         [0x237D669],

pmdsky_debug_py/eu_itcm.py

@@ -3003,11 +3003,11 @@ class EuItcmArm9Functions:
         None,
     )
 
-    IsMoveRangeString19 = Symbol(
+    IsMoveRangeStringUser = Symbol(
         None,
         None,
         None,
-        "IsMoveRangeString19",
+        "IsMoveRangeStringUser",
         "Returns whether a move's range string is 19 ('User').\n\nr0: Move pointer\nreturn: True if the move's range string field has a value of 19.",
         None,
     )
@@ -9215,6 +9215,8 @@ class EuItcmArm9Functions:
         "DirectoryFile_LoadDirectoryFile", LoadFileInPack
     )
 
+    IsMoveRangeString19 = _Deprecated("IsMoveRangeString19", IsMoveRangeStringUser)
+
     GetLowKickMultiplier = _Deprecated("GetLowKickMultiplier", GetWeightMultiplier)
 
 
@@ -25479,6 +25481,15 @@ class EuItcmOverlay29Functions:
         None,
     )
 
+    CanMonsterMoveOrSwapWithAllyInDirection = Symbol(
+        None,
+        None,
+        None,
+        "CanMonsterMoveOrSwapWithAllyInDirection",
+        "Checks if the given monster can move in the specified direction. Includes if an allied or neutral monster is standing on an adjacent tile, as the monsters can swap places.\n\nReturns false if an enemy monster is standing on the target tile\n\nr0: Monster entity pointer\nr1: Direction to check\nreturn: bool",
+        None,
+    )
+
     CanAttackInDirection = Symbol(
         None,
         None,
@@ -27387,12 +27398,21 @@ class EuItcmOverlay29Functions:
         None,
     )
 
+    ResetAiCanAttackInDirection = Symbol(
+        None,
+        None,
+        None,
+        "ResetAiCanAttackInDirection",
+        "Resets all entries in AI_CAN_ATTACK_IN_DIRECTION to false.\n\nNo params.",
+        None,
+    )
+
     AiConsiderMove = Symbol(
         None,
         None,
         None,
         "AiConsiderMove",
-        "The AI uses this function to check if a move has any potential targets, to calculate the list of potential targets and to calculate the move's special weight.\nThis weight will be higher if the pokémon has weak-type picker and the target is weak to the move (allies only, enemies always get a result of 1 even if the move is super effective). More things could affect the result.\nThis function also sets the flag can_be_used on the ai_possible_move struct if it makes sense to use it.\nMore research is needed. There's more documentation about this special weight. Does all the documented behavior happen in this function?\n\nr0: ai_possible_move struct for this move\nr1: Entity pointer\nr2: Move pointer\nreturn: Move's calculated special weight",
+        "The AI uses this function to check if a move has any potential targets, to calculate the list of potential targets and to calculate the move's special weight. The weight is calculated using WeightMoveWithIqSkills.\nThis function also sets the flag can_be_used on the ai_possible_move struct if it makes sense to use it.\n\nThe weight returned by this function is not the same as GetMoveAiWeight. If the AI does not have Weak-Type Picker, AiConsiderMove is called after the AI has selected which move it will use (using GetMoveAiWeight). It determines whether it makes sense for the AI to actually use the chosen move (i.e., whether targets are in range), and which direction the AI will use the move in if so. The return value of this function is not used anywhere in this case.\n\nIf the AI has Weak-Type Picker, the AI calls this function earlier in the AI logic to determine which move to use, using the returned special weight to find which move has the most advantageous type matchups.\n\nr0: ai_possible_move struct for this move\nr1: Entity pointer\nr2: Move pointer\nreturn: Move's calculated special weight",
         None,
     )
 
@@ -27414,6 +27434,15 @@ class EuItcmOverlay29Functions:
         None,
     )
 
+    WeightMoveWithIqSkills = Symbol(
+        None,
+        None,
+        None,
+        "WeightMoveWithIqSkills",
+        "Calculates a move weight used for deciding which target the move should be used on. If the user is an ally, the target is an enemy Pokémon, and the user has Exp. Go-Getter, Efficiency Expert, or Weak-Type Picker enabled, this function calculates a move weight based on that IQ skill's functionality. Otherwise, this function returns a weight of 1.\n\nr0: User entity pointer\nr1: Move's AI range field\nr2: Target entity pointer\nr3: Move type\nreturn: Move weight for deciding move targeting.",
+        None,
+    )
+
     TargetRegularAttack = Symbol(
         None,
         None,
@@ -32748,6 +32777,42 @@ class EuItcmRamData:
         "uint32_t[8]",
     )
 
+    AI_CAN_ATTACK_IN_DIRECTION = Symbol(
+        None,
+        None,
+        None,
+        "AI_CAN_ATTACK_IN_DIRECTION",
+        "[Runtime] Stores whether the AI can use an attack in each direction.",
+        "bool[8]",
+    )
+
+    AI_POTENTIAL_ATTACK_TARGET_DIRECTIONS = Symbol(
+        None,
+        None,
+        None,
+        "AI_POTENTIAL_ATTACK_TARGET_DIRECTIONS",
+        "[Runtime] Stores the directions that the AI can use an attack in. Parallel to AI_POTENTIAL_ATTACK_TARGET_WEIGHTS and AI_POTENTIAL_ATTACK_TARGETS.",
+        "struct direction_id_8[8]",
+    )
+
+    AI_POTENTIAL_ATTACK_TARGET_WEIGHTS = Symbol(
+        None,
+        None,
+        None,
+        "AI_POTENTIAL_ATTACK_TARGET_WEIGHTS",
+        "[Runtime] Stores the targeting weights for each direction the AI can use an attack in. Parallel to AI_POTENTIAL_ATTACK_TARGET_DIRECTIONS and AI_POTENTIAL_ATTACK_TARGETS.",
+        "uint32_t[8]",
+    )
+
+    AI_POTENTIAL_ATTACK_TARGETS = Symbol(
+        None,
+        None,
+        None,
+        "AI_POTENTIAL_ATTACK_TARGETS",
+        "[Runtime] Stores the target entity for each direction the AI can use an attack in. Parallel to AI_POTENTIAL_ATTACK_TARGET_DIRECTIONS and AI_POTENTIAL_ATTACK_TARGET_DIRECTIONS.",
+        "struct entity*[8]",
+    )
+
     ROLLOUT_ICE_BALL_MISSED = Symbol(
         None,
         None,

pmdsky_debug_py/jp.py

@@ -3049,11 +3049,11 @@ class JpArm9Functions:
         None,
     )
 
-    IsMoveRangeString19 = Symbol(
+    IsMoveRangeStringUser = Symbol(
         [0x13BD4],
         [0x2013BD4],
         None,
-        "IsMoveRangeString19",
+        "IsMoveRangeStringUser",
         "Returns whether a move's range string is 19 ('User').\n\nr0: Move pointer\nreturn: True if the move's range string field has a value of 19.",
         None,
     )
@@ -9261,6 +9261,8 @@ class JpArm9Functions:
         "DirectoryFile_LoadDirectoryFile", LoadFileInPack
     )
 
+    IsMoveRangeString19 = _Deprecated("IsMoveRangeString19", IsMoveRangeStringUser)
+
     GetLowKickMultiplier = _Deprecated("GetLowKickMultiplier", GetWeightMultiplier)
 
 
@@ -26045,6 +26047,15 @@ class JpOverlay29Functions:
         None,
     )
 
+    CanMonsterMoveOrSwapWithAllyInDirection = Symbol(
+        [0x24C7C],
+        [0x230255C],
+        None,
+        "CanMonsterMoveOrSwapWithAllyInDirection",
+        "Checks if the given monster can move in the specified direction. Includes if an allied or neutral monster is standing on an adjacent tile, as the monsters can swap places.\n\nReturns false if an enemy monster is standing on the target tile\n\nr0: Monster entity pointer\nr1: Direction to check\nreturn: bool",
+        None,
+    )
+
     CanAttackInDirection = Symbol(
         [0x24DB4],
         [0x2302694],
@@ -27953,12 +27964,21 @@ class JpOverlay29Functions:
         None,
     )
 
+    ResetAiCanAttackInDirection = Symbol(
+        [0x3D44C],
+        [0x231AD2C],
+        None,
+        "ResetAiCanAttackInDirection",
+        "Resets all entries in AI_CAN_ATTACK_IN_DIRECTION to false.\n\nNo params.",
+        None,
+    )
+
     AiConsiderMove = Symbol(
         [0x3D470],
         [0x231AD50],
         None,
         "AiConsiderMove",
-        "The AI uses this function to check if a move has any potential targets, to calculate the list of potential targets and to calculate the move's special weight.\nThis weight will be higher if the pokémon has weak-type picker and the target is weak to the move (allies only, enemies always get a result of 1 even if the move is super effective). More things could affect the result.\nThis function also sets the flag can_be_used on the ai_possible_move struct if it makes sense to use it.\nMore research is needed. There's more documentation about this special weight. Does all the documented behavior happen in this function?\n\nr0: ai_possible_move struct for this move\nr1: Entity pointer\nr2: Move pointer\nreturn: Move's calculated special weight",
+        "The AI uses this function to check if a move has any potential targets, to calculate the list of potential targets and to calculate the move's special weight. The weight is calculated using WeightMoveWithIqSkills.\nThis function also sets the flag can_be_used on the ai_possible_move struct if it makes sense to use it.\n\nThe weight returned by this function is not the same as GetMoveAiWeight. If the AI does not have Weak-Type Picker, AiConsiderMove is called after the AI has selected which move it will use (using GetMoveAiWeight). It determines whether it makes sense for the AI to actually use the chosen move (i.e., whether targets are in range), and which direction the AI will use the move in if so. The return value of this function is not used anywhere in this case.\n\nIf the AI has Weak-Type Picker, the AI calls this function earlier in the AI logic to determine which move to use, using the returned special weight to find which move has the most advantageous type matchups.\n\nr0: ai_possible_move struct for this move\nr1: Entity pointer\nr2: Move pointer\nreturn: Move's calculated special weight",
         None,
     )
 
@@ -27980,6 +28000,15 @@ class JpOverlay29Functions:
         None,
     )
 
+    WeightMoveWithIqSkills = Symbol(
+        [0x3DF54],
+        [0x231B834],
+        None,
+        "WeightMoveWithIqSkills",
+        "Calculates a move weight used for deciding which target the move should be used on. If the user is an ally, the target is an enemy Pokémon, and the user has Exp. Go-Getter, Efficiency Expert, or Weak-Type Picker enabled, this function calculates a move weight based on that IQ skill's functionality. Otherwise, this function returns a weight of 1.\n\nr0: User entity pointer\nr1: Move's AI range field\nr2: Target entity pointer\nr3: Move type\nreturn: Move weight for deciding move targeting.",
+        None,
+    )
+
     TargetRegularAttack = Symbol(
         [0x3E050],
         [0x231B930],
@@ -31246,8 +31275,8 @@ class JpOverlay29Data:
     )
 
     DIRECTIONAL_BIT_MASKS = Symbol(
-        [0x76138],
-        [0x2353A18],
+        [0x76110, 0x76118, 0x76120, 0x76128, 0x76130, 0x76138],
+        [0x23539F0, 0x23539F8, 0x2353A00, 0x2353A08, 0x2353A10, 0x2353A18],
         0x8,
         "DIRECTIONAL_BIT_MASKS",
         "An array of one-hot bit masks corresponding to each direction_id. Used alongside tile->walkable_neighbor_flags to determine whether it's possible to move to a tile.",
@@ -33358,6 +33387,42 @@ class JpRamData:
         "uint32_t[8]",
     )
 
+    AI_CAN_ATTACK_IN_DIRECTION = Symbol(
+        [0x37DC98],
+        [0x237DC98],
+        0x8,
+        "AI_CAN_ATTACK_IN_DIRECTION",
+        "[Runtime] Stores whether the AI can use an attack in each direction.",
+        "bool[8]",
+    )
+
+    AI_POTENTIAL_ATTACK_TARGET_DIRECTIONS = Symbol(
+        [0x37DCA0],
+        [0x237DCA0],
+        0x8,
+        "AI_POTENTIAL_ATTACK_TARGET_DIRECTIONS",
+        "[Runtime] Stores the directions that the AI can use an attack in. Parallel to AI_POTENTIAL_ATTACK_TARGET_WEIGHTS and AI_POTENTIAL_ATTACK_TARGETS.",
+        "struct direction_id_8[8]",
+    )
+
+    AI_POTENTIAL_ATTACK_TARGET_WEIGHTS = Symbol(
+        [0x37DCA8],
+        [0x237DCA8],
+        0x20,
+        "AI_POTENTIAL_ATTACK_TARGET_WEIGHTS",
+        "[Runtime] Stores the targeting weights for each direction the AI can use an attack in. Parallel to AI_POTENTIAL_ATTACK_TARGET_DIRECTIONS and AI_POTENTIAL_ATTACK_TARGETS.",
+        "uint32_t[8]",
+    )
+
+    AI_POTENTIAL_ATTACK_TARGETS = Symbol(
+        [0x37DCC8],
+        [0x237DCC8],
+        0x20,
+        "AI_POTENTIAL_ATTACK_TARGETS",
+        "[Runtime] Stores the target entity for each direction the AI can use an attack in. Parallel to AI_POTENTIAL_ATTACK_TARGET_DIRECTIONS and AI_POTENTIAL_ATTACK_TARGET_DIRECTIONS.",
+        "struct entity*[8]",
+    )
+
     ROLLOUT_ICE_BALL_MISSED = Symbol(
         [0x37DCE9],
         [0x237DCE9],

pmdsky_debug_py/jp_itcm.py

@@ -3003,11 +3003,11 @@ class JpItcmArm9Functions:
         None,
     )
 
-    IsMoveRangeString19 = Symbol(
+    IsMoveRangeStringUser = Symbol(
         None,
         None,
         None,
-        "IsMoveRangeString19",
+        "IsMoveRangeStringUser",
         "Returns whether a move's range string is 19 ('User').\n\nr0: Move pointer\nreturn: True if the move's range string field has a value of 19.",
         None,
     )
@@ -9215,6 +9215,8 @@ class JpItcmArm9Functions:
         "DirectoryFile_LoadDirectoryFile", LoadFileInPack
     )
 
+    IsMoveRangeString19 = _Deprecated("IsMoveRangeString19", IsMoveRangeStringUser)
+
     GetLowKickMultiplier = _Deprecated("GetLowKickMultiplier", GetWeightMultiplier)
 
 
@@ -25479,6 +25481,15 @@ class JpItcmOverlay29Functions:
         None,
     )
 
+    CanMonsterMoveOrSwapWithAllyInDirection = Symbol(
+        None,
+        None,
+        None,
+        "CanMonsterMoveOrSwapWithAllyInDirection",
+        "Checks if the given monster can move in the specified direction. Includes if an allied or neutral monster is standing on an adjacent tile, as the monsters can swap places.\n\nReturns false if an enemy monster is standing on the target tile\n\nr0: Monster entity pointer\nr1: Direction to check\nreturn: bool",
+        None,
+    )
+
     CanAttackInDirection = Symbol(
         None,
         None,
@@ -27387,12 +27398,21 @@ class JpItcmOverlay29Functions:
         None,
     )
 
+    ResetAiCanAttackInDirection = Symbol(
+        None,
+        None,
+        None,
+        "ResetAiCanAttackInDirection",
+        "Resets all entries in AI_CAN_ATTACK_IN_DIRECTION to false.\n\nNo params.",
+        None,
+    )
+
     AiConsiderMove = Symbol(
         None,
         None,
         None,
         "AiConsiderMove",
-        "The AI uses this function to check if a move has any potential targets, to calculate the list of potential targets and to calculate the move's special weight.\nThis weight will be higher if the pokémon has weak-type picker and the target is weak to the move (allies only, enemies always get a result of 1 even if the move is super effective). More things could affect the result.\nThis function also sets the flag can_be_used on the ai_possible_move struct if it makes sense to use it.\nMore research is needed. There's more documentation about this special weight. Does all the documented behavior happen in this function?\n\nr0: ai_possible_move struct for this move\nr1: Entity pointer\nr2: Move pointer\nreturn: Move's calculated special weight",
+        "The AI uses this function to check if a move has any potential targets, to calculate the list of potential targets and to calculate the move's special weight. The weight is calculated using WeightMoveWithIqSkills.\nThis function also sets the flag can_be_used on the ai_possible_move struct if it makes sense to use it.\n\nThe weight returned by this function is not the same as GetMoveAiWeight. If the AI does not have Weak-Type Picker, AiConsiderMove is called after the AI has selected which move it will use (using GetMoveAiWeight). It determines whether it makes sense for the AI to actually use the chosen move (i.e., whether targets are in range), and which direction the AI will use the move in if so. The return value of this function is not used anywhere in this case.\n\nIf the AI has Weak-Type Picker, the AI calls this function earlier in the AI logic to determine which move to use, using the returned special weight to find which move has the most advantageous type matchups.\n\nr0: ai_possible_move struct for this move\nr1: Entity pointer\nr2: Move pointer\nreturn: Move's calculated special weight",
         None,
     )
 
@@ -27414,6 +27434,15 @@ class JpItcmOverlay29Functions:
         None,
     )
 
+    WeightMoveWithIqSkills = Symbol(
+        None,
+        None,
+        None,
+        "WeightMoveWithIqSkills",
+        "Calculates a move weight used for deciding which target the move should be used on. If the user is an ally, the target is an enemy Pokémon, and the user has Exp. Go-Getter, Efficiency Expert, or Weak-Type Picker enabled, this function calculates a move weight based on that IQ skill's functionality. Otherwise, this function returns a weight of 1.\n\nr0: User entity pointer\nr1: Move's AI range field\nr2: Target entity pointer\nr3: Move type\nreturn: Move weight for deciding move targeting.",
+        None,
+    )
+
     TargetRegularAttack = Symbol(
         None,
         None,
@@ -32748,6 +32777,42 @@ class JpItcmRamData:
         "uint32_t[8]",
     )
 
+    AI_CAN_ATTACK_IN_DIRECTION = Symbol(
+        None,
+        None,
+        None,
+        "AI_CAN_ATTACK_IN_DIRECTION",
+        "[Runtime] Stores whether the AI can use an attack in each direction.",
+        "bool[8]",
+    )
+
+    AI_POTENTIAL_ATTACK_TARGET_DIRECTIONS = Symbol(
+        None,
+        None,
+        None,
+        "AI_POTENTIAL_ATTACK_TARGET_DIRECTIONS",
+        "[Runtime] Stores the directions that the AI can use an attack in. Parallel to AI_POTENTIAL_ATTACK_TARGET_WEIGHTS and AI_POTENTIAL_ATTACK_TARGETS.",
+        "struct direction_id_8[8]",
+    )
+
+    AI_POTENTIAL_ATTACK_TARGET_WEIGHTS = Symbol(
+        None,
+        None,
+        None,
+        "AI_POTENTIAL_ATTACK_TARGET_WEIGHTS",
+        "[Runtime] Stores the targeting weights for each direction the AI can use an attack in. Parallel to AI_POTENTIAL_ATTACK_TARGET_DIRECTIONS and AI_POTENTIAL_ATTACK_TARGETS.",
+        "uint32_t[8]",
+    )
+
+    AI_POTENTIAL_ATTACK_TARGETS = Symbol(
+        None,
+        None,
+        None,
+        "AI_POTENTIAL_ATTACK_TARGETS",
+        "[Runtime] Stores the target entity for each direction the AI can use an attack in. Parallel to AI_POTENTIAL_ATTACK_TARGET_DIRECTIONS and AI_POTENTIAL_ATTACK_TARGET_DIRECTIONS.",
+        "struct entity*[8]",
+    )
+
     ROLLOUT_ICE_BALL_MISSED = Symbol(
         None,
         None,

pmdsky_debug_py/na.py

@@ -3049,11 +3049,11 @@ class NaArm9Functions:
         None,
     )
 
-    IsMoveRangeString19 = Symbol(
+    IsMoveRangeStringUser = Symbol(
         [0x13C04],
         [0x2013C04],
         None,
-        "IsMoveRangeString19",
+        "IsMoveRangeStringUser",
         "Returns whether a move's range string is 19 ('User').\n\nr0: Move pointer\nreturn: True if the move's range string field has a value of 19.",
         None,
     )
@@ -9261,6 +9261,8 @@ class NaArm9Functions:
         "DirectoryFile_LoadDirectoryFile", LoadFileInPack
     )
 
+    IsMoveRangeString19 = _Deprecated("IsMoveRangeString19", IsMoveRangeStringUser)
+
     GetLowKickMultiplier = _Deprecated("GetLowKickMultiplier", GetWeightMultiplier)
 
 
@@ -26052,6 +26054,15 @@ class NaOverlay29Functions:
         None,
     )
 
+    CanMonsterMoveOrSwapWithAllyInDirection = Symbol(
+        [0x24F18],
+        [0x2301158],
+        None,
+        "CanMonsterMoveOrSwapWithAllyInDirection",
+        "Checks if the given monster can move in the specified direction. Includes if an allied or neutral monster is standing on an adjacent tile, as the monsters can swap places.\n\nReturns false if an enemy monster is standing on the target tile\n\nr0: Monster entity pointer\nr1: Direction to check\nreturn: bool",
+        None,
+    )
+
     CanAttackInDirection = Symbol(
         [0x24FF4],
         [0x2301234],
@@ -27960,12 +27971,21 @@ class NaOverlay29Functions:
         None,
     )
 
+    ResetAiCanAttackInDirection = Symbol(
+        [0x3D61C],
+        [0x231985C],
+        None,
+        "ResetAiCanAttackInDirection",
+        "Resets all entries in AI_CAN_ATTACK_IN_DIRECTION to false.\n\nNo params.",
+        None,
+    )
+
     AiConsiderMove = Symbol(
         [0x3D640],
         [0x2319880],
         None,
         "AiConsiderMove",
-        "The AI uses this function to check if a move has any potential targets, to calculate the list of potential targets and to calculate the move's special weight.\nThis weight will be higher if the pokémon has weak-type picker and the target is weak to the move (allies only, enemies always get a result of 1 even if the move is super effective). More things could affect the result.\nThis function also sets the flag can_be_used on the ai_possible_move struct if it makes sense to use it.\nMore research is needed. There's more documentation about this special weight. Does all the documented behavior happen in this function?\n\nr0: ai_possible_move struct for this move\nr1: Entity pointer\nr2: Move pointer\nreturn: Move's calculated special weight",
+        "The AI uses this function to check if a move has any potential targets, to calculate the list of potential targets and to calculate the move's special weight. The weight is calculated using WeightMoveWithIqSkills.\nThis function also sets the flag can_be_used on the ai_possible_move struct if it makes sense to use it.\n\nThe weight returned by this function is not the same as GetMoveAiWeight. If the AI does not have Weak-Type Picker, AiConsiderMove is called after the AI has selected which move it will use (using GetMoveAiWeight). It determines whether it makes sense for the AI to actually use the chosen move (i.e., whether targets are in range), and which direction the AI will use the move in if so. The return value of this function is not used anywhere in this case.\n\nIf the AI has Weak-Type Picker, the AI calls this function earlier in the AI logic to determine which move to use, using the returned special weight to find which move has the most advantageous type matchups.\n\nr0: ai_possible_move struct for this move\nr1: Entity pointer\nr2: Move pointer\nreturn: Move's calculated special weight",
         None,
     )
 
@@ -27987,6 +28007,15 @@ class NaOverlay29Functions:
         None,
     )
 
+    WeightMoveWithIqSkills = Symbol(
+        [0x3E124],
+        [0x231A364],
+        None,
+        "WeightMoveWithIqSkills",
+        "Calculates a move weight used for deciding which target the move should be used on. If the user is an ally, the target is an enemy Pokémon, and the user has Exp. Go-Getter, Efficiency Expert, or Weak-Type Picker enabled, this function calculates a move weight based on that IQ skill's functionality. Otherwise, this function returns a weight of 1.\n\nr0: User entity pointer\nr1: Move's AI range field\nr2: Target entity pointer\nr3: Move type\nreturn: Move weight for deciding move targeting.",
+        None,
+    )
+
     TargetRegularAttack = Symbol(
         [0x3E220],
         [0x231A460],
@@ -31351,8 +31380,8 @@ class NaOverlay29Data:
     )
 
     DIRECTIONAL_BIT_MASKS = Symbol(
-        [0x76558],
-        [0x2352798],
+        [0x76530, 0x76538, 0x76540, 0x76548, 0x76550, 0x76558],
+        [0x2352770, 0x2352778, 0x2352780, 0x2352788, 0x2352790, 0x2352798],
         0x8,
         "DIRECTIONAL_BIT_MASKS",
         "An array of one-hot bit masks corresponding to each direction_id. Used alongside tile->walkable_neighbor_flags to determine whether it's possible to move to a tile.",
@@ -33468,6 +33497,42 @@ class NaRamData:
         "uint32_t[8]",
     )
 
+    AI_CAN_ATTACK_IN_DIRECTION = Symbol(
+        [0x37CA18],
+        [0x237CA18],
+        0x8,
+        "AI_CAN_ATTACK_IN_DIRECTION",
+        "[Runtime] Stores whether the AI can use an attack in each direction.",
+        "bool[8]",
+    )
+
+    AI_POTENTIAL_ATTACK_TARGET_DIRECTIONS = Symbol(
+        [0x37CA20],
+        [0x237CA20],
+        0x8,
+        "AI_POTENTIAL_ATTACK_TARGET_DIRECTIONS",
+        "[Runtime] Stores the directions that the AI can use an attack in. Parallel to AI_POTENTIAL_ATTACK_TARGET_WEIGHTS and AI_POTENTIAL_ATTACK_TARGETS.",
+        "struct direction_id_8[8]",
+    )
+
+    AI_POTENTIAL_ATTACK_TARGET_WEIGHTS = Symbol(
+        [0x37CA28],
+        [0x237CA28],
+        0x20,
+        "AI_POTENTIAL_ATTACK_TARGET_WEIGHTS",
+        "[Runtime] Stores the targeting weights for each direction the AI can use an attack in. Parallel to AI_POTENTIAL_ATTACK_TARGET_DIRECTIONS and AI_POTENTIAL_ATTACK_TARGETS.",
+        "uint32_t[8]",
+    )
+
+    AI_POTENTIAL_ATTACK_TARGETS = Symbol(
+        [0x37CA48],
+        [0x237CA48],
+        0x20,
+        "AI_POTENTIAL_ATTACK_TARGETS",
+        "[Runtime] Stores the target entity for each direction the AI can use an attack in. Parallel to AI_POTENTIAL_ATTACK_TARGET_DIRECTIONS and AI_POTENTIAL_ATTACK_TARGET_DIRECTIONS.",
+        "struct entity*[8]",
+    )
+
     ROLLOUT_ICE_BALL_MISSED = Symbol(
         [0x37CA69],
         [0x237CA69],

pmdsky_debug_py/na_itcm.py

@@ -3003,11 +3003,11 @@ class NaItcmArm9Functions:
         None,
     )
 
-    IsMoveRangeString19 = Symbol(
+    IsMoveRangeStringUser = Symbol(
         None,
         None,
         None,
-        "IsMoveRangeString19",
+        "IsMoveRangeStringUser",
         "Returns whether a move's range string is 19 ('User').\n\nr0: Move pointer\nreturn: True if the move's range string field has a value of 19.",
         None,
     )
@@ -9215,6 +9215,8 @@ class NaItcmArm9Functions:
         "DirectoryFile_LoadDirectoryFile", LoadFileInPack
     )
 
+    IsMoveRangeString19 = _Deprecated("IsMoveRangeString19", IsMoveRangeStringUser)
+
     GetLowKickMultiplier = _Deprecated("GetLowKickMultiplier", GetWeightMultiplier)
 
 
@@ -25479,6 +25481,15 @@ class NaItcmOverlay29Functions:
         None,
     )
 
+    CanMonsterMoveOrSwapWithAllyInDirection = Symbol(
+        None,
+        None,
+        None,
+        "CanMonsterMoveOrSwapWithAllyInDirection",
+        "Checks if the given monster can move in the specified direction. Includes if an allied or neutral monster is standing on an adjacent tile, as the monsters can swap places.\n\nReturns false if an enemy monster is standing on the target tile\n\nr0: Monster entity pointer\nr1: Direction to check\nreturn: bool",
+        None,
+    )
+
     CanAttackInDirection = Symbol(
         None,
         None,
@@ -27387,12 +27398,21 @@ class NaItcmOverlay29Functions:
         None,
     )
 
+    ResetAiCanAttackInDirection = Symbol(
+        None,
+        None,
+        None,
+        "ResetAiCanAttackInDirection",
+        "Resets all entries in AI_CAN_ATTACK_IN_DIRECTION to false.\n\nNo params.",
+        None,
+    )
+
     AiConsiderMove = Symbol(
         None,
         None,
         None,
         "AiConsiderMove",
-        "The AI uses this function to check if a move has any potential targets, to calculate the list of potential targets and to calculate the move's special weight.\nThis weight will be higher if the pokémon has weak-type picker and the target is weak to the move (allies only, enemies always get a result of 1 even if the move is super effective). More things could affect the result.\nThis function also sets the flag can_be_used on the ai_possible_move struct if it makes sense to use it.\nMore research is needed. There's more documentation about this special weight. Does all the documented behavior happen in this function?\n\nr0: ai_possible_move struct for this move\nr1: Entity pointer\nr2: Move pointer\nreturn: Move's calculated special weight",
+        "The AI uses this function to check if a move has any potential targets, to calculate the list of potential targets and to calculate the move's special weight. The weight is calculated using WeightMoveWithIqSkills.\nThis function also sets the flag can_be_used on the ai_possible_move struct if it makes sense to use it.\n\nThe weight returned by this function is not the same as GetMoveAiWeight. If the AI does not have Weak-Type Picker, AiConsiderMove is called after the AI has selected which move it will use (using GetMoveAiWeight). It determines whether it makes sense for the AI to actually use the chosen move (i.e., whether targets are in range), and which direction the AI will use the move in if so. The return value of this function is not used anywhere in this case.\n\nIf the AI has Weak-Type Picker, the AI calls this function earlier in the AI logic to determine which move to use, using the returned special weight to find which move has the most advantageous type matchups.\n\nr0: ai_possible_move struct for this move\nr1: Entity pointer\nr2: Move pointer\nreturn: Move's calculated special weight",
         None,
     )
 
@@ -27414,6 +27434,15 @@ class NaItcmOverlay29Functions:
         None,
     )
 
+    WeightMoveWithIqSkills = Symbol(
+        None,
+        None,
+        None,
+        "WeightMoveWithIqSkills",
+        "Calculates a move weight used for deciding which target the move should be used on. If the user is an ally, the target is an enemy Pokémon, and the user has Exp. Go-Getter, Efficiency Expert, or Weak-Type Picker enabled, this function calculates a move weight based on that IQ skill's functionality. Otherwise, this function returns a weight of 1.\n\nr0: User entity pointer\nr1: Move's AI range field\nr2: Target entity pointer\nr3: Move type\nreturn: Move weight for deciding move targeting.",
+        None,
+    )
+
     TargetRegularAttack = Symbol(
         None,
         None,
@@ -32748,6 +32777,42 @@ class NaItcmRamData:
         "uint32_t[8]",
     )
 
+    AI_CAN_ATTACK_IN_DIRECTION = Symbol(
+        None,
+        None,
+        None,
+        "AI_CAN_ATTACK_IN_DIRECTION",
+        "[Runtime] Stores whether the AI can use an attack in each direction.",
+        "bool[8]",
+    )
+
+    AI_POTENTIAL_ATTACK_TARGET_DIRECTIONS = Symbol(
+        None,
+        None,
+        None,
+        "AI_POTENTIAL_ATTACK_TARGET_DIRECTIONS",
+        "[Runtime] Stores the directions that the AI can use an attack in. Parallel to AI_POTENTIAL_ATTACK_TARGET_WEIGHTS and AI_POTENTIAL_ATTACK_TARGETS.",
+        "struct direction_id_8[8]",
+    )
+
+    AI_POTENTIAL_ATTACK_TARGET_WEIGHTS = Symbol(
+        None,
+        None,
+        None,
+        "AI_POTENTIAL_ATTACK_TARGET_WEIGHTS",
+        "[Runtime] Stores the targeting weights for each direction the AI can use an attack in. Parallel to AI_POTENTIAL_ATTACK_TARGET_DIRECTIONS and AI_POTENTIAL_ATTACK_TARGETS.",
+        "uint32_t[8]",
+    )
+
+    AI_POTENTIAL_ATTACK_TARGETS = Symbol(
+        None,
+        None,
+        None,
+        "AI_POTENTIAL_ATTACK_TARGETS",
+        "[Runtime] Stores the target entity for each direction the AI can use an attack in. Parallel to AI_POTENTIAL_ATTACK_TARGET_DIRECTIONS and AI_POTENTIAL_ATTACK_TARGET_DIRECTIONS.",
+        "struct entity*[8]",
+    )
+
     ROLLOUT_ICE_BALL_MISSED = Symbol(
         None,
         None,

pmdsky_debug_py/protocol.py

@@ -1737,7 +1737,7 @@ class Arm9FunctionsProtocol(Protocol):
         None,
     ]
 
-    IsMoveRangeString19: Symbol[
+    IsMoveRangeStringUser: Symbol[
         Optional[list[int]],
         None,
     ]
@@ -15588,6 +15588,11 @@ class Overlay29FunctionsProtocol(Protocol):
         None,
     ]
 
+    CanMonsterMoveOrSwapWithAllyInDirection: Symbol[
+        Optional[list[int]],
+        None,
+    ]
+
     CanAttackInDirection: Symbol[
         Optional[list[int]],
         None,
@@ -16648,6 +16653,11 @@ class Overlay29FunctionsProtocol(Protocol):
         None,
     ]
 
+    ResetAiCanAttackInDirection: Symbol[
+        Optional[list[int]],
+        None,
+    ]
+
     AiConsiderMove: Symbol[
         Optional[list[int]],
         None,
@@ -16663,6 +16673,11 @@ class Overlay29FunctionsProtocol(Protocol):
         None,
     ]
 
+    WeightMoveWithIqSkills: Symbol[
+        Optional[list[int]],
+        None,
+    ]
+
     TargetRegularAttack: Symbol[
         Optional[list[int]],
         None,
@@ -19761,6 +19776,26 @@ class RamDataProtocol(Protocol):
         Optional[int],
     ]
 
+    AI_CAN_ATTACK_IN_DIRECTION: Symbol[
+        Optional[list[int]],
+        Optional[int],
+    ]
+
+    AI_POTENTIAL_ATTACK_TARGET_DIRECTIONS: Symbol[
+        Optional[list[int]],
+        Optional[int],
+    ]
+
+    AI_POTENTIAL_ATTACK_TARGET_WEIGHTS: Symbol[
+        Optional[list[int]],
+        Optional[int],
+    ]
+
+    AI_POTENTIAL_ATTACK_TARGETS: Symbol[
+        Optional[list[int]],
+        Optional[int],
+    ]
+
     ROLLOUT_ICE_BALL_MISSED: Symbol[
         Optional[list[int]],
         Optional[int],

{pmdsky_debug_py-10.1.14.dist-info → pmdsky_debug_py-10.1.15.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pmdsky-debug-py
-Version: 10.1.14
+Version: 10.1.15
 Summary: pmdsky-debug symbols for Python.
 Author-email: Marco 'Capypara' Köpcke <hello@capypara.de>
 License: MIT

pmdsky_debug_py-10.1.15.dist-info/RECORD

@@ -0,0 +1,14 @@
+pmdsky_debug_py/__init__.py,sha256=xvXjdxEqeoQaaS6ssZYVI9jARzv5M4q6FNwA3Z6fOw4,1831
+pmdsky_debug_py/_release.py,sha256=oW4peccnf3LiK6to3pVIlfqQZnm-J4OC_gVHXPiJHYY,31
+pmdsky_debug_py/eu.py,sha256=5Yl0Jgj3jemoy33M0DEWRelMMJQ2RzsUi6bXXNDjUq0,1175763
+pmdsky_debug_py/eu_itcm.py,sha256=kgPgXbZNI66eK_ySXxVx-RszqTwmR0YoZ4V0TumRWks,1123343
+pmdsky_debug_py/jp.py,sha256=4AaTWd8Z_9d9ZxiqhXp0bS2fClNlUY0U0xfch8aR2Yo,1172491
+pmdsky_debug_py/jp_itcm.py,sha256=3meYYolzZO--8JV3fsU-Q95-2_DB1sDhg3E0PLrRJlw,1123343
+pmdsky_debug_py/na.py,sha256=dXtR3A0udv0pE3PKDBewSATViFGpYkEmcLHqM-KQido,1176720
+pmdsky_debug_py/na_itcm.py,sha256=Nm-xoCIiNdJg7RhiNxdLRrUwJks8RBhuoM4fl228rRQ,1123343
+pmdsky_debug_py/protocol.py,sha256=6O_9eNvaK5Y55PxHQL6NOwYgyoXohSMAwXT_9-Q9qdk,343529
+pmdsky_debug_py/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pmdsky_debug_py-10.1.15.dist-info/METADATA,sha256=aprgKfc6FrAR8fpZZeKrtmKg82_CTr00gXnH74XouT0,1376
+pmdsky_debug_py-10.1.15.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+pmdsky_debug_py-10.1.15.dist-info/top_level.txt,sha256=cqvpcJbud2s8IyBAc1MfCySwniko_6qO5LWSSxNIoXI,16
+pmdsky_debug_py-10.1.15.dist-info/RECORD,,

pmdsky_debug_py-10.1.14.dist-info/RECORD

@@ -1,14 +0,0 @@
-pmdsky_debug_py/__init__.py,sha256=xvXjdxEqeoQaaS6ssZYVI9jARzv5M4q6FNwA3Z6fOw4,1831
-pmdsky_debug_py/_release.py,sha256=MrDjd6IdKDXfbcm06I9KNNxKufFtDqzsfFvD2a0AuSY,31
-pmdsky_debug_py/eu.py,sha256=ZlmZujyzHbWU69uVlEyKKL1G3sMXZ3Vmqd9Z0mrELKU,1172503
-pmdsky_debug_py/eu_itcm.py,sha256=endPOP3etgWPGsBcg3g70Xdsr7Tqo8ZlDDJwKEBL3wc,1120269
-pmdsky_debug_py/jp.py,sha256=aS62hzRHKkrTCL6iMN_SVgCr-I9w5jPWn5PYcEifiHw,1169231
-pmdsky_debug_py/jp_itcm.py,sha256=gu6_VldknhVUCI2PM7G_XwhYz5l_Pw3BeLKlE6dxeRI,1120269
-pmdsky_debug_py/na.py,sha256=tKWvTlnCwKMyxg0whpZ_ptuNXT3jXO26SL4M7bgiWOo,1173460
-pmdsky_debug_py/na_itcm.py,sha256=__LgGcnE9yS0j25lEeGW58n_gvs8ZwVK3920iIL-t2s,1120269
-pmdsky_debug_py/protocol.py,sha256=QcB1pNGG1AR076S9Gb3qsada7kFt8n1w3ly4lVGSso8,342831
-pmdsky_debug_py/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pmdsky_debug_py-10.1.14.dist-info/METADATA,sha256=X4nlXJLMw1gmEuOLhCWowLRc5wYdzyaEqm27TI6rRIA,1376
-pmdsky_debug_py-10.1.14.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-pmdsky_debug_py-10.1.14.dist-info/top_level.txt,sha256=cqvpcJbud2s8IyBAc1MfCySwniko_6qO5LWSSxNIoXI,16
-pmdsky_debug_py-10.1.14.dist-info/RECORD,,