Added decent spacing to all scripts thanks to Rubocop

Data/Scripts/011_Battle/003_Move/004_Move_BaseEffects.rb

@@ -8,7 +8,7 @@
 # Status moves always fail.
 #===============================================================================
 class Battle::Move::Unimplemented < Battle::Move
-  def pbMoveFailed?(user,targets)
+  def pbMoveFailed?(user, targets)
     if statusMove?
       @battle.pbDisplay(_INTL("But it failed!"))
       return true
@@ -21,7 +21,7 @@ end
 # Pseudomove for confusion damage.
 #===============================================================================
 class Battle::Move::Confusion < Battle::Move
-  def initialize(battle,move)
+  def initialize(battle, move)
     @battle     = battle
     @realMove   = move
     @id         = :CONFUSEDAMAGE
@@ -41,16 +41,16 @@ class Battle::Move::Confusion < Battle::Move
     @snatched   = false
   end
 
-  def physicalMove?(thisType = nil);  return true;  end
-  def specialMove?(thisType = nil);   return false; end
-  def pbCritialOverride(user,target); return -1;    end
+  def physicalMove?(thisType = nil);   return true;  end
+  def specialMove?(thisType = nil);    return false; end
+  def pbCritialOverride(user, target); return -1;    end
 end
 
 #===============================================================================
 # Struggle.
 #===============================================================================
 class Battle::Move::Struggle < Battle::Move
-  def initialize(battle,move)
+  def initialize(battle, move)
     @battle     = battle
     @realMove   = nil                     # Not associated with a move
     @id         = (move) ? move.id : :STRUGGLE
@@ -73,10 +73,10 @@ class Battle::Move::Struggle < Battle::Move
   def physicalMove?(thisType = nil); return true;  end
   def specialMove?(thisType = nil);  return false; end
 
-  def pbEffectAfterAllHits(user,target)
+  def pbEffectAfterAllHits(user, target)
     return if target.damageState.unaffected
-    user.pbReduceHP((user.totalhp/4.0).round,false)
-    @battle.pbDisplay(_INTL("{1} is damaged by recoil!",user.pbThis))
+    user.pbReduceHP((user.totalhp / 4.0).round, false)
+    @battle.pbDisplay(_INTL("{1} is damaged by recoil!", user.pbThis))
     user.pbItemHPHealCheck
   end
 end
@@ -87,19 +87,19 @@ end
 class Battle::Move::StatUpMove < Battle::Move
   def canSnatch?; return true; end
 
-  def pbMoveFailed?(user,targets)
+  def pbMoveFailed?(user, targets)
     return false if damagingMove?
-    return !user.pbCanRaiseStatStage?(@statUp[0],user,self,true)
+    return !user.pbCanRaiseStatStage?(@statUp[0], user, self, true)
   end
 
   def pbEffectGeneral(user)
     return if damagingMove?
-    user.pbRaiseStatStage(@statUp[0],@statUp[1],user)
+    user.pbRaiseStatStage(@statUp[0], @statUp[1], user)
   end
 
-  def pbAdditionalEffect(user,target)
-    if user.pbCanRaiseStatStage?(@statUp[0],user,self)
-      user.pbRaiseStatStage(@statUp[0],@statUp[1],user)
+  def pbAdditionalEffect(user, target)
+    if user.pbCanRaiseStatStage?(@statUp[0], user, self)
+      user.pbRaiseStatStage(@statUp[0], @statUp[1], user)
     end
   end
 end
@@ -110,16 +110,16 @@ end
 class Battle::Move::MultiStatUpMove < Battle::Move
   def canSnatch?; return true; end
 
-  def pbMoveFailed?(user,targets)
+  def pbMoveFailed?(user, targets)
     return false if damagingMove?
     failed = true
-    for i in 0...@statUp.length/2
-      next if !user.pbCanRaiseStatStage?(@statUp[i*2],user,self)
+    for i in 0...@statUp.length / 2
+      next if !user.pbCanRaiseStatStage?(@statUp[i * 2], user, self)
       failed = false
       break
     end
     if failed
-      @battle.pbDisplay(_INTL("{1}'s stats won't go any higher!",user.pbThis))
+      @battle.pbDisplay(_INTL("{1}'s stats won't go any higher!", user.pbThis))
       return true
     end
     return false
@@ -128,19 +128,19 @@ class Battle::Move::MultiStatUpMove < Battle::Move
   def pbEffectGeneral(user)
     return if damagingMove?
     showAnim = true
-    for i in 0...@statUp.length/2
-      next if !user.pbCanRaiseStatStage?(@statUp[i*2],user,self)
-      if user.pbRaiseStatStage(@statUp[i*2],@statUp[i*2+1],user,showAnim)
+    for i in 0...@statUp.length / 2
+      next if !user.pbCanRaiseStatStage?(@statUp[i * 2], user, self)
+      if user.pbRaiseStatStage(@statUp[i * 2], @statUp[i * 2 + 1], user, showAnim)
         showAnim = false
       end
     end
   end
 
-  def pbAdditionalEffect(user,target)
+  def pbAdditionalEffect(user, target)
     showAnim = true
-    for i in 0...@statUp.length/2
-      next if !user.pbCanRaiseStatStage?(@statUp[i*2],user,self)
-      if user.pbRaiseStatStage(@statUp[i*2],@statUp[i*2+1],user,showAnim)
+    for i in 0...@statUp.length / 2
+      next if !user.pbCanRaiseStatStage?(@statUp[i * 2], user, self)
+      if user.pbRaiseStatStage(@statUp[i * 2], @statUp[i * 2 + 1], user, showAnim)
         showAnim = false
       end
     end
@@ -151,12 +151,12 @@ end
 # Lower multiple of user's stats.
 #===============================================================================
 class Battle::Move::StatDownMove < Battle::Move
-  def pbEffectWhenDealingDamage(user,target)
+  def pbEffectWhenDealingDamage(user, target)
     return if @battle.pbAllFainted?(target.idxOwnSide)
     showAnim = true
-    for i in 0...@statDown.length/2
-      next if !user.pbCanLowerStatStage?(@statDown[i*2],user,self)
-      if user.pbLowerStatStage(@statDown[i*2],@statDown[i*2+1],user,showAnim)
+    for i in 0...@statDown.length / 2
+      next if !user.pbCanLowerStatStage?(@statDown[i * 2], user, self)
+      if user.pbLowerStatStage(@statDown[i * 2], @statDown[i * 2 + 1], user, showAnim)
         showAnim = false
       end
     end
@@ -174,15 +174,15 @@ class Battle::Move::TargetStatDownMove < Battle::Move
     return !target.pbCanLowerStatStage?(@statDown[0], user, self, show_message)
   end
 
-  def pbEffectAgainstTarget(user,target)
+  def pbEffectAgainstTarget(user, target)
     return if damagingMove?
-    target.pbLowerStatStage(@statDown[0],@statDown[1],user)
+    target.pbLowerStatStage(@statDown[0], @statDown[1], user)
   end
 
-  def pbAdditionalEffect(user,target)
+  def pbAdditionalEffect(user, target)
     return if target.damageState.substitute
-    return if !target.pbCanLowerStatStage?(@statDown[0],user,self)
-    target.pbLowerStatStage(@statDown[0],@statDown[1],user)
+    return if !target.pbCanLowerStatStage?(@statDown[0], user, self)
+    target.pbLowerStatStage(@statDown[0], @statDown[1], user)
   end
 end
 
@@ -195,8 +195,8 @@ class Battle::Move::TargetMultiStatDownMove < Battle::Move
   def pbFailsAgainstTarget?(user, target, show_message)
     return false if damagingMove?
     failed = true
-    for i in 0...@statDown.length/2
-      next if !target.pbCanLowerStatStage?(@statDown[i*2],user,self)
+    for i in 0...@statDown.length / 2
+      next if !target.pbCanLowerStatStage?(@statDown[i * 2], user, self)
       failed = false
       break
     end
@@ -205,19 +205,19 @@ class Battle::Move::TargetMultiStatDownMove < Battle::Move
       #       is shown here, I know.
       canLower = false
       if target.hasActiveAbility?(:CONTRARY) && !@battle.moldBreaker
-        for i in 0...@statDown.length/2
-          next if target.statStageAtMax?(@statDown[i*2])
+        for i in 0...@statDown.length / 2
+          next if target.statStageAtMax?(@statDown[i * 2])
           canLower = true
           break
         end
-        @battle.pbDisplay(_INTL("{1}'s stats won't go any higher!",user.pbThis)) if !canLower && show_message
+        @battle.pbDisplay(_INTL("{1}'s stats won't go any higher!", user.pbThis)) if !canLower && show_message
       else
-        for i in 0...@statDown.length/2
-          next if target.statStageAtMin?(@statDown[i*2])
+        for i in 0...@statDown.length / 2
+          next if target.statStageAtMin?(@statDown[i * 2])
           canLower = true
           break
         end
-        @battle.pbDisplay(_INTL("{1}'s stats won't go any lower!",user.pbThis)) if !canLower && show_message
+        @battle.pbDisplay(_INTL("{1}'s stats won't go any lower!", user.pbThis)) if !canLower && show_message
       end
       if canLower
         target.pbCanLowerStatStage?(@statDown[0], user, self, show_message)
@@ -264,11 +264,11 @@ class Battle::Move::TargetMultiStatDownMove < Battle::Move
     @battle.pbHideAbilitySplash(target)   # To hide target's Mirror Armor splash
   end
 
-  def pbEffectAgainstTarget(user,target)
+  def pbEffectAgainstTarget(user, target)
     pbLowerTargetMultipleStats(user, target) if !damagingMove?
   end
 
-  def pbAdditionalEffect(user,target)
+  def pbAdditionalEffect(user, target)
     pbLowerTargetMultipleStats(user, target) if !target.damageState.substitute
   end
 end
@@ -277,12 +277,12 @@ end
 # Fixed damage-inflicting move.
 #===============================================================================
 class Battle::Move::FixedDamageMove < Battle::Move
-  def pbFixedDamage(user,target); return 1; end
+  def pbFixedDamage(user, target); return 1; end
 
-  def pbCalcDamage(user,target,numTargets = 1)
+  def pbCalcDamage(user, target, numTargets = 1)
     target.damageState.critical   = false
-    target.damageState.calcDamage = pbFixedDamage(user,target)
-    target.damageState.calcDamage = 1 if target.damageState.calcDamage<1
+    target.damageState.calcDamage = pbFixedDamage(user, target)
+    target.damageState.calcDamage = 1 if target.damageState.calcDamage < 1
   end
 end
 
@@ -315,16 +315,16 @@ class Battle::Move::TwoTurnMove < Battle::Move
     return super
   end
 
-  def pbAccuracyCheck(user,target)
+  def pbAccuracyCheck(user, target)
     return true if !@damagingTurn
     return super
   end
 
-  def pbInitialEffect(user,targets,hitNum)
-    pbChargingTurnMessage(user,targets) if @chargingTurn
+  def pbInitialEffect(user, targets, hitNum)
+    pbChargingTurnMessage(user, targets) if @chargingTurn
     if @chargingTurn && @damagingTurn   # Move only takes one turn to use
-      pbShowAnimation(@id,user,targets,1)   # Charging anim
-      targets.each { |b| pbChargingTurnEffect(user,b) }
+      pbShowAnimation(@id, user, targets, 1)   # Charging anim
+      targets.each { |b| pbChargingTurnEffect(user, b) }
       if @powerHerb
         # Moves that would make the user semi-invulnerable will hide the user
         # after the charging animation, so the "UseItem" animation shouldn't show
@@ -335,39 +335,39 @@ class Battle::Move::TwoTurnMove < Battle::Move
              "TwoTurnAttackInvulnerableInSkyParalyzeTarget",
              "TwoTurnAttackInvulnerableRemoveProtections",
              "TwoTurnAttackInvulnerableInSkyTargetCannotAct"].include?(@function)
-          @battle.pbCommonAnimation("UseItem",user)
+          @battle.pbCommonAnimation("UseItem", user)
         end
-        @battle.pbDisplay(_INTL("{1} became fully charged due to its Power Herb!",user.pbThis))
+        @battle.pbDisplay(_INTL("{1} became fully charged due to its Power Herb!", user.pbThis))
         user.pbConsumeItem
       end
     end
-    pbAttackingTurnMessage(user,targets) if @damagingTurn
+    pbAttackingTurnMessage(user, targets) if @damagingTurn
   end
 
-  def pbChargingTurnMessage(user,targets)
-    @battle.pbDisplay(_INTL("{1} began charging up!",user.pbThis))
+  def pbChargingTurnMessage(user, targets)
+    @battle.pbDisplay(_INTL("{1} began charging up!", user.pbThis))
   end
 
-  def pbAttackingTurnMessage(user,targets)
+  def pbAttackingTurnMessage(user, targets)
   end
 
-  def pbChargingTurnEffect(user,target)
+  def pbChargingTurnEffect(user, target)
     # Skull Bash/Sky Drop are the only two-turn moves with an effect here, and
     # the latter just records the target is being Sky Dropped
   end
 
-  def pbAttackingTurnEffect(user,target)
+  def pbAttackingTurnEffect(user, target)
   end
 
-  def pbEffectAgainstTarget(user,target)
+  def pbEffectAgainstTarget(user, target)
     if @damagingTurn
-      pbAttackingTurnEffect(user,target)
+      pbAttackingTurnEffect(user, target)
     elsif @chargingTurn
-      pbChargingTurnEffect(user,target)
+      pbChargingTurnEffect(user, target)
     end
   end
 
-  def pbShowAnimation(id,user,targets,hitNum = 0,showAnimation = true)
+  def pbShowAnimation(id, user, targets, hitNum = 0, showAnimation = true)
     hitNum = 1 if @chargingTurn && !@damagingTurn   # Charging anim
     super
   end
@@ -381,9 +381,9 @@ class Battle::Move::HealingMove < Battle::Move
   def pbHealAmount(user); return 1;    end
   def canSnatch?;         return true; end
 
-  def pbMoveFailed?(user,targets)
-    if user.hp==user.totalhp
-      @battle.pbDisplay(_INTL("{1}'s HP is full!",user.pbThis))
+  def pbMoveFailed?(user, targets)
+    if user.hp == user.totalhp
+      @battle.pbDisplay(_INTL("{1}'s HP is full!", user.pbThis))
       return true
     end
     return false
@@ -392,7 +392,7 @@ class Battle::Move::HealingMove < Battle::Move
   def pbEffectGeneral(user)
     amt = pbHealAmount(user)
     user.pbRecoverHP(amt)
-    @battle.pbDisplay(_INTL("{1}'s HP was restored.",user.pbThis))
+    @battle.pbDisplay(_INTL("{1}'s HP was restored.", user.pbThis))
   end
 end
 
@@ -401,16 +401,16 @@ end
 #===============================================================================
 class Battle::Move::RecoilMove < Battle::Move
   def recoilMove?;                 return true; end
-  def pbRecoilDamage(user,target); return 1;    end
+  def pbRecoilDamage(user, target); return 1;    end
 
-  def pbEffectAfterAllHits(user,target)
+  def pbEffectAfterAllHits(user, target)
     return if target.damageState.unaffected
     return if !user.takesIndirectDamage?
     return if user.hasActiveAbility?(:ROCKHEAD)
-    amt = pbRecoilDamage(user,target)
-    amt = 1 if amt<1
-    user.pbReduceHP(amt,false)
-    @battle.pbDisplay(_INTL("{1} is damaged by recoil!",user.pbThis))
+    amt = pbRecoilDamage(user, target)
+    amt = 1 if amt < 1
+    user.pbReduceHP(amt, false)
+    @battle.pbDisplay(_INTL("{1} is damaged by recoil!", user.pbThis))
     user.pbItemHPHealCheck
   end
 end
@@ -419,18 +419,18 @@ end
 # Protect move.
 #===============================================================================
 class Battle::Move::ProtectMove < Battle::Move
-  def initialize(battle,move)
+  def initialize(battle, move)
     super
     @sidedEffect = false
   end
 
-  def pbChangeUsageCounters(user,specialUsage)
+  def pbChangeUsageCounters(user, specialUsage)
     oldVal = user.effects[PBEffects::ProtectRate]
     super
     user.effects[PBEffects::ProtectRate] = oldVal
   end
 
-  def pbMoveFailed?(user,targets)
+  def pbMoveFailed?(user, targets)
     if @sidedEffect
       if user.pbOwnSide.effects[@effect]
         user.effects[PBEffects::ProtectRate] = 1
@@ -443,8 +443,8 @@ class Battle::Move::ProtectMove < Battle::Move
       return true
     end
     if (!@sidedEffect || Settings::MECHANICS_GENERATION <= 5) &&
-       user.effects[PBEffects::ProtectRate]>1 &&
-       @battle.pbRandom(user.effects[PBEffects::ProtectRate])!=0
+       user.effects[PBEffects::ProtectRate] > 1 &&
+       @battle.pbRandom(user.effects[PBEffects::ProtectRate]) != 0
       user.effects[PBEffects::ProtectRate] = 1
       @battle.pbDisplay(_INTL("But it failed!"))
       return true
@@ -468,9 +468,9 @@ class Battle::Move::ProtectMove < Battle::Move
 
   def pbProtectMessage(user)
     if @sidedEffect
-      @battle.pbDisplay(_INTL("{1} protected {2}!",@name,user.pbTeam(true)))
+      @battle.pbDisplay(_INTL("{1} protected {2}!", @name, user.pbTeam(true)))
     else
-      @battle.pbDisplay(_INTL("{1} protected itself!",user.pbThis))
+      @battle.pbDisplay(_INTL("{1} protected itself!", user.pbThis))
     end
   end
 end
@@ -479,12 +479,12 @@ end
 # Weather-inducing move.
 #===============================================================================
 class Battle::Move::WeatherMove < Battle::Move
-  def initialize(battle,move)
+  def initialize(battle, move)
     super
     @weatherType = :None
   end
 
-  def pbMoveFailed?(user,targets)
+  def pbMoveFailed?(user, targets)
     case @battle.field.weather
     when :HarshSun
       @battle.pbDisplay(_INTL("The extremely harsh sunlight was not lessened at all!"))
@@ -503,7 +503,7 @@ class Battle::Move::WeatherMove < Battle::Move
   end
 
   def pbEffectGeneral(user)
-    @battle.pbStartWeather(user,@weatherType,true,false)
+    @battle.pbStartWeather(user, @weatherType, true, false)
   end
 end
 
@@ -511,7 +511,7 @@ end
 # Pledge move.
 #===============================================================================
 class Battle::Move::PledgeMove < Battle::Move
-  def pbOnStartUse(user,targets)
+  def pbOnStartUse(user, targets)
     @pledgeSetup = false
     @pledgeCombo = false
     @pledgeOtherUser = nil
@@ -519,7 +519,7 @@ class Battle::Move::PledgeMove < Battle::Move
     @overrideAnim = nil
     # Check whether this is the use of a combo move
     @combos.each do |i|
-      next if i[0]!=user.effects[PBEffects::FirstPledge]
+      next if i[0] != user.effects[PBEffects::FirstPledge]
       @battle.pbDisplay(_INTL("The two moves have become one! It's a combined move!"))
       @pledgeCombo = true
       @comboEffect = i[1]
@@ -529,11 +529,11 @@ class Battle::Move::PledgeMove < Battle::Move
     return if @pledgeCombo
     # Check whether this is the setup of a combo move
     user.allAllies.each do |b|
-      next if @battle.choices[b.index][0]!=:UseMove || b.movedThisRound?
+      next if @battle.choices[b.index][0] != :UseMove || b.movedThisRound?
       move = @battle.choices[b.index][2]
       next if !move
       @combos.each do |i|
-        next if i[0]!=move.function
+        next if i[0] != move.function
         @pledgeSetup = true
         @pledgeOtherUser = b
         break
@@ -558,7 +558,7 @@ class Battle::Move::PledgeMove < Battle::Move
     return super
   end
 
-  def pbBaseDamage(baseDmg,user,target)
+  def pbBaseDamage(baseDmg, user, target)
     baseDmg *= 2 if @pledgeCombo
     return baseDmg
   end
@@ -567,33 +567,33 @@ class Battle::Move::PledgeMove < Battle::Move
     user.effects[PBEffects::FirstPledge] = nil
     return if !@pledgeSetup
     @battle.pbDisplay(_INTL("{1} is waiting for {2}'s move...",
-       user.pbThis,@pledgeOtherUser.pbThis(true)))
+       user.pbThis, @pledgeOtherUser.pbThis(true)))
     @pledgeOtherUser.effects[PBEffects::FirstPledge] = @function
     @pledgeOtherUser.effects[PBEffects::MoveNext]    = true
     user.lastMoveFailed = true   # Treated as a failure for Stomping Tantrum
   end
 
-  def pbEffectAfterAllHits(user,target)
+  def pbEffectAfterAllHits(user, target)
     return if !@pledgeCombo
     msg = nil
     animName = nil
     case @comboEffect
     when :SeaOfFire   # Grass + Fire
-      if user.pbOpposingSide.effects[PBEffects::SeaOfFire]==0
+      if user.pbOpposingSide.effects[PBEffects::SeaOfFire] == 0
         user.pbOpposingSide.effects[PBEffects::SeaOfFire] = 4
-        msg = _INTL("A sea of fire enveloped {1}!",user.pbOpposingTeam(true))
+        msg = _INTL("A sea of fire enveloped {1}!", user.pbOpposingTeam(true))
         animName = (user.opposes?) ? "SeaOfFire" : "SeaOfFireOpp"
       end
     when :Rainbow   # Fire + Water
-      if user.pbOwnSide.effects[PBEffects::Rainbow]==0
+      if user.pbOwnSide.effects[PBEffects::Rainbow] == 0
         user.pbOwnSide.effects[PBEffects::Rainbow] = 4
-        msg = _INTL("A rainbow appeared in the sky on {1}'s side!",user.pbTeam(true))
+        msg = _INTL("A rainbow appeared in the sky on {1}'s side!", user.pbTeam(true))
         animName = (user.opposes?) ? "RainbowOpp" : "Rainbow"
       end
     when :Swamp   # Water + Grass
-      if user.pbOpposingSide.effects[PBEffects::Swamp]==0
+      if user.pbOpposingSide.effects[PBEffects::Swamp] == 0
         user.pbOpposingSide.effects[PBEffects::Swamp] = 4
-        msg = _INTL("A swamp enveloped {1}!",user.pbOpposingTeam(true))
+        msg = _INTL("A swamp enveloped {1}!", user.pbOpposingTeam(true))
         animName = (user.opposes?) ? "Swamp" : "SwampOpp"
       end
     end
@@ -601,7 +601,7 @@ class Battle::Move::PledgeMove < Battle::Move
     @battle.pbCommonAnimation(animName) if animName
   end
 
-  def pbShowAnimation(id,user,targets,hitNum = 0,showAnimation = true)
+  def pbShowAnimation(id, user, targets, hitNum = 0, showAnimation = true)
     return if @pledgeSetup   # No animation for setting up
     id = @overrideAnim if @overrideAnim
     return super