Added decent spacing to all scripts thanks to Rubocop

Data/Scripts/011_Battle/003_Move/007_MoveEffects_BattlerOther.rb

@@ -9,14 +9,14 @@ class Battle::Move::SleepTarget < Battle::Move
     return !target.pbCanSleep?(user, show_message, self)
   end
 
-  def pbEffectAgainstTarget(user,target)
+  def pbEffectAgainstTarget(user, target)
     return if damagingMove?
     target.pbSleep
   end
 
-  def pbAdditionalEffect(user,target)
+  def pbAdditionalEffect(user, target)
     return if target.damageState.substitute
-    target.pbSleep if target.pbCanSleep?(user,false,self)
+    target.pbSleep if target.pbCanSleep?(user, false, self)
   end
 end
 
@@ -24,9 +24,9 @@ end
 # Puts the target to sleep. Fails if user is not Darkrai. (Dark Void (Gen 7+))
 #===============================================================================
 class Battle::Move::SleepTargetIfUserDarkrai < Battle::Move::SleepTarget
-  def pbMoveFailed?(user,targets)
+  def pbMoveFailed?(user, targets)
     if !user.isSpecies?(:DARKRAI) && user.effects[PBEffects::TransformSpecies] != :DARKRAI
-      @battle.pbDisplay(_INTL("But {1} can't use the move!",user.pbThis))
+      @battle.pbDisplay(_INTL("But {1} can't use the move!", user.pbThis))
       return true
     end
     return false
@@ -38,13 +38,13 @@ end
 # (Relic Song)
 #===============================================================================
 class Battle::Move::SleepTargetChangeUserMeloettaForm < Battle::Move::SleepTarget
-  def pbEndOfMoveUsageEffect(user,targets,numHits,switchedBattlers)
-    return if numHits==0
+  def pbEndOfMoveUsageEffect(user, targets, numHits, switchedBattlers)
+    return if numHits == 0
     return if user.fainted? || user.effects[PBEffects::Transform]
     return if !user.isSpecies?(:MELOETTA)
-    return if user.hasActiveAbility?(:SHEERFORCE) && @addlEffect>0
-    newForm = (user.form+1)%2
-    user.pbChangeForm(newForm,_INTL("{1} transformed!",user.pbThis))
+    return if user.hasActiveAbility?(:SHEERFORCE) && @addlEffect > 0
+    newForm = (user.form + 1) % 2
+    user.pbChangeForm(newForm, _INTL("{1} transformed!", user.pbThis))
   end
 end
 
@@ -55,17 +55,17 @@ class Battle::Move::SleepTargetNextTurn < Battle::Move
   def canMagicCoat?; return true; end
 
   def pbFailsAgainstTarget?(user, target, show_message)
-    if target.effects[PBEffects::Yawn]>0
+    if target.effects[PBEffects::Yawn] > 0
       @battle.pbDisplay(_INTL("But it failed!")) if show_message
       return true
     end
-    return true if !target.pbCanSleep?(user,true,self)
+    return true if !target.pbCanSleep?(user, true, self)
     return false
   end
 
-  def pbEffectAgainstTarget(user,target)
+  def pbEffectAgainstTarget(user, target)
     target.effects[PBEffects::Yawn] = 2
-    @battle.pbDisplay(_INTL("{1} made {2} drowsy!",user.pbThis,target.pbThis(true)))
+    @battle.pbDisplay(_INTL("{1} made {2} drowsy!", user.pbThis, target.pbThis(true)))
   end
 end
 
@@ -75,7 +75,7 @@ end
 class Battle::Move::PoisonTarget < Battle::Move
   def canMagicCoat?; return true; end
 
-  def initialize(battle,move)
+  def initialize(battle, move)
     super
     @toxic = false
   end
@@ -85,14 +85,14 @@ class Battle::Move::PoisonTarget < Battle::Move
     return !target.pbCanPoison?(user, show_message, self)
   end
 
-  def pbEffectAgainstTarget(user,target)
+  def pbEffectAgainstTarget(user, target)
     return if damagingMove?
-    target.pbPoison(user,nil,@toxic)
+    target.pbPoison(user, nil, @toxic)
   end
 
-  def pbAdditionalEffect(user,target)
+  def pbAdditionalEffect(user, target)
     return if target.damageState.substitute
-    target.pbPoison(user,nil,@toxic) if target.pbCanPoison?(user,false,self)
+    target.pbPoison(user, nil, @toxic) if target.pbCanPoison?(user, false, self)
   end
 end
 
@@ -103,18 +103,18 @@ class Battle::Move::PoisonTargetLowerTargetSpeed1 < Battle::Move
   def canMagicCoat?; return true; end
 
   def pbFailsAgainstTarget?(user, target, show_message)
-    if !target.pbCanPoison?(user,false,self) &&
-       !target.pbCanLowerStatStage?(:SPEED,user,self)
+    if !target.pbCanPoison?(user, false, self) &&
+       !target.pbCanLowerStatStage?(:SPEED, user, self)
       @battle.pbDisplay(_INTL("But it failed!")) if show_message
       return true
     end
     return false
   end
 
-  def pbEffectAgainstTarget(user,target)
-    target.pbPoison(user) if target.pbCanPoison?(user,false,self)
-    if target.pbCanLowerStatStage?(:SPEED,user,self)
-      target.pbLowerStatStage(:SPEED,1,user)
+  def pbEffectAgainstTarget(user, target)
+    target.pbPoison(user) if target.pbCanPoison?(user, false, self)
+    if target.pbCanLowerStatStage?(:SPEED, user, self)
+      target.pbLowerStatStage(:SPEED, 1, user)
     end
   end
 end
@@ -123,12 +123,12 @@ end
 # Badly poisons the target. (Poison Fang, Toxic)
 #===============================================================================
 class Battle::Move::BadPoisonTarget < Battle::Move::PoisonTarget
-  def initialize(battle,move)
+  def initialize(battle, move)
     super
     @toxic = true
   end
 
-  def pbOverrideSuccessCheckPerHit(user,target)
+  def pbOverrideSuccessCheckPerHit(user, target)
     return (Settings::MORE_TYPE_EFFECTS && statusMove? && user.pbHasType?(:POISON))
   end
 end
@@ -144,14 +144,14 @@ class Battle::Move::ParalyzeTarget < Battle::Move
     return !target.pbCanParalyze?(user, show_message, self)
   end
 
-  def pbEffectAgainstTarget(user,target)
+  def pbEffectAgainstTarget(user, target)
     return if damagingMove?
     target.pbParalyze(user)
   end
 
-  def pbAdditionalEffect(user,target)
+  def pbAdditionalEffect(user, target)
     return if target.damageState.substitute
-    target.pbParalyze(user) if target.pbCanParalyze?(user,false,self)
+    target.pbParalyze(user) if target.pbCanParalyze?(user, false, self)
   end
 end
 
@@ -175,8 +175,8 @@ end
 #===============================================================================
 class Battle::Move::ParalyzeTargetTrampleMinimize < Battle::Move::ParalyzeTarget
   def tramplesMinimize?(param = 1)
-    return true if param==1 && Settings::MECHANICS_GENERATION >= 6   # Perfect accuracy
-    return true if param==2   # Double damage
+    return true if param == 1 && Settings::MECHANICS_GENERATION >= 6   # Perfect accuracy
+    return true if param == 2   # Double damage
     return super
   end
 end
@@ -188,7 +188,7 @@ end
 class Battle::Move::ParalyzeTargetAlwaysHitsInRainHitsTargetInSky < Battle::Move::ParalyzeTarget
   def hitsFlyingTargets?; return true; end
 
-  def pbBaseAccuracy(user,target)
+  def pbBaseAccuracy(user, target)
     case target.effectiveWeather
     when :Sun, :HarshSun
       return 50
@@ -205,14 +205,14 @@ end
 class Battle::Move::ParalyzeFlinchTarget < Battle::Move
   def flinchingMove?; return true; end
 
-  def pbAdditionalEffect(user,target)
+  def pbAdditionalEffect(user, target)
     return if target.damageState.substitute
-    chance = pbAdditionalEffectChance(user,target,10)
-    return if chance==0
-    if @battle.pbRandom(100)<chance
-      target.pbParalyze(user) if target.pbCanParalyze?(user,false,self)
+    chance = pbAdditionalEffectChance(user, target, 10)
+    return if chance == 0
+    if @battle.pbRandom(100) < chance
+      target.pbParalyze(user) if target.pbCanParalyze?(user, false, self)
     end
-    target.pbFlinch(user) if @battle.pbRandom(100)<chance
+    target.pbFlinch(user) if @battle.pbRandom(100) < chance
   end
 end
 
@@ -227,14 +227,14 @@ class Battle::Move::BurnTarget < Battle::Move
     return !target.pbCanBurn?(user, show_message, self)
   end
 
-  def pbEffectAgainstTarget(user,target)
+  def pbEffectAgainstTarget(user, target)
     return if damagingMove?
     target.pbBurn(user)
   end
 
-  def pbAdditionalEffect(user,target)
+  def pbAdditionalEffect(user, target)
     return if target.damageState.substitute
-    target.pbBurn(user) if target.pbCanBurn?(user,false,self)
+    target.pbBurn(user) if target.pbCanBurn?(user, false, self)
   end
 end
 
@@ -254,14 +254,14 @@ end
 class Battle::Move::BurnFlinchTarget < Battle::Move
   def flinchingMove?; return true; end
 
-  def pbAdditionalEffect(user,target)
+  def pbAdditionalEffect(user, target)
     return if target.damageState.substitute
-    chance = pbAdditionalEffectChance(user,target,10)
-    return if chance==0
-    if @battle.pbRandom(100)<chance
-      target.pbBurn(user) if target.pbCanBurn?(user,false,self)
+    chance = pbAdditionalEffectChance(user, target, 10)
+    return if chance == 0
+    if @battle.pbRandom(100) < chance
+      target.pbBurn(user) if target.pbCanBurn?(user, false, self)
     end
-    target.pbFlinch(user) if @battle.pbRandom(100)<chance
+    target.pbFlinch(user) if @battle.pbRandom(100) < chance
   end
 end
 
@@ -276,14 +276,14 @@ class Battle::Move::FreezeTarget < Battle::Move
     return !target.pbCanFreeze?(user, show_message, self)
   end
 
-  def pbEffectAgainstTarget(user,target)
+  def pbEffectAgainstTarget(user, target)
     return if damagingMove?
     target.pbFreeze
   end
 
-  def pbAdditionalEffect(user,target)
+  def pbAdditionalEffect(user, target)
     return if target.damageState.substitute
-    target.pbFreeze if target.pbCanFreeze?(user,false,self)
+    target.pbFreeze if target.pbCanFreeze?(user, false, self)
   end
 end
 
@@ -291,7 +291,7 @@ end
 # Freezes the target. Effectiveness against Water-type is 2x. (Freeze-Dry)
 #===============================================================================
 class Battle::Move::FreezeTargetSuperEffectiveAgainstWater < Battle::Move::FreezeTarget
-  def pbCalcTypeModSingle(moveType,defType,user,target)
+  def pbCalcTypeModSingle(moveType, defType, user, target)
     return Effectiveness::SUPER_EFFECTIVE_ONE if defType == :WATER
     return super
   end
@@ -301,7 +301,7 @@ end
 # Freezes the target. Accuracy perfect in hail. (Blizzard)
 #===============================================================================
 class Battle::Move::FreezeTargetAlwaysHitsInHail < Battle::Move::FreezeTarget
-  def pbBaseAccuracy(user,target)
+  def pbBaseAccuracy(user, target)
     return 0 if target.effectiveWeather == :Hail
     return super
   end
@@ -313,14 +313,14 @@ end
 class Battle::Move::FreezeFlinchTarget < Battle::Move
   def flinchingMove?; return true; end
 
-  def pbAdditionalEffect(user,target)
+  def pbAdditionalEffect(user, target)
     return if target.damageState.substitute
-    chance = pbAdditionalEffectChance(user,target,10)
-    return if chance==0
-    if @battle.pbRandom(100)<chance
-      target.pbFreeze if target.pbCanFreeze?(user,false,self)
+    chance = pbAdditionalEffectChance(user, target, 10)
+    return if chance == 0
+    if @battle.pbRandom(100) < chance
+      target.pbFreeze if target.pbCanFreeze?(user, false, self)
     end
-    target.pbFlinch(user) if @battle.pbRandom(100)<chance
+    target.pbFlinch(user) if @battle.pbRandom(100) < chance
   end
 end
 
@@ -328,7 +328,7 @@ end
 # Burns, freezes or paralyzes the target. (Tri Attack)
 #===============================================================================
 class Battle::Move::ParalyzeBurnOrFreezeTarget < Battle::Move
-  def pbAdditionalEffect(user,target)
+  def pbAdditionalEffect(user, target)
     return if target.damageState.substitute
     case @battle.pbRandom(3)
     when 0 then target.pbBurn(user) if target.pbCanBurn?(user, false, self)
@@ -342,7 +342,7 @@ end
 # User passes its status problem to the target. (Psycho Shift)
 #===============================================================================
 class Battle::Move::GiveUserStatusToTarget < Battle::Move
-  def pbMoveFailed?(user,targets)
+  def pbMoveFailed?(user, targets)
     if user.status == :NONE
       @battle.pbDisplay(_INTL("But it failed!"))
       return true
@@ -351,33 +351,33 @@ class Battle::Move::GiveUserStatusToTarget < Battle::Move
   end
 
   def pbFailsAgainstTarget?(user, target, show_message)
-    if !target.pbCanInflictStatus?(user.status,user,false,self)
+    if !target.pbCanInflictStatus?(user.status, user, false, self)
       @battle.pbDisplay(_INTL("But it failed!")) if show_message
       return true
     end
     return false
   end
 
-  def pbEffectAgainstTarget(user,target)
+  def pbEffectAgainstTarget(user, target)
     msg = ""
     case user.status
     when :SLEEP
       target.pbSleep
-      msg = _INTL("{1} woke up.",user.pbThis)
+      msg = _INTL("{1} woke up.", user.pbThis)
     when :POISON
-      target.pbPoison(user,nil,user.statusCount!=0)
-      msg = _INTL("{1} was cured of its poisoning.",user.pbThis)
+      target.pbPoison(user, nil, user.statusCount != 0)
+      msg = _INTL("{1} was cured of its poisoning.", user.pbThis)
     when :BURN
       target.pbBurn(user)
-      msg = _INTL("{1}'s burn was healed.",user.pbThis)
+      msg = _INTL("{1}'s burn was healed.", user.pbThis)
     when :PARALYSIS
       target.pbParalyze(user)
-      msg = _INTL("{1} was cured of paralysis.",user.pbThis)
+      msg = _INTL("{1} was cured of paralysis.", user.pbThis)
     when :FROZEN
       target.pbFreeze
-      msg = _INTL("{1} was thawed out.",user.pbThis)
+      msg = _INTL("{1} was thawed out.", user.pbThis)
     end
-    if msg!=""
+    if msg != ""
       user.pbCureStatus(false)
       @battle.pbDisplay(msg)
     end
@@ -390,7 +390,7 @@ end
 class Battle::Move::CureUserBurnPoisonParalysis < Battle::Move
   def canSnatch?; return true; end
 
-  def pbMoveFailed?(user,targets)
+  def pbMoveFailed?(user, targets)
     if ![:BURN, :POISON, :PARALYSIS].include?(user.status)
       @battle.pbDisplay(_INTL("But it failed!"))
       return true
@@ -403,11 +403,11 @@ class Battle::Move::CureUserBurnPoisonParalysis < Battle::Move
     user.pbCureStatus(false)
     case old_status
     when :BURN
-      @battle.pbDisplay(_INTL("{1} healed its burn!",user.pbThis))
+      @battle.pbDisplay(_INTL("{1} healed its burn!", user.pbThis))
     when :POISON
-      @battle.pbDisplay(_INTL("{1} cured its poisoning!",user.pbThis))
+      @battle.pbDisplay(_INTL("{1} cured its poisoning!", user.pbThis))
     when :PARALYSIS
-      @battle.pbDisplay(_INTL("{1} cured its paralysis!",user.pbThis))
+      @battle.pbDisplay(_INTL("{1} cured its paralysis!", user.pbThis))
     end
   end
 end
@@ -426,7 +426,7 @@ class Battle::Move::CureUserPartyStatus < Battle::Move
   def canSnatch?;          return true; end
   def worksWithNoTargets?; return true; end
 
-  def pbMoveFailed?(user,targets)
+  def pbMoveFailed?(user, targets)
     has_effect = @battle.allSameSideBattlers(user).any? { |b| b.status != :NONE }
     if !has_effect
       has_effect = @battle.pbParty(user.index).any? { |pkmn| pkmn && pkmn.able? && pkmn.status != :NONE }
@@ -442,7 +442,7 @@ class Battle::Move::CureUserPartyStatus < Battle::Move
     return target.status == :NONE
   end
 
-  def pbAromatherapyHeal(pkmn,battler = nil)
+  def pbAromatherapyHeal(pkmn, battler = nil)
     oldStatus = (battler) ? battler.status : pkmn.status
     curedName = (battler) ? battler.pbThis : pkmn.name
     if battler
@@ -453,21 +453,21 @@ class Battle::Move::CureUserPartyStatus < Battle::Move
     end
     case oldStatus
     when :SLEEP
-      @battle.pbDisplay(_INTL("{1} was woken from sleep.",curedName))
+      @battle.pbDisplay(_INTL("{1} was woken from sleep.", curedName))
     when :POISON
-      @battle.pbDisplay(_INTL("{1} was cured of its poisoning.",curedName))
+      @battle.pbDisplay(_INTL("{1} was cured of its poisoning.", curedName))
     when :BURN
-      @battle.pbDisplay(_INTL("{1}'s burn was healed.",curedName))
+      @battle.pbDisplay(_INTL("{1}'s burn was healed.", curedName))
     when :PARALYSIS
-      @battle.pbDisplay(_INTL("{1} was cured of paralysis.",curedName))
+      @battle.pbDisplay(_INTL("{1} was cured of paralysis.", curedName))
     when :FROZEN
-      @battle.pbDisplay(_INTL("{1} was thawed out.",curedName))
+      @battle.pbDisplay(_INTL("{1} was thawed out.", curedName))
     end
   end
 
-  def pbEffectAgainstTarget(user,target)
+  def pbEffectAgainstTarget(user, target)
     # Cure all Pokémon in battle on the user's side.
-    pbAromatherapyHeal(target.pokemon,target)
+    pbAromatherapyHeal(target.pokemon, target)
   end
 
   def pbEffectGeneral(user)
@@ -481,14 +481,14 @@ class Battle::Move::CureUserPartyStatus < Battle::Move
     # Cure all Pokémon in the user's and partner trainer's party.
     # NOTE: This intentionally affects the partner trainer's inactive Pokémon
     #       too.
-    @battle.pbParty(user.index).each_with_index do |pkmn,i|
+    @battle.pbParty(user.index).each_with_index do |pkmn, i|
       next if !pkmn || !pkmn.able? || pkmn.status == :NONE
-      next if @battle.pbFindBattler(i,user)   # Skip Pokémon in battle
+      next if @battle.pbFindBattler(i, user)   # Skip Pokémon in battle
       pbAromatherapyHeal(pkmn)
     end
   end
 
-  def pbShowAnimation(id,user,targets,hitNum = 0,showAnimation = true)
+  def pbShowAnimation(id, user, targets, hitNum = 0, showAnimation = true)
     super
     if @id == :AROMATHERAPY
       @battle.pbDisplay(_INTL("A soothing aroma wafted through the area!"))
@@ -502,7 +502,7 @@ end
 # Cures the target's burn. (Sparkling Aria)
 #===============================================================================
 class Battle::Move::CureTargetBurn < Battle::Move
-  def pbAdditionalEffect(user,target)
+  def pbAdditionalEffect(user, target)
     return if target.fainted? || target.damageState.substitute
     return if target.status != :BURN
     target.pbCureStatus
@@ -516,8 +516,8 @@ end
 class Battle::Move::StartUserSideImmunityToInflictedStatus < Battle::Move
   def canSnatch?; return true; end
 
-  def pbMoveFailed?(user,targets)
-    if user.pbOwnSide.effects[PBEffects::Safeguard]>0
+  def pbMoveFailed?(user, targets)
+    if user.pbOwnSide.effects[PBEffects::Safeguard] > 0
       @battle.pbDisplay(_INTL("But it failed!"))
       return true
     end
@@ -526,7 +526,7 @@ class Battle::Move::StartUserSideImmunityToInflictedStatus < Battle::Move
 
   def pbEffectGeneral(user)
     user.pbOwnSide.effects[PBEffects::Safeguard] = 5
-    @battle.pbDisplay(_INTL("{1} became cloaked in a mystical veil!",user.pbTeam))
+    @battle.pbDisplay(_INTL("{1} became cloaked in a mystical veil!", user.pbTeam))
   end
 end
 
@@ -536,12 +536,12 @@ end
 class Battle::Move::FlinchTarget < Battle::Move
   def flinchingMove?; return true; end
 
-  def pbEffectAgainstTarget(user,target)
+  def pbEffectAgainstTarget(user, target)
     return if damagingMove?
     target.pbFlinch(user)
   end
 
-  def pbAdditionalEffect(user,target)
+  def pbAdditionalEffect(user, target)
     return if target.damageState.substitute
     target.pbFlinch(user)
   end
@@ -553,8 +553,8 @@ end
 #===============================================================================
 class Battle::Move::FlinchTargetTrampleMinimize < Battle::Move::FlinchTarget
   def tramplesMinimize?(param = 1)
-    return true if param==1 && Settings::MECHANICS_GENERATION >= 6   # Perfect accuracy
-    return true if param==2   # Double damage
+    return true if param == 1 && Settings::MECHANICS_GENERATION >= 6   # Perfect accuracy
+    return true if param == 2   # Double damage
     return super
   end
 end
@@ -565,7 +565,7 @@ end
 class Battle::Move::FlinchTargetFailsIfUserNotAsleep < Battle::Move::FlinchTarget
   def usableWhenAsleep?; return true; end
 
-  def pbMoveFailed?(user,targets)
+  def pbMoveFailed?(user, targets)
     if !user.asleep?
       @battle.pbDisplay(_INTL("But it failed!"))
       return true
@@ -579,7 +579,7 @@ end
 # (Fake Out)
 #===============================================================================
 class Battle::Move::FlinchTargetFailsIfNotUserFirstTurn < Battle::Move::FlinchTarget
-  def pbMoveFailed?(user,targets)
+  def pbMoveFailed?(user, targets)
     if user.turnCount > 1
       @battle.pbDisplay(_INTL("But it failed!"))
       return true
@@ -595,11 +595,11 @@ end
 class Battle::Move::FlinchTargetDoublePowerIfTargetInSky < Battle::Move::FlinchTarget
   def hitsFlyingTargets?; return true; end
 
-  def pbBaseDamage(baseDmg,user,target)
+  def pbBaseDamage(baseDmg, user, target)
     baseDmg *= 2 if target.inTwoTurnAttack?("TwoTurnAttackInvulnerableInSky",
                                             "TwoTurnAttackInvulnerableInSkyParalyzeTarget",
                                             "TwoTurnAttackInvulnerableInSkyTargetCannotAct") ||
-                    target.effects[PBEffects::SkyDrop]>=0
+                    target.effects[PBEffects::SkyDrop] >= 0
     return baseDmg
   end
 end
@@ -615,14 +615,14 @@ class Battle::Move::ConfuseTarget < Battle::Move
     return !target.pbCanConfuse?(user, show_message, self)
   end
 
-  def pbEffectAgainstTarget(user,target)
+  def pbEffectAgainstTarget(user, target)
     return if damagingMove?
     target.pbConfuse
   end
 
-  def pbAdditionalEffect(user,target)
+  def pbAdditionalEffect(user, target)
     return if target.damageState.substitute
-    return if !target.pbCanConfuse?(user,false,self)
+    return if !target.pbCanConfuse?(user, false, self)
     target.pbConfuse
   end
 end
@@ -634,7 +634,7 @@ end
 class Battle::Move::ConfuseTargetAlwaysHitsInRainHitsTargetInSky < Battle::Move::ConfuseTarget
   def hitsFlyingTargets?; return true; end
 
-  def pbBaseAccuracy(user,target)
+  def pbBaseAccuracy(user, target)
     case target.effectiveWeather
     when :Sun, :HarshSun
       return 50
@@ -659,14 +659,14 @@ class Battle::Move::AttractTarget < Battle::Move
     return false
   end
 
-  def pbEffectAgainstTarget(user,target)
+  def pbEffectAgainstTarget(user, target)
     return if damagingMove?
     target.pbAttract(user)
   end
 
-  def pbAdditionalEffect(user,target)
+  def pbAdditionalEffect(user, target)
     return if target.damageState.substitute
-    target.pbAttract(user) if target.pbCanAttract?(user,false)
+    target.pbAttract(user) if target.pbCanAttract?(user, false)
   end
 end
 
@@ -676,7 +676,7 @@ end
 class Battle::Move::SetUserTypesBasedOnEnvironment < Battle::Move
   def canSnatch?; return true; end
 
-  def pbMoveFailed?(user,targets)
+  def pbMoveFailed?(user, targets)
     if !user.canChangeType?
       @battle.pbDisplay(_INTL("But it failed!"))
       return true
@@ -742,7 +742,7 @@ class Battle::Move::SetUserTypesBasedOnEnvironment < Battle::Move
   def pbEffectGeneral(user)
     user.pbChangeTypes(@newType)
     typeName = GameData::Type.get(@newType).name
-    @battle.pbDisplay(_INTL("{1}'s type changed to {2}!",user.pbThis,typeName))
+    @battle.pbDisplay(_INTL("{1}'s type changed to {2}!", user.pbThis, typeName))
   end
 end
 
@@ -794,7 +794,7 @@ end
 class Battle::Move::SetUserTypesToTargetTypes < Battle::Move
   def ignoresSubstitute?(user); return true; end
 
-  def pbMoveFailed?(user,targets)
+  def pbMoveFailed?(user, targets)
     if !user.canChangeType?
       @battle.pbDisplay(_INTL("But it failed!"))
       return true
@@ -804,22 +804,22 @@ class Battle::Move::SetUserTypesToTargetTypes < Battle::Move
 
   def pbFailsAgainstTarget?(user, target, show_message)
     newTypes = target.pbTypes(true)
-    if newTypes.length==0   # Target has no type to copy
+    if newTypes.length == 0   # Target has no type to copy
       @battle.pbDisplay(_INTL("But it failed!")) if show_message
       return true
     end
-    if user.pbTypes==target.pbTypes &&
-       user.effects[PBEffects::Type3]==target.effects[PBEffects::Type3]
+    if user.pbTypes == target.pbTypes &&
+       user.effects[PBEffects::Type3] == target.effects[PBEffects::Type3]
       @battle.pbDisplay(_INTL("But it failed!")) if show_message
       return true
     end
     return false
   end
 
-  def pbEffectAgainstTarget(user,target)
+  def pbEffectAgainstTarget(user, target)
     user.pbChangeTypes(target)
     @battle.pbDisplay(_INTL("{1}'s type changed to match {2}'s!",
-       user.pbThis,target.pbThis(true)))
+       user.pbThis, target.pbThis(true)))
   end
 end
 
@@ -831,20 +831,20 @@ end
 class Battle::Move::SetUserTypesToUserMoveType < Battle::Move
   def canSnatch?; return true; end
 
-  def pbMoveFailed?(user,targets)
+  def pbMoveFailed?(user, targets)
     if !user.canChangeType?
       @battle.pbDisplay(_INTL("But it failed!"))
       return true
     end
     userTypes = user.pbTypes(true)
     @newTypes = []
-    user.eachMoveWithIndex do |m,i|
-      break if Settings::MECHANICS_GENERATION >= 6 && i>0
+    user.eachMoveWithIndex do |m, i|
+      break if Settings::MECHANICS_GENERATION >= 6 && i > 0
       next if GameData::Type.get(m.type).pseudo_type
       next if userTypes.include?(m.type)
       @newTypes.push(m.type) if !@newTypes.include?(m.type)
     end
-    if @newTypes.length==0
+    if @newTypes.length == 0
       @battle.pbDisplay(_INTL("But it failed!"))
       return true
     end
@@ -855,7 +855,7 @@ class Battle::Move::SetUserTypesToUserMoveType < Battle::Move
     newType = @newTypes[@battle.pbRandom(@newTypes.length)]
     user.pbChangeTypes(newType)
     typeName = GameData::Type.get(newType).name
-    @battle.pbDisplay(_INTL("{1}'s type changed to {2}!",user.pbThis,typeName))
+    @battle.pbDisplay(_INTL("{1}'s type changed to {2}!", user.pbThis, typeName))
   end
 end
 
@@ -896,10 +896,10 @@ class Battle::Move::SetTargetTypesToWater < Battle::Move
     return false
   end
 
-  def pbEffectAgainstTarget(user,target)
+  def pbEffectAgainstTarget(user, target)
     target.pbChangeTypes(:WATER)
     typeName = GameData::Type.get(:WATER).name
-    @battle.pbDisplay(_INTL("{1}'s type changed to {2}!",target.pbThis,typeName))
+    @battle.pbDisplay(_INTL("{1}'s type changed to {2}!", target.pbThis, typeName))
   end
 end
 
@@ -917,10 +917,10 @@ class Battle::Move::AddGhostTypeToTarget < Battle::Move
     return false
   end
 
-  def pbEffectAgainstTarget(user,target)
+  def pbEffectAgainstTarget(user, target)
     target.effects[PBEffects::Type3] = :GHOST
     typeName = GameData::Type.get(:GHOST).name
-    @battle.pbDisplay(_INTL("{1} transformed into the {2} type!",target.pbThis,typeName))
+    @battle.pbDisplay(_INTL("{1} transformed into the {2} type!", target.pbThis, typeName))
   end
 end
 
@@ -938,10 +938,10 @@ class Battle::Move::AddGrassTypeToTarget < Battle::Move
     return false
   end
 
-  def pbEffectAgainstTarget(user,target)
+  def pbEffectAgainstTarget(user, target)
     target.effects[PBEffects::Type3] = :GRASS
     typeName = GameData::Type.get(:GRASS).name
-    @battle.pbDisplay(_INTL("{1} transformed into the {2} type!",target.pbThis,typeName))
+    @battle.pbDisplay(_INTL("{1} transformed into the {2} type!", target.pbThis, typeName))
   end
 end
 
@@ -949,7 +949,7 @@ end
 # User loses their Fire type. Fails if user is not Fire-type. (Burn Up)
 #===============================================================================
 class Battle::Move::UserLosesFireType < Battle::Move
-  def pbMoveFailed?(user,targets)
+  def pbMoveFailed?(user, targets)
     if !user.pbHasType?(:FIRE)
       @battle.pbDisplay(_INTL("But it failed!"))
       return true
@@ -957,10 +957,10 @@ class Battle::Move::UserLosesFireType < Battle::Move
     return false
   end
 
-  def pbEffectAfterAllHits(user,target)
+  def pbEffectAfterAllHits(user, target)
     if !user.effects[PBEffects::BurnUp]
       user.effects[PBEffects::BurnUp] = true
-      @battle.pbDisplay(_INTL("{1} burned itself out!",user.pbThis))
+      @battle.pbDisplay(_INTL("{1} burned itself out!", user.pbThis))
     end
   end
 end
@@ -971,7 +971,7 @@ end
 class Battle::Move::SetTargetAbilityToSimple < Battle::Move
   def canMagicCoat?; return true; end
 
-  def pbMoveFailed?(user,targets)
+  def pbMoveFailed?(user, targets)
     if !GameData::Ability.exists?(:SIMPLE)
       @battle.pbDisplay(_INTL("But it failed!"))
       return true
@@ -987,12 +987,12 @@ class Battle::Move::SetTargetAbilityToSimple < Battle::Move
     return false
   end
 
-  def pbEffectAgainstTarget(user,target)
-    @battle.pbShowAbilitySplash(target,true,false)
+  def pbEffectAgainstTarget(user, target)
+    @battle.pbShowAbilitySplash(target, true, false)
     oldAbil = target.ability
     target.ability = :SIMPLE
     @battle.pbReplaceAbilitySplash(target)
-    @battle.pbDisplay(_INTL("{1} acquired {2}!",target.pbThis,target.abilityName))
+    @battle.pbDisplay(_INTL("{1} acquired {2}!", target.pbThis, target.abilityName))
     @battle.pbHideAbilitySplash(target)
     target.pbOnLosingAbility(oldAbil)
     target.pbTriggerAbilityOnGainingIt
@@ -1005,7 +1005,7 @@ end
 class Battle::Move::SetTargetAbilityToInsomnia < Battle::Move
   def canMagicCoat?; return true; end
 
-  def pbMoveFailed?(user,targets)
+  def pbMoveFailed?(user, targets)
     if !GameData::Ability.exists?(:INSOMNIA)
       @battle.pbDisplay(_INTL("But it failed!"))
       return true
@@ -1021,12 +1021,12 @@ class Battle::Move::SetTargetAbilityToInsomnia < Battle::Move
     return false
   end
 
-  def pbEffectAgainstTarget(user,target)
-    @battle.pbShowAbilitySplash(target,true,false)
+  def pbEffectAgainstTarget(user, target)
+    @battle.pbShowAbilitySplash(target, true, false)
     oldAbil = target.ability
     target.ability = :INSOMNIA
     @battle.pbReplaceAbilitySplash(target)
-    @battle.pbDisplay(_INTL("{1} acquired {2}!",target.pbThis,target.abilityName))
+    @battle.pbDisplay(_INTL("{1} acquired {2}!", target.pbThis, target.abilityName))
     @battle.pbHideAbilitySplash(target)
     target.pbOnLosingAbility(oldAbil)
     target.pbTriggerAbilityOnGainingIt
@@ -1039,7 +1039,7 @@ end
 class Battle::Move::SetUserAbilityToTargetAbility < Battle::Move
   def ignoresSubstitute?(user); return true; end
 
-  def pbMoveFailed?(user,targets)
+  def pbMoveFailed?(user, targets)
     if user.unstoppableAbility?
       @battle.pbDisplay(_INTL("But it failed!"))
       return true
@@ -1048,7 +1048,7 @@ class Battle::Move::SetUserAbilityToTargetAbility < Battle::Move
   end
 
   def pbFailsAgainstTarget?(user, target, show_message)
-    if !target.ability || user.ability==target.ability
+    if !target.ability || user.ability == target.ability
       @battle.pbDisplay(_INTL("But it failed!")) if show_message
       return true
     end
@@ -1060,13 +1060,13 @@ class Battle::Move::SetUserAbilityToTargetAbility < Battle::Move
     return false
   end
 
-  def pbEffectAgainstTarget(user,target)
-    @battle.pbShowAbilitySplash(user,true,false)
+  def pbEffectAgainstTarget(user, target)
+    @battle.pbShowAbilitySplash(user, true, false)
     oldAbil = user.ability
     user.ability = target.ability
     @battle.pbReplaceAbilitySplash(user)
     @battle.pbDisplay(_INTL("{1} copied {2}'s {3}!",
-       user.pbThis,target.pbThis(true),target.abilityName))
+       user.pbThis, target.pbThis(true), target.abilityName))
     @battle.pbHideAbilitySplash(user)
     user.pbOnLosingAbility(oldAbil)
     user.pbTriggerAbilityOnGainingIt
@@ -1079,7 +1079,7 @@ end
 class Battle::Move::SetTargetAbilityToUserAbility < Battle::Move
   def canMagicCoat?; return true; end
 
-  def pbMoveFailed?(user,targets)
+  def pbMoveFailed?(user, targets)
     if !user.ability
       @battle.pbDisplay(_INTL("But it failed!"))
       return true
@@ -1100,12 +1100,12 @@ class Battle::Move::SetTargetAbilityToUserAbility < Battle::Move
     return false
   end
 
-  def pbEffectAgainstTarget(user,target)
-    @battle.pbShowAbilitySplash(target,true,false)
+  def pbEffectAgainstTarget(user, target)
+    @battle.pbShowAbilitySplash(target, true, false)
     oldAbil = target.ability
     target.ability = user.ability
     @battle.pbReplaceAbilitySplash(target)
-    @battle.pbDisplay(_INTL("{1} acquired {2}!",target.pbThis,target.abilityName))
+    @battle.pbDisplay(_INTL("{1} acquired {2}!", target.pbThis, target.abilityName))
     @battle.pbHideAbilitySplash(target)
     target.pbOnLosingAbility(oldAbil)
     target.pbTriggerAbilityOnGainingIt
@@ -1118,7 +1118,7 @@ end
 class Battle::Move::UserTargetSwapAbilities < Battle::Move
   def ignoresSubstitute?(user); return true; end
 
-  def pbMoveFailed?(user,targets)
+  def pbMoveFailed?(user, targets)
     if !user.ability
       @battle.pbDisplay(_INTL("But it failed!"))
       return true
@@ -1151,10 +1151,10 @@ class Battle::Move::UserTargetSwapAbilities < Battle::Move
     return false
   end
 
-  def pbEffectAgainstTarget(user,target)
+  def pbEffectAgainstTarget(user, target)
     if user.opposes?(target)
-      @battle.pbShowAbilitySplash(user,false,false)
-      @battle.pbShowAbilitySplash(target,true,false)
+      @battle.pbShowAbilitySplash(user, false, false)
+      @battle.pbShowAbilitySplash(target, true, false)
     end
     oldUserAbil   = user.ability
     oldTargetAbil = target.ability
@@ -1165,10 +1165,10 @@ class Battle::Move::UserTargetSwapAbilities < Battle::Move
       @battle.pbReplaceAbilitySplash(target)
     end
     if Battle::Scene::USE_ABILITY_SPLASH
-      @battle.pbDisplay(_INTL("{1} swapped Abilities with its target!",user.pbThis))
+      @battle.pbDisplay(_INTL("{1} swapped Abilities with its target!", user.pbThis))
     else
       @battle.pbDisplay(_INTL("{1} swapped its {2} Ability with its target's {3} Ability!",
-         user.pbThis,target.abilityName,user.abilityName))
+         user.pbThis, target.abilityName, user.abilityName))
     end
     if user.opposes?(target)
       @battle.pbHideAbilitySplash(user)
@@ -1195,10 +1195,10 @@ class Battle::Move::NegateTargetAbility < Battle::Move
     return false
   end
 
-  def pbEffectAgainstTarget(user,target)
+  def pbEffectAgainstTarget(user, target)
     target.effects[PBEffects::GastroAcid] = true
     target.effects[PBEffects::Truant]     = false
-    @battle.pbDisplay(_INTL("{1}'s Ability was suppressed!",target.pbThis))
+    @battle.pbDisplay(_INTL("{1}'s Ability was suppressed!", target.pbThis))
     target.pbOnLosingAbility(target.ability, true)
   end
 end
@@ -1208,15 +1208,15 @@ end
 # performed its action this round. (Core Enforcer)
 #===============================================================================
 class Battle::Move::NegateTargetAbilityIfTargetActed < Battle::Move
-  def pbEffectAgainstTarget(user,target)
+  def pbEffectAgainstTarget(user, target)
     return if target.damageState.substitute || target.effects[PBEffects::GastroAcid]
     return if target.unstoppableAbility?
-    return if @battle.choices[target.index][0]!=:UseItem &&
-              !((@battle.choices[target.index][0]==:UseMove ||
-              @battle.choices[target.index][0]==:Shift) && target.movedThisRound?)
+    return if @battle.choices[target.index][0] != :UseItem &&
+              !((@battle.choices[target.index][0] == :UseMove ||
+              @battle.choices[target.index][0] == :Shift) && target.movedThisRound?)
     target.effects[PBEffects::GastroAcid] = true
     target.effects[PBEffects::Truant]     = false
-    @battle.pbDisplay(_INTL("{1}'s Ability was suppressed!",target.pbThis))
+    @battle.pbDisplay(_INTL("{1}'s Ability was suppressed!", target.pbThis))
     target.pbOnLosingAbility(target.ability, true)
   end
 end
@@ -1226,7 +1226,7 @@ end
 # (Moongeist Beam, Sunsteel Strike)
 #===============================================================================
 class Battle::Move::IgnoreTargetAbility < Battle::Move
-  def pbChangeUsageCounters(user,specialUsage)
+  def pbChangeUsageCounters(user, specialUsage)
     super
     @battle.moldBreaker = true if !specialUsage
   end
@@ -1239,10 +1239,10 @@ class Battle::Move::StartUserAirborne < Battle::Move
   def unusableInGravity?; return true; end
   def canSnatch?;         return true; end
 
-  def pbMoveFailed?(user,targets)
+  def pbMoveFailed?(user, targets)
     if user.effects[PBEffects::Ingrain] ||
        user.effects[PBEffects::SmackDown] ||
-       user.effects[PBEffects::MagnetRise]>0
+       user.effects[PBEffects::MagnetRise] > 0
       @battle.pbDisplay(_INTL("But it failed!"))
       return true
     end
@@ -1251,7 +1251,7 @@ class Battle::Move::StartUserAirborne < Battle::Move
 
   def pbEffectGeneral(user)
     user.effects[PBEffects::MagnetRise] = 5
-    @battle.pbDisplay(_INTL("{1} levitated with electromagnetism!",user.pbThis))
+    @battle.pbDisplay(_INTL("{1} levitated with electromagnetism!", user.pbThis))
   end
 end
 
@@ -1265,7 +1265,7 @@ class Battle::Move::StartTargetAirborneAndAlwaysHitByMoves < Battle::Move
   def pbFailsAgainstTarget?(user, target, show_message)
     if target.effects[PBEffects::Ingrain] ||
        target.effects[PBEffects::SmackDown] ||
-       target.effects[PBEffects::Telekinesis]>0
+       target.effects[PBEffects::Telekinesis] > 0
       @battle.pbDisplay(_INTL("But it failed!")) if show_message
       return true
     end
@@ -1280,9 +1280,9 @@ class Battle::Move::StartTargetAirborneAndAlwaysHitByMoves < Battle::Move
     return false
   end
 
-  def pbEffectAgainstTarget(user,target)
+  def pbEffectAgainstTarget(user, target)
     target.effects[PBEffects::Telekinesis] = 3
-    @battle.pbDisplay(_INTL("{1} was hurled into the air!",target.pbThis))
+    @battle.pbDisplay(_INTL("{1} was hurled into the air!", target.pbThis))
   end
 end
 
@@ -1300,19 +1300,19 @@ end
 class Battle::Move::HitsTargetInSkyGroundsTarget < Battle::Move
   def hitsFlyingTargets?; return true; end
 
-  def pbCalcTypeModSingle(moveType,defType,user,target)
+  def pbCalcTypeModSingle(moveType, defType, user, target)
     return Effectiveness::NORMAL_EFFECTIVE_ONE if moveType == :GROUND && defType == :FLYING
     return super
   end
 
-  def pbEffectAfterAllHits(user,target)
+  def pbEffectAfterAllHits(user, target)
     return if target.fainted?
     return if target.damageState.unaffected || target.damageState.substitute
     return if target.inTwoTurnAttack?("TwoTurnAttackInvulnerableInSkyTargetCannotAct") ||
-              target.effects[PBEffects::SkyDrop]>=0   # Sky Drop
+              target.effects[PBEffects::SkyDrop] >= 0   # Sky Drop
     return if !target.airborne? && !target.inTwoTurnAttack?("TwoTurnAttackInvulnerableInSky",
                                                             "TwoTurnAttackInvulnerableInSkyParalyzeTarget")
-    target.effects[PBEffects::SmackDown]   = true
+    target.effects[PBEffects::SmackDown] = true
     if target.inTwoTurnAttack?("TwoTurnAttackInvulnerableInSky",
                                "TwoTurnAttackInvulnerableInSkyParalyzeTarget")   # NOTE: Not Sky Drop.
       target.effects[PBEffects::TwoTurnAttack] = nil
@@ -1320,7 +1320,7 @@ class Battle::Move::HitsTargetInSkyGroundsTarget < Battle::Move
     end
     target.effects[PBEffects::MagnetRise]  = 0
     target.effects[PBEffects::Telekinesis] = 0
-    @battle.pbDisplay(_INTL("{1} fell straight down!",target.pbThis))
+    @battle.pbDisplay(_INTL("{1} fell straight down!", target.pbThis))
   end
 end
 
@@ -1329,8 +1329,8 @@ end
 # (Gravity)
 #===============================================================================
 class Battle::Move::StartGravity < Battle::Move
-  def pbMoveFailed?(user,targets)
-    if @battle.field.effects[PBEffects::Gravity]>0
+  def pbMoveFailed?(user, targets)
+    if @battle.field.effects[PBEffects::Gravity] > 0
       @battle.pbDisplay(_INTL("But it failed!"))
       return true
     end
@@ -1349,9 +1349,9 @@ class Battle::Move::StartGravity < Battle::Move
         @battle.pbClearChoice(b.index) if !b.movedThisRound?
         showMessage = true
       end
-      if b.effects[PBEffects::MagnetRise]>0 ||
-         b.effects[PBEffects::Telekinesis]>0 ||
-         b.effects[PBEffects::SkyDrop]>=0
+      if b.effects[PBEffects::MagnetRise] > 0 ||
+         b.effects[PBEffects::Telekinesis] > 0 ||
+         b.effects[PBEffects::SkyDrop] >= 0
         b.effects[PBEffects::MagnetRise]  = 0
         b.effects[PBEffects::Telekinesis] = 0
         b.effects[PBEffects::SkyDrop]     = -1
@@ -1367,7 +1367,7 @@ end
 # User transforms into the target. (Transform)
 #===============================================================================
 class Battle::Move::TransformUserIntoTarget < Battle::Move
-  def pbMoveFailed?(user,targets)
+  def pbMoveFailed?(user, targets)
     if user.effects[PBEffects::Transform]
       @battle.pbDisplay(_INTL("But it failed!"))
       return true
@@ -1384,12 +1384,12 @@ class Battle::Move::TransformUserIntoTarget < Battle::Move
     return false
   end
 
-  def pbEffectAgainstTarget(user,target)
+  def pbEffectAgainstTarget(user, target)
     user.pbTransform(target)
   end
 
-  def pbShowAnimation(id,user,targets,hitNum = 0,showAnimation = true)
+  def pbShowAnimation(id, user, targets, hitNum = 0, showAnimation = true)
     super
-    @battle.scene.pbChangePokemon(user,targets[0].pokemon)
+    @battle.scene.pbChangePokemon(user, targets[0].pokemon)
   end
 end