Change a move's type

Principle

A move's type can be changed for two distinct reasons:

• From the move itself: the move determines its type based on the user or the context.
• From an external effect: an active effect modifies the move's type before execution.

The two mechanisms have different return formats: definitive_types returns an Array<Integer> (list of types), while on_move_type_change returns a single Integer or nil.

From the move

Some moves can change type based on their own rules. For example, the move Raging Bull adapts its type based on the form of Tauros using it.

To handle this behavior, override the definitive_types method in the move's class.

Example: Raging Bull

# @return [Array<Symbol>]
RAGING_BULL_USERS = %i[tauros]

# Get the types of the move with 1st type being affected by effects
# @param user [PFM::PokemonBattler] user of the move
# @param target [PFM::PokemonBattler] target of the move
# @return [Array<Integer>] list of types of the move
def definitive_types(user, target)
  return [type] unless RAGING_BULL_USERS.include?(user.db_symbol)

  case user.form
  when 1
    return [data_type(:fighting).id]
  when 2
    return [data_type(:fire).id]
  when 3
    return [data_type(:water).id]
  else
    return [type]
  end
end

• The RAGING_BULL_USERS constant limits the effect to the relevant Pokemon, allowing easy monkey patching.
• data_type(:symbol).id converts a type symbol to its numeric identifier.
• The method always returns an Array<Integer>, even for a single type ([type]).

From an effect

Some effects can modify a move's type before execution. For example, the Ion Deluge effect transforms Normal-type moves into Electric-type.

To handle this behavior, use the on_move_type_change method in the effect's class.

Example: Ion Deluge

# Function called when we try to get the definitive type of a move
# @param user [PFM::PokemonBattler]
# @param target [PFM::PokemonBattler] expected target
# @param move [Battle::Move]
# @param type [Integer] current type of the move (potentially after effects)
# @return [Integer, nil] new type of the move
def on_move_type_change(user, target, move, type)
  return if type != data_type(:normal).id

  return data_type(:electric).id
end

• The type parameter contains the current type of the move, potentially already modified by other effects.
• The method returns the new type (Integer) if the condition is met, or implicitly nil to leave the type unchanged.

Conclusion

• Use definitive_types if the type change depends on the move's own logic. Return an Array<Integer>.
• Use on_move_type_change if the change depends on an external effect. Return an Integer or nil.
• Use data_type(:symbol).id to convert a type symbol to a numeric identifier.