Modifier l'efficacité d'une attaque

Principe

L'efficacité d'une attaque peut être modifiée pour deux raisons distinctes :

• Depuis l'attaque elle-même : l'attaque surcharge la méthode single_type_multiplier_overwrite dans sa sous-classe.
• Depuis un effet externe : un effet actif modifie le multiplicateur de type avant le calcul des dégâts.

La valeur retournée est un multiplicateur numérique appliqué par type de la cible :

• 0 = immunisé
• 0.5 = pas très efficace
• 1 = neutre (efficacité normale)
• 2 = super efficace

Depuis l'attaque

Certaines attaques peuvent modifier leur efficacité selon leurs propres règles. Par exemple, l'attaque Lyophilisation inflige des dégâts super efficaces contre les Pokémon de type Eau, alors que la Glace est normalement neutre contre l'Eau.

Pour gérer ce comportement, on surcharge la méthode single_type_multiplier_overwrite dans la sous-classe de l'attaque. Si les conditions ne sont pas remplies, on retourne super pour laisser la chaîne de calcul continuer normalement.

Exemple : Lyophilisation

module Battle
  class Move
    class FreezeDry < Basic
      # Get a single type multiplier overwrite
      # @param target [PFM::PokemonBattler] target of the move
      # @param target_type [Integer] one of the type of the target
      # @param type [Integer] one of the type of the move
      # @return [Float | nil] definitive multiplier
      def single_type_multiplier_overwrite(target, target_type, type)
        return super if target_type != data_type(:water).id

        return 2
      end
    end

    Move.register(:s_freeze_dry, FreezeDry)
  end
end

• La méthode vérifie si le type de la cible est Eau. Si oui, elle retourne 2 (super efficace).
• Si la condition n'est pas remplie, return super délègue au comportement par défaut de la classe parente.
• Pas besoin de vérifier db_symbol : la méthode est définie dans la sous-classe de l'attaque, elle ne s'applique donc qu'à cette attaque.

Depuis un effet

Certains effets peuvent modifier l'efficacité de type d'une attaque. Par exemple, l'effet Clairvoyance permet aux attaques Normal et Combat de toucher les Pokémon de type Spectre avec une efficacité neutre.

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

Exemple : Clairvoyance

# Function that computes an overwrite of the type multiplier
# @param target [PFM::PokemonBattler]
# @param target_type [Integer] one of the type of the target
# @param type [Integer] one of the type of the move
# @param move [Battle::Move]
# @return [Numeric, nil] overwriten type multiplier
def on_single_type_multiplier_overwrite(target, target_type, type, move)
  return if target != @pokemon || target_type != data_type(:ghost).id
  return unless [data_type(:normal).id, data_type(:fighting).id].include?(type)

  return 1
end

• La première ligne vérifie que la cible est le porteur de l'effet et que le type de la cible est Spectre.
• La deuxième ligne vérifie que le type de l'attaque est Normal ou Combat.
• Le retour 1 remplace l'immunité habituelle (Spectre immunisé à Normal/Combat) par une efficacité neutre.
• Le retour nil (implicite) laisse le multiplicateur de type inchangé.

Conclusion

• Surchargez single_type_multiplier_overwrite dans la sous-classe de l'attaque si la modification dépend de la logique propre de l'attaque. Retournez super si les conditions ne sont pas remplies.
• Utilisez on_single_type_multiplier_overwrite si la modification dépend d'un effet externe. Retournez nil (implicitement) pour ne pas modifier le multiplicateur.
• Retournez un Numeric (0, 0.5, 1, 2) pour modifier le multiplicateur.