Modifier la précision d'une attaque

Principe

La précision d'une attaque est calculée par la méthode chance_of_hit selon la formule :

chance_of_hit = factor × accuracy

Où factor est le produit de trois éléments :

• Les multiplicateurs de tous les effets actifs (chance_of_hit_multiplier).
• Le modificateur de précision de l'utilisateur (accuracy_mod).
• Le modificateur d'esquive de la cible (evasion_mod).

Si bypass_chance_of_hit? retourne true, le test de précision est ignoré et l'attaque touche automatiquement.

remarque

Astuce Pokémon Studio : mettre la précision d'une attaque à 0 dans Pokémon Studio suffit à la rendre infaillible. Le système considère une précision inférieure ou égale à 0 comme un bypass automatique du test de précision.

Depuis l'attaque

Certaines attaques modifient leur précision selon le contexte. Par exemple, l'attaque Fatal-Foudre a une précision de 50 au soleil, touche automatiquement sous la pluie, et conserve sa précision normale sinon.

Pour gérer ce comportement, on override la méthode accuracy dans la sous-classe de l'attaque. Si les conditions ne sont pas remplies, on retourne super pour conserver la valeur définie dans Pokémon Studio.

Exemple : Fatal-Foudre

# Return the current accuracy of the move
# @return [Integer]
def accuracy
  return 50 if @logic.effective_weather_effect.global_sunny?
  return 0 if @logic.effective_weather_effect.global_rain?

  return super
end

• return 50 réduit la précision à 50% au soleil.
• return 0 rend l'attaque infaillible sous la pluie (précision de 0 = bypass automatique).
• return super conserve la précision définie dans Pokémon Studio pour tous les autres cas.

On peut également override bypass_chance_of_hit? pour ignorer complètement le test de précision selon des conditions spécifiques. Par exemple, une attaque qui touche toujours si la cible utilise Lilliput :

# Check if the move bypass chance of hit and cannot fail
# @param user [PFM::PokemonBattler] user of the move
# @param target [PFM::PokemonBattler] target of the move
# @return [Boolean]
def bypass_chance_of_hit?(user, target)
  return true if target.effects.has?(:minimize)

  return super
end

• bypass_chance_of_hit? est utile quand le bypass dépend d'une condition externe (état de la cible, talent, etc.) plutôt que d'un changement de valeur de précision.

Depuis un effet

Certains effets peuvent modifier la précision d'une attaque via un multiplicateur. Par exemple, le talent Oeil Composé multiplie par 1.3 la précision de toutes les attaques de l'utilisateur.

Pour gérer ce comportement, on utilise la méthode chance_of_hit_multiplier dans la classe de l'effet.

Exemple : Oeil Composé

# Return the chance of hit multiplier
# @param user [PFM::PokemonBattler] user of the move
# @param target [PFM::PokemonBattler] target of the move
# @param move [Battle::Move]
# @return [Float]
def chance_of_hit_multiplier(user, target, move)
  return 1 if user != @target

  return 1.3
end

• super retourne le multiplicateur par défaut (1), à utiliser si les conditions ne sont pas remplies.
• Retourner une valeur supérieure à 1 augmente la précision, inférieure à 1 la réduit.
• Tous les multiplicateurs des effets actifs sont multipliés entre eux avant d'être appliqués à la formule.

Exemple : Agitation

# Return the chance of hit multiplier
# @param user [PFM::PokemonBattler] user of the move
# @param target [PFM::PokemonBattler] target of the move
# @param move [Battle::Move]
# @return [Float]
def chance_of_hit_multiplier(user, target, move)
  return 1 if user != @target

  return move.physical? ? 0.8 : 1
end

• Ici le multiplicateur est conditionnel : 0.8 pour les attaques physiques, 1 pour les autres.
• Le talent Agitation réduit la précision des attaques physiques en échange d'un bonus d'attaque.

Conclusion

• Surchargez accuracy dans la sous-classe de l'attaque pour modifier la précision selon le contexte. Retournez super si les conditions ne sont pas remplies.
• Surchargez bypass_chance_of_hit? pour ignorer le test de précision selon une condition. Retournez super sinon.
• Utilisez chance_of_hit_multiplier pour appliquer un multiplicateur sur la précision depuis un effet. Retournez un Float.
• La formule finale est : factor × accuracy, où factor est le produit de tous les multiplicateurs, de la précision de l'utilisateur et de l'esquive de la cible.