Pokemon_Battle_Core 2

#==============================================================================
# ■ Pokemon_Battle_Core
# Pokemon Script Project - Krosk
# 26/07/07
#-----------------------------------------------------------------------------
# Corrigé par RhenaudTheLukark
#-----------------------------------------------------------------------------
# Scène à ne pas modifier de préférence
#-----------------------------------------------------------------------------
# Système de Combat - Pokémon Sauvage
#   Composantes de programmation des attaques
#   Attaque
#-----------------------------------------------------------------------------

#-----------------------------------------------------------------------------
# 0: Normal, 1: Poison, 2: Paralysé, 3: Brulé, 4:Sommeil, 5:Gelé, 8: Toxic
# @confuse (6), @flinch (7)
#-----------------------------------------------------------------------------
# 1 Normal  2 Feu  3 Eau 4 Electrique 5 Plante 6 Glace 7 Combat 8 Poison 9 Sol
# 10 Vol 11 Psy 12 Insecte 13 Roche 14 Spectre 15 Dragon 16 Acier 17 Tenebres
#-----------------------------------------------------------------------------

module POKEMON_S
  #------------------------------------------------------------
  # Pokemon_Battle_Core
  # scene
  #------------------------------------------------------------
  class Pokemon_Battle_Core
    #------------------------------------------------------------
    # Détail du déroulement - Actions pré-round
    #------------------------------------------------------------
    # Vérification saut de phase
    #     Force l'utilisateur à continuer à attaquer
    #     0x27 # Two_turn attack
    #     0x2A # Multi-turn attack
    #     0x4B # Two_turn attack
    #     0x50 # Two_turn reverse
    #     0x75 # Roulade
    #     0x9F # Brouhaha / Uproar
    #     0x1A # Patience / Bide
    #     0x1B # Mania / Thrash
    #------------------------------------------------------------
    def phase_jump(enemy = false)
      @last_skill = $battle_var.last_used
      list = [0x27, 0x2A, 0x4B, 0x50, 0x75, 0x9F, 0x1A, 0x1B, 0x91, 0x97, 0x9B0, 0x9B1, 0x9B2, 0x9B3]
      if not(enemy) # Actor
        for effect in @actor.effect_list
          if list.include?(effect)
            @actor_skill = $battle_var.actor_last_used
            @phase = 2
            return true
          end
        end
        return false
      elsif enemy
        for effect in @enemy.effect_list
          if list.include?(effect)
            @enemy_skill = $battle_var.enemy_last_used
            return false
          end
        end
        return true
      end
    end

    #------------------------------------------------------------
    # Interdictions de switcher
    #------------------------------------------------------------
    def switch_able(actor, enemy)
      # Arena Trap / Piege (ab)
      if enemy.ability == 71 and not (enemy.effect_list.include?(0xEF) or enemy.effect_list.include?(0xF7))
        return false
      end
      # Effets appliqués au user empêchant la fuite
      list = [0x1A, 0x1B, 0x6A, 0x9F, 0xB5]
      for effect in actor.effect_list
        if list.include?(effect)
          return false
        end
      end
      # Effets appliqués à l'ennemi empêchant la fuite
      list = [0x2A]
      for effect in enemy.effect_list
        if list.include?(effect)
          return false
        end
      end
      # Shadow Tag / Marque Ombre (ab) // Magnepiece / Magnet Pull (ab)
      if ((enemy.ability == 23 or enemy.ability == 42) and not
          (enemy.effect_list.include?(0xEF) or enemy.effect_list.include?(0xF7))) and
          enemy.type_steel?
        draw_text("#{enemy.ability_name} de #{enemy.given_name}", "empêche le changement!")
        wait(40)
        return false
      end
      return true
    end

    #------------------------------------------------------------
    # Capacité de fuite
    #------------------------------------------------------------
    def run_able?(runner, opponent)
      x = (Integer(opponent.spd/4) / 255.0)
      rate = Integer(runner.spd*32/x)+(30*($battle_var.run_count))
      if not(flee_able(runner, opponent))
        return false
      end
      if opponent.spd <= runner.spd
        return true
      elsif x == 0
        return true
      elsif rate > 255
        return true
      elsif rand(256) <= rate
        return true
      else
        return false
      end
    end

    #------------------------------------------------------------
    # Interdictions de fuire
    #------------------------------------------------------------
    def flee_able(actor, enemy)
      # Run away / Fuite (ab)
      if actor.ability == 50 and not (actor.effect_list.include?(0xEF) or actor.effect_list.include?(0xF7))
        return true
      end
      # Arena Trap / Piege (ab)
      if enemy.ability == 71 and not (enemy.effect_list.include?(0xEF) or enemy.effect_list.include?(0xF7))
        return false
      end
      list = [0x6A, 0xB5]
      for effect in actor.effect_list
        if list.include?(effect)
          return false
        end
      end
      # Shadow Tag / Marque Ombre (ab) // Magnepiece / Magnet Pull (ab)
      if ((enemy.ability == 23 or enemy.ability == 42) and not
          (enemy.effect_list.include?(0xEF) or enemy.effect_list.include?(0xF7))) and
          enemy.type_steel?
        wait(40)
        return false
      end
      return true
    end

    #------------------------------------------------------------
    # Vérification saut de phase de sélection d'attaque
    #     Force l'utilisateur à utiliser la même attaque
    #------------------------------------------------------------
    def attack_selection_jump
      for effect in @actor.effect_list
        case effect
        when 0x5A # Encore
          return true
        when 0x1A # Patience / Bide
          return true
        when 0x1B # Mania / Thrash
          return true
        end
      end
      return false
    end

    #------------------------------------------------------------
    # Détail du déroulement - Round
    #------------------------------------------------------------
    # Pré-actions , Actions
    #------------------------------------------------------------
    def attack_action(user, user_skill, enemy)
      #------------------------------------------------------------
      # Target , Sprite definition
      #------------------------------------------------------------
      # Target
      target_id = user_skill.target
      if target_id == 0 or target_id == 4 or target_id == 8 or target_id == 20 #Opposants
        target = enemy
      elsif target_id == 10
        target = user # Défini la cible comme l'acteur
      end

      # Assignation sprite et informations
      if user == @actor
        user_sprite = @actor_sprite
        user_status = @actor_status
        user_last_skill = $battle_var.actor_last_used
        user_last_taken_damage = $battle_var.actor_last_taken_damage
      elsif user == @enemy
        user_sprite = @enemy_sprite
        user_status = @enemy_status
        user_last_skill = $battle_var.enemy_last_used
        user_last_taken_damage = $battle_var.enemy_last_taken_damage
      end
      if target == @actor
        target_sprite = @actor_sprite
        target_status = @actor_status
        target_last_skill = $battle_var.actor_last_used
        target_last_taken_damage = $battle_var.actor_last_taken_damage
      elsif target == @enemy
        target_sprite = @enemy_sprite
        target_status = @enemy_status
        target_last_skill = $battle_var.enemy_last_used
        target_last_taken_damage = $battle_var.enemy_last_taken_damage
      end
      last_skill = $battle_var.last_used

      #------------------------------------------------------------
      # Status Check
      #------------------------------------------------------------
      # Sommeil
      if user.asleep?
        if user.sleep_check and not(user.effect_list.include?(0x9F)) # Uproar
          draw_text("#{user.given_name}", "dort!")
          status_animation(user_sprite, user.status)
          wait(40)
          # Attaques actives au sommeil
          # Sleep Talk - Blabla Dodo / Snore - Baillement non affecté par le sommeil
          if not(user_skill.effect == 0x61 or user_skill.effect == 0x5C)
            return
          end
        else
          user_status.refresh
          draw_text("#{user.given_name}", "se réveille!")
          wait(40)
        end
      end

      # Frozen
      if user.frozen?
        if user.froze_check
          if user_skill.effect == 0x7D # Defrost move
            user.cure
            user_status.refresh
            draw_text("#{user.given_name}", "dégèle!")
            wait(40)
          else
            draw_text("#{user.given_name}", "est gelé!")
            status_animation(user_sprite, user.status)
            wait(40)
            return
          end
        else
          user_status.refresh
          draw_text("#{user.given_name}", "dégèle!")
          wait(40)
        end
      end

      # Two turn reverse
      case user_skill.effect
      when 0x50 # Two turn reverse
        if user.effect_list.include?(0x50) # Déjà attaqué
          draw_text("#{user.given_name}", "doit recharger!")
          wait(40)
          return
        end
      end

      # Truant / Absentéisme (ab)
      if user.ability == 54 and not (user.effect_list.include?(0xEF) or user.effect_list.include?(0xF7))
        if user.ability_token == nil
          user.ability_token = false
        end
        if user.ability_token == true
          draw_text("#{user.given_name}", "paresse!")
          wait(40)
          return
        end
      end

      # Flinch
      if user.flinch?
        draw_text("#{user.given_name}", "est apeuré!")
        status_animation(user_sprite, 7)
        user.flinch_check
        wait(40)
        return
      end

      # Confuse
      if user.confused?
        if user.state_count > 0
          draw_text("#{user.given_name}", "est confus!")
          status_animation(user_sprite, 6)
          condition = user.confuse_check
          if condition == true
            draw_text("#{user.given_name}" +  "se blesse", "dans sa confusion.")
            damage = user.confuse_damage
            self_damage(user, user_sprite, user_status, damage)
            wait(40)
            return
          end
        elsif user.state_count == 0
          draw_text("#{user.given_name}", "n'est plus confus!")
          user.cure_state
          wait(40)
        end
      end

      # Paralyze
      if user.paralyzed?
        if user.paralysis_check
          draw_text("#{user.given_name} est paralysé!", "Il ne peut pas attaquer!")
          status_animation(user_sprite, user.status)
          wait(40)
          return
        end
      end

      #------------------------------------------------------------
      # Effets pré-accuracy_check et programmation des attaques
      #------------------------------------------------------------
      pp_use = true
      jumper_end = false
      case user_skill.effect
      when 0x1A # Bide / Patience
        index = user.effect_list.index(0x1A)
        if user.effect_list.include?(0x1A) and [4,5].include?(user.status)
          user.effect.delete_at(index) # Supprime si endormi ou gelé
        end
        if not(user.effect_list.include?(0x1A))
          draw_text("#{user.given_name}", "patiente...")
          wait(40)
          turn = rand(2) + 3
          user.skill_effect(0x1A, turn, 0)
          jumper_end = true
        elsif user.effect[index][1] >= 2 # Encore en charge
          draw_text("#{user.given_name} patiente...")
          wait(40)
          pp_use = false
          jumper_end = true
        else
          pp_use = false
          # Changement de cible!
          if user == @actor
            target = @enemy
            target_sprite = @enemy_sprite
            target_status = @enemy_status
          elsif user == @enemy
            target = @actor
            target_sprite = @actor_sprite
            target_status = @actor_status
          end
        end
      when 0x1B # Thrash / Mania
        index = user.effect_list.index(0x1B)
        if user.effect_list.include?(0x1B) and [4,5].include?(user.status)
          user.effect.delete_at(index) # Supprime si endormi ou gelé
        end
        if not(user.effect_list.include?(0x1B))
          turn = rand(2) + 2
          user.skill_effect(0x1B, turn)
          pp_use = true
        else
          pp_use = false
        end
      when 0x27 # Razor wind / Coupe-Vent / Two turn atk
        if not(user.effect_list.include?(0x27)) # not(Déjà préparé)
          user.skill_effect(0x27, 2)
          draw_text("#{user.given_name} se prépare!")
          jumper_end = true
          wait(40)
        elsif user.effect_list.include?(0x27)
          pp_use = false
          index = user.effect_list.index(0x27)
          user.effect.delete_at(index)
        end
      when 0x4B # Pique/Sky attack / TTA
        if not(user.effect_list.include?(0x4B)) # not(Déjà préparé)
          user.skill_effect(0x4B, 2)
          draw_text("#{user.given_name} se concentre!")
          wait(40)
          jumper_end = true
        elsif user.effect_list.include?(0x4B)
          index = user.effect_list.index(0x4B)
          user.effect.delete_at(index)
          pp_use = false
        end
      when 0x91 # Skull Bash / Coud krane / TTA
        if not(user.effect_list.include?(0x91))
          user.skill_effect(0x91, 2)
          draw_text("#{user.given_name} se prépare!")
          wait(40)
          n = user.change_dfe(+1)
          raise_stat("DFE", user, n)
          jumper_end = true
        elsif user.effect_list.include?(0x91)
          index = user.effect_list.index(0x91)
          user.effect.delete_at(index)
          pp_use = false
        end
      when 0x97 # Solarbeam / Lance-Soleil
        if $battle_var.sunny? and not(user.effect_list.include?(0x97)) # Sunny
          # Continue et lance l'attaque
        elsif not(user.effect_list.include?(0x97))
          user.skill_effect(0x97, 2)
          draw_text("#{user.given_name} se charge!")
          wait(40)
          jumper_end = true
        elsif user.effect_list.include?(0x97)
          pp_use = false
          index = user.effect_list.index(0x97)
          user.effect.delete_at(index)
        end
      when 0x9B0 # Tunnel / Dig
        if not(user.effect_list.include?(0x9B0)) # not(Déjà préparé)
          user.skill_effect(0x9B0, 2)
          draw_text("#{user.given_name} creuse!")
          wait(40)
          jumper_end = true
        else
          index = user.effect_list.index(0x9B0)
          user.effect.delete_at(index)
          pp_use = false
        end
      when 0x9B1 # Fly / Vol
        if not(user.effect_list.include?(0x9B1)) # not(Déjà préparé)
          user.skill_effect(0x9B1, 2)
          draw_text("#{user.given_name} s'envole!")
          wait(40)
          jumper_end = true
        else
          index = user.effect_list.index(0x9B1)
          user.effect.delete_at(index)
          pp_use = false
        end
      when 0x9B2 # Rebond / Bounce
        if not(user.effect_list.include?(0x9B2)) # not(Déjà préparé)
          user.skill_effect(0x9B2, 2)
          draw_text("#{user.given_name} saute!")
          wait(40)
          jumper_end = true
        else
          index = user.effect_list.index(0x9B2)
          user.effect.delete_at(index)
          pp_use = false
        end
      when 0x9B3 # Dive / Plongée
        if not(user.effect_list.include?(0x9B3)) # not(Déjà préparé)
          user.skill_effect(0x9B3, 2)
          draw_text("#{user.given_name} plonge!")
          wait(40)
          jumper_end = true
        else
          pp_use = false
          index = user.effect_list.index(0x9B3)
          user.effect.delete_at(index)
        end
      when 0x108 # Revenant
        if not(user.effect_list.include?(0x108)) # not(Déjà préparé)
          user.skill_effect(0x108, 2)
          draw_text("#{user.given_name} disparaît!")
          wait(40)
          jumper_end = true
        else
          pp_use = false
          index = user.effect_list.index(0x108)
          user.effect.delete_at(index)
        end
      end

      # Spécial dernier skill utilisé
      if user_last_skill != nil
        case user_last_skill.effect
        when 0xB3 # Wish / Souhait
          user.skill_effect(0xB3, 1)
        end
      end

      for effect in user.effect
        case effect[0]
        when 0x51 # Rage / Frénésie # Fin du bonus
          if user_skill.effect != 0x51
            user.change_atk(-effect[2])
            user.effect.delete(effect)
          end
        when 0x5A # Encore
          user_skill = user.skills_set[effect[2]]
        when 0x62 # Prélevement destin / Destiny Bond # Suppression état
          index = user.effect.index(effect)
          user.effect.delete_at(index)
        when 0x75 # Rollout/roulade
          pp_use = false
        when 0x9F # Uproar / Brouhaha
          pp_use = false
        when 0x78 # Attract
          if rand(2) == 1
            draw_text("#{user.given_name} est amoureux!")
            wait(40)
            return
          end
        when 0xC2 # Grudge
          index = user.effect.index(effect)
          user.effect.delete_at(index)
        end
      end

      #------------------------------------------------------------
      # Utilisation de l'attaque
      #------------------------------------------------------------
      # PP spent
      if pp_use
        user_skill.use
        if user == @actor
          $battle_var.actor_last_used = user_skill
          user_last_skill = $battle_var.actor_last_used
        elsif user == @enemy
          $battle_var.enemy_last_used = user_skill
          user_last_skill = $battle_var.enemy_last_used
        end
        $battle_var.last_used = user_skill
        last_skill = $battle_var.last_used
      end

      # Pressure / Pression
      if pp_use and target.ability == 46 and not (target.effect_list.include?(0xEF) or
          target.effect_list.include?(0xF7)) and target == enemy and user_skill.pp > 0
        user_skill.use
      end

      if jumper_end
        return
      end

      # Text
      draw_text("#{user.given_name} utilise", "#{user_skill.name}!")
      wait(10)

      # Redéfinition des derniers skills utilisés
      user_last_skill = user_skill

      #------------------------------------------------------------
      # Décision Hit Miss
      #------------------------------------------------------------
      # Accuracy check
      n = accuracy_check(user_skill, user, target) #weather, status...
      # Accuracy stage
      # si la cible n'est pas soi meme (10), ou OHKO (0x26), pas de vérif
      if user_skill.target != 10 or user.effect != 0x26
        n = Integer(n*accuracy_stage(user, target))
      end
      # Hit or miss
      if rand(100) < n
        hit = true
      else
        hit = false
      end

      multi_hit = 1 # Nombre de coups
      total_hit = 1

      # miss: indicateur que l'attaque touche l'adversaire mais inefficace
      #       "Mais cela échoue!"
      miss = false

      #------------------------------------------------------------
      # Effets pré-attaque et programmation des attaques
      #------------------------------------------------------------
      #    ( zone détermination de la précision / touche ou pas )
      #------------------------------------------------------------
      # Comparaison préliminaire pour les skills "copieurs"

      case user_skill.effect
      when 0x09 # Mirror move / Mimique / Condition de validité
        unlist = [0x52,0x09,0x39,0x53,0x5F,0x61,0x6D,0x70,0xC7,0xB4,0x8F,0x94,0xAA,0xAD,0xB2]
        if target_last_skill == nil or user_last_taken_damage == 0
          miss = true
        elsif target_last_skill.target == 10 or unlist.include?(target_last_skill.effect)
          miss = true
        else
          user_skill = target_last_skill.clone
          user_skill.enable
          user_skill.refill
        end
      when 0x52 # Copie / Mimic
        list = [102, 166, 118, 165]
        for skill in user.skills_set
          list.push(skill.id)
        end
        # Conditions de validité: ne copie pas la luste ni lorsqu'il y a Morphing
        if target_last_skill == nil
          miss = true
        elsif list.include?(target_last_skill.id) or user.effect_list.include?(0x39)
          miss = true
        end
      when 0x53 # Metronome / Condition de validité
        list = [0x53,0x52,0x59,0x90,0x6F,0x74,0x62,0x61,0x69,0xAC,0xC3,0xB0,0xB1,0xAA]
        until not(list.include?(user_skill.effect) or user_skill.id == 165) # Tant que le skill copié est interdit
          user_skill = POKEMON_S::Skill.new(rand($data_skills_pokemon.length)+1)
        end
      when 0x61 # Sleep talk
        unless user.asleep?
          miss = true
        else
          list = []
          for i in 0..user.skills_set.size - 1
            list.push(i)
          end
          list.shuffle!

          copied_skill = user.skills_set[list.shift]
          while !(copied_skill.usable? and not copied_skill.effect == [0x1A, 0x61, 0xB4, 0x09, 0x52, 0xAA, 0x9F, 0x27, 0x4B, 0x91, 0x97, 0x9B])
            copied_skill = user.skills_set[list.shift]
          end
          draw_text("#{user.given_name} utilise","#{copied_skill.name}!")
          user_skill = copied_skill
        end
      when 0xB4 # Assist / Assitance
        no = [0x53,0x52,0x59,0x90,0x6F,0x74,0x62,0x61,0x69,0xAC,0xC3,0xB0,0xB1,0xAA,0xB4]
        list = []
        copied_skill = user_skill
        if user == @actor
          for pokemon in @party.actors
            for skill in pokemon.skills_set
              list.push(skill.clone)
            end
          end
          list.shuffle!
          copied_skill = list.shift
          until not(no.include?(copied_skill)) # Jusqu'a que le skill copié est interdit
            copied_skill = list.shift
          end
        elsif user == @enemy
          for skill in user.skills_set
            list.push(skill.clone)
          end
          list.shuffle!
          copied_skill = list.shift
          until not(no.include?(copied_skill)) # Jusqu'à que le skill copié est interdit
            copied_skill = list.shift
          end
        end
        user_skill = copied_skill
      end

      case user_skill.effect
      # --------- ---------- --------
      #    Conditions de touche
      # --------- ---------- --------
      when 0x11 # Hit without fail
        hit = true
      when 0x4D # Fatal Throw / Corps perdu (Hit without fail)
        hit = true
      when 0x98 # Thunder / Fatal Foudre
        if $battle_var.rain?
          hit = true
        end
      when 0x1D # Random Multi_hit
        number = rand(8)
        case number
        when 0
          multi_hit = 5
        when 1
          multi_hit = 4
        end
        if [2,3,4].include?(number)
          multi_hit = 3
        elsif [5,6,7].include?(number)
          multi_hit = 2
        end
        total_hit = multi_hit
      when 0x2C # Double Strike
        multi_hit = 2
        total_hit = 2
      when 0x4D # Twineedle / Double Dard
        multi_hit = 2
        total_hit = 2
      when 0x68 # Triple pied / Triple Kick
        multi_hit = 3
        total_hit = 3
      # --------- ---------- --------
      #    Conditions de foirage
      # --------- ---------- --------
      when 0x07 # Self destruct et Damp / Moiteur (ab)
        if target.ability == 6 and not (target.effect_list.include?(0xEF) or target.effect_list.include?(0xF7))
          draw_text("#{target.ability_name} de #{target.given_name}", "empêche l'auto-destruction.")
          wait(40)
          return
        end
        if user.ability == 6 and not (user.effect_list.include?(0xEF) or user.effect_list.include?(0xF7))
          draw_text("#{user.ability_name} de #{user.given_name}", "empêche l'auto-destruction.")
          wait(40)
          return
        end
      when 0x20 # Heal 1/2
        if user.hp == user.max_hp
          miss = true
        end
      when 0x23 # Light screen / Mur Lumière
        if user.effect_list.include?(0x23)
          miss = true
        end
      when 0x25
        if user.asleep? # or user.hp == user.max_hp
          miss = true
        end
      when 0x2E # Mist / Brume
        if user.effect_list.include?(0x2E)
          miss = true
        end
      when 0x41 # Protection / Reflet
        if user.effect_list.include?(0x41)
          miss = true
        end
      when 0x5C # Ronflement / Snore
        if not(user.asleep?)
          miss = true
        end
      when 0x7C # Rune Protect / Safeguard
        if user.effect_list.include?(0x7C)
          miss = true
        end
      when 0x39 # Transform / Morphing
        if target.effect_list.include?(0x39)
          miss = true
        end
      when 0x54 # Vampigraine / Leech seed # Fail if grass or already infected
        if [target.type1, target.type2].include?(5)
          miss = true
        end
        if user.effect_list.include?(0x54)
          miss = true
        end
      when 0x56 # Entrave / Disable # Conditions de miss
        # Skill invalide ou non possédé
        if target_last_skill == nil or target.skills_set.index(target_last_skill) == nil
          miss = true
        elsif target.effect_list.include?(0x56) or target_last_skill.pp == 0
          miss = true
        end
      when 0x59 # Riposte / Counter # Conditions de miss
        if target_last_skill == nil or user_last_taken_damage == 0
          miss = true
        elsif not(target_last_skill.physical)
          miss = true
        end
      when 0x64 # Depit / Spite
        if target_last_skill != nil
          if target_last_skill.pp <= 1 or target.skills_set.include?(target_last_skill)
            miss = true
          end
        else
          miss = true
        end
      when 0x6A # Regard noir / Mean Look
        if target.effect_list.include?(0x6A)
          miss = true
        end
      when 0x6B # Nightmare / Cauchemar
        if not(target.asleep?) or target.effect_list.include?(0x6B)
          miss = true
        end
      when 0x6D # Curse / Malédiction
        if target.effect_list.include?(0x6D)
          miss = true
        end
      when 0x6F # Abri / Detection
        if user.effect_list.include?(0x6F)
          index = user.effect_list.index(0x6F)
          used = user.effect[index][2] + 1
          rate = rand(2**16)
          if rate > (2**16) / used
            miss = true
          end
        end
      when 0x74 # Endure / Tenacité
        if user.effect_list.include?(0x74)
          index = user.effect_list.index(0x74)
          used = user.effect[index][2] + 1
          rate = rand(2**16)
          if rate > (2**16) / used
            miss = true
          end
        end
      when 0x78 # Attract / Attraction
        if target.effect_list.include?(0x78) or (target.gender + user.gender) != 3
          miss = true
        end
        # Benet / Oblivious (ab)
        if target.ability == 12 and not (target.effect_list.include?(0xEF) or target.effect_list.include?(0xF7))
          draw_text("#{target.ability_name} de #{target.given_name}", "l'empêche d'être amoureux.")
          wait(40)
          return
        end
      when 0x90 # Voile miroir / Mirror Coat # Conditions de miss
        if not(target_last_skill.special) or user_last_taken_damage == 0
          miss = true
        end
      when 0x5A # Encore
        if target_last_skill == nil
          miss = true
        elsif target_last_skill.pp == 0 or
            not(target.skills_set.include?(target_last_skill)) or
            [165, 227, 119].include?(target_last_skill.id)
          miss = true
        elsif target.effect_list.include?(0x5A) or user.effect_list.include?(0x5A)
          miss = true
        end
      when 0x5F # Gribouille / Sketch
        if [166, 165].include?(target_last_skill.id) or
            user.skills.include?(target_last_skill.id)
          miss = true
        end
      when 0x8E # Cognobidon / Belly drum
        if user.hp <= (user.max_hp / 2) or user.atk_stage >= 6
          miss = true
        end
      when 0xA5 # Torment / Tourmente
        index = target.skills_set.index(target_last_skill)
        if index == nil
          miss = true
        end
      when 0xAA # Mitra-Poing
        if user_last_taken_damage != 0
          miss = true
        end
      when 0xBA # Brick Break / Casse-Brique
        if hit
          target.effect.delete(target.effect.rassoc("0x41"))
          target.effect.delete(target.effect.rassoc("0x23"))
        end
      when 0xBB # Yawn / Baillement
        if target.status != 0 or target.effect_list.include?(0x7C)
          miss = true
        end
      when 0xB5
        if user.effect_list.include?(0xB5)
          miss = true
        end
      when 0xB1 # Trick / Passe-Passe
        if user.item_hold == 0 and target.item_hold == 0
          miss = true
        end
      when 0x1E # Conversion / Adaptation
        # Si il existe un skill qui est valide
        list = []
        for skill in user.skills_set
          list.push(skill.type)
        end
        list.delete(user.type1)
        list.delete(user.type2)
        list.delete(0) # Curse / Malédiction
        if list.length == 0
          miss = true
        end
      when 0xB3 # Wish / Souhait
        if user.effect_list.include?(0xB3)
          miss = true
        end
      when 0xC9 # Mud Sport / Lance-Boue
        if user.effect_list.include?(0xC9)
          miss = true
        end
      when 0xD2 # Water Sport / Tourniquet
        if user.effect_list.include?(0xD2)
          miss = true
        end
      when 0xD8 # Oeil Miracle
        target.eva_stage = 0
        draw_text("#{user.given_name} sait", "où est #{target.given_name}!")
        target.skill_effect(0xD8)
      when 0xDC # Voeu Soin (+ effet)
        if $pokemon_party.number_alive == 1
          miss = true
        else
          user.effect_list(0xDC)
          rec_damage = user.hp
          self_damage(user, user_sprite, user_status, rec_damage)
          draw_text("#{user.given_name}", "se sacrifie pour son allié!")
          wait(40)
        end
      when 0xE1  # Vent Arrière
        if user.effect_list.include?(0xE1)
          miss = true
        end
      when 0xE2 # Acupression
        random_stat = rand(7).to_i
        case random_stat
        when 0
          n = user.change_atk(+2)
          raise_stat("ATK", user, n)
        when 1
          n = user.change_dfe(+2)
          raise_stat("DFE", user, n)
        when 2
          n = user.change_spd(+2)
          raise_stat("SPD", user, n)
        when 3
          n = user.change_ats(+2)
          raise_stat("ATS", user, n)
        when 4
          n = user.change_dfs(+2)
          raise_stat("DFS", user, n)
        when 5
          n = user.change_acc(+2)
          raise_stat("ACC", user, n)
        when 6
          n = user.change_eva(+2)
          raise_stat("EVA", user, n)
        end
      when 0xE3 # Fulmifer
        if @strike_first or user_last_taken_damage == 0
          miss = true
        end
      when 0xE5 # Close Combat
        n = user.change_dfe(-1)
        reduce_stat("DFE", user, n)
        n = user.change_dfs(-1)
        reduce_stat("DFS", user, n)
      when 0xE8 # Embargo
        if target.effect_list.include?(0xE8)
          miss = true
        end
      when 0xE9 # Dégommage
        if user.item_hold == [0..12, 176, 193..204, 253..260, 277..329, 332..350] or
          (user.item_hold == [261..276] and user.id == 493)
          miss = true
        end
      when 0xEA # Echange Psy (+ effet)
        if target.status != 0
          miss = true
        else
          if user.poisoned?
            status_check(target, 1)
          elsif user.paralyzed?
            status_check(target, 2)
          elsif user.burn?
            status_check(target, 3)
          elsif user.asleep?
            status_check(target, 4)
          elsif user.frozen?
            status_check(target, 5)
          elsif user.confused?
            status_check(target, 6)
          elsif user.toxic?
            status_check(target, 8)
          else
            miss = true
          end
          target_status.refresh
        end
      when 0xF1 # Moi d'Abord (+ effet)
        actor_user = true
        if user == enemy
          @target_skill = @enemy_skill
          actor_user = false
        else
          @target_skill = @actor_skill
        end
        if !@strike_first or @target_skill.power == 0
          miss = true
        else
          @me_first = true
          if actor_user
            @enemy_skill = @actor_skill
            attack_action(@enemy, @enemy_skill, @actor)
          else
            @actor_skill = @enemy_skill
            attack_action(@actor, @actor_skill, @enemy)
          end
        end
      when 0xF2 # Photocopie (+ effet)
        if $battle_var.last_used != nil
          if user == @actor
            attack_action(@actor, $battle_var.last_used, @enemy)
          else
            attack_action(@enemy, $battle_var.last_used, @actor)
          end
        else
          miss = true
        end
      when 0xF3 # Permuforce (effet)
        temp_atk_stage = user.atk_stage
        temp_ats_stage = user.ats_stage
        user.atk_stage = target.atk_stage
        user.ats_stage = target.ats_stage
        target.atk_stage = temp_atk_stage
        target.ats_stage = temp_ats_stage
        draw_text("Les changements d'attaque", "des Pokémon ont été échangés!")
        wait(40)
      when 0xF4 # Permugarde (effet)
        temp_dfe_stage = user.dfe_stage
        temp_dfs_stage = user.dfs_stage
        user.dfe_stage = target.dfe_stage
        user.dfs_stage = target.dfs_stage
        target.dfe_stage = temp_dfe_stage
        target.dfs_stage = temp_dfs_stage
        draw_text("Les changements de défense", "des Pokémon ont été échangés!")
        wait(40)
      when 0xF6 # Dernierecour
        for skill in user.skills_set
          if skill.pp == skill.maxpp and skill.name != "DERNIERECOUR"
            miss = true
            break
          end
        end
      when 0xF7 # Soucigraine
        if target.effect_list.include?(0xF7)
          miss = true
        end
      when 0xF8 # Coup Bas
        if !@strike_first or @target_skill.power == 0
          miss = true
        end
      when 0xFA # Permucoeur (effet)
        temp_atk_stage = user.atk_stage
        temp_ats_stage = user.ats_stage
        temp_dfe_stage = user.dfe_stage
        temp_dfs_stage = user.dfs_stage
        temp_acc_stage = user.acc_stage
        temp_eva_stage = user.eva_stage
        temp_spd_stage = user.spd_stage
        user.atk_stage = target.atk_stage
        user.ats_stage = target.ats_stage
        user.dfe_stage = target.dfe_stage
        user.dfs_stage = target.dfs_stage
        user.acc_stage = target.acc_stage
        user.eva_stage = target.eva_stage
        user.spd_stage = target.spd_stage
        target.atk_stage = temp_atk_stage
        target.ats_stage = temp_ats_stage
        target.dfe_stage = temp_dfe_stage
        target.acc_stage = temp_acc_stage
        target.eva_stage = temp_eva_stage
        target.spd_stage = temp_spd_stage
        draw_text("Les changements de stats", "des Pokémon ont été échangés!")
        wait(40)
      when 0xFB # Anneau Hydro
        if user.effect_list.include?(0xFB)
          miss = true
        end
      when 0xFC # Vol Magnétik
        if user.effect_list.include?(0xFC)
          miss = true
        end
      when 0x70 # Picots / Spikes
        picots = 0
        if target.effect_list.include?(0x70)
          index = target.effect_list.index(0x70)
          picots = target.effect[index][2]
        end
        if picots == 3
          miss = true
        else
          target.effect_list.delete(0x70)
          picots += 1
          target.skill_effect(0x70, -1, picots)
          draw_text("#{user.given_name} pose des", "picots vers l'ennemi!")
          wait(40)
        end
      when 0xF9 # Pics Toxic (+ effet)
        picots_toxic = 0
        if target.effect_list.include?(0xF9)
          index = target.effect_list.index(0xF9)
          picots_toxic = target.effect[index][2]
        end
        if picots_toxic == 2
          miss = true
        else
          target.effect_list.delete(0xF9)
          picots_toxic += 1
          target.skill_effect(0xF9, -1, picots_toxic)
          draw_text("#{enemy.given_name} pose des", "pics empoisonnés vers l'ennemi!")
          wait(40)
        end
      when 0x101 # Anti-Brume
        for effect in [0x41, 0x23, 0x2E, 0x70, 0x7C, 0xF9]
          if target.effect_list.include?(effect)
            target.effect.delete(effect)
          end
        end
        n = target.change_eva(-1)
        reduce_stat("EVA", target, n)
      when 0x102 # Distorsion
        if actor.effect_list.include?(0x102)
          miss = true
        else
          actor.skill_effect(0x102, 6)
        end
      when 0x103 # Seduction
        if target.gender + user.gender != 3
          n = target.change_ats(-2)
          reduce_stat("ATS", target, n)
        end
      when 0x104 # Piège de Roc
        if target.effect_list.include?(0x104)
          miss = true
        else
          target.skill_effect(0x104)
        end
      when 0x99 # Teleport
        # Arena Trap / Piege (ab) // Run away / Fuite (ab)
        if enemy.ability == 71 and (user.ability != 50 or user.effect_list.include?(0xEF) or
            user.effect_list.include?(0xF7)) and !(enemy.effect_list.include?(0xEF) or
            enemy.effect_list.include?(0xF7))
          draw_text("#{enemy.ability_name} de #{enemy.given_name}", "empêche la fuite.")
          wait(40)
          return
        end
        # Magnet Pull / Magnepiege (ab) // Run away / Fuite (ab)
        if enemy.ability == 42 and (user.ability != 50 or user.effect_list.include?(0xEF) or
            user.effect_list.include?(0xF7)) and !(enemy.effect_list.include?(0xEF) or
            enemy.effect_list.include?(0xF7))
          draw_text("#{enemy.ability_name} de #{enemy.given_name}", "empêche la fuite.")
          wait(40)
          return
        end
        # Shadow Tag / Marque ombre (ab) // Run away / Fuite (ab)
        if enemy.ability == 23 and (user.ability != 50 or user.effect_list.include?(0xEF) or
            user.effect_list.include?(0xF7)) and !(enemy.effect_list.include?(0xEF) or
            enemy.effect_list.include?(0xF7))
          draw_text("#{enemy.ability_name} de #{enemy.given_name}", "empêche la fuite.")
          wait(40)
          return
        end
      end

      #------------------------------------------------------------
      # Attaque
      #------------------------------------------------------------
      #
      #------------------------------------------------------------
      # Multi_hit
      until multi_hit == 0
        multi_hit -= 1

        #------------------------------------------------------------
        # Programmation des attaques et effets de statut
        #------------------------------------------------------------
        critical_special = 0
        # Skill Effect
        case user_skill.effect
        when 0x2B # Good chance of critical_hit
          critical_special = 1
        when 0x4B # Pique/Sky attack / TTA
          critical_special = 1
        when 0x68 # Triple Kick / Triple Pied
          if not(user.effect_list.include?(0x68))
            user.skill_effect(0x68, 1, 0)
          else
            index = user.effect_list.index(0x68)
            user.effect[index][2] += 1
            # Accuracy check à chaque coup
            n = accuracy_check(user_skill, user, target)
            n = Integer(n*accuracy_stage(user, target))
            if rand(100) <= n
              hit = true
            else
              hit = false
            end
          end
        when 0xC8 # Blaze Kick
          critical_special = 1
        when 0xD1 # Poison Tail
          critical_special = 1
        end

        # User effect
        for effect in user.effect
          case effect[0]
          when 0x2F # Focus energy
            critical_special = 2
          when 0xA5 # Torment
            index = user.skills_set.index(user_last_skill)
            user.skills_set[index].disable

            skill_index = effect[2]
            user.skills_set[skill_index].enable

            # new index = index du skill bloqué
            new_index = user.skills_set.index(user_last_skill)
            effect[2] = new_index
          end
        end

        #------------------------------------------------------------
        # Détermination des dommages
        #------------------------------------------------------------
        info = damage_calculation(user_skill, user, target, critical_special)

        # Animation d'attaque
        attack_animation(info, hit, miss, user, user_skill, user_sprite, target_sprite)

        # Invincibilité
        if $game_temp.god_mode
          hit = false
        end

        if hit and not(miss)

          # Damage deal to target
          damage = info[0]
          efficiency = info[2]

          #------------------------------------------------------------
          # Effets attaque et programmation des attaques
          #------------------------------------------------------------
          case user_skill.effect
          # ----------------- -------------- ---------------
          #     Dommages Pré-déterminés / Utilisateur
          # ----------------- -------------- ---------------
          when 0x26 # OHKO
            if damage > 0 # Affecté par les immunités
              damage = target.hp
            end
          when 0x28 # Super Fang
            if damage > 0 # Affecté par les immunités
              damage = target.hp / 2
            end
          when 0x29 # Draco-rage
            if damage > 0
              damage = 40
            end
          when 0x57 # Frappe Atlas
            if damage > 0
              damage = user.level
            end
          when 0x58 # Vague Psy
            if damage > 0
              damage = Integer( user.level * (rand(11) * 10 + 50) / 100 )
            end
          when 0x59 # Counter / Riposte
            if damage > 0
              damage = user_last_taken_damage * 2
            end
          when 0x90 # Voile Miroir / Mirror Coat
            if damage > 0
              damage = user_last_taken_damage * 2
            end
          when 0x65 # False Swipe
            if target.hp - damage <= 0
              damage = target.hp - 1
            end
          when 0x7A # Cadeau / gift
            number = rand(256)
            gift = false
            if number < 26
              damage = 120
            elsif number < 102
              damage = 80
            elsif number < 204
              damage = 40
            else
              damage = 0
              gift = true
            end
          when 0x82 # Sonic boom
            if damage > 0
              damage = 20
            end
          when 0xBD # Endeavor
            if damage > 0
              damage = target.hp - user.hp
            end
          when 0x1A # Bide / Patience
            if damage > 0
              index = user.effect_list.index(0x1A)
              damage = user.effect[index][2] * 2
            end
          end

          # ----------------- -------------- ---------------
          #      Dommages Pré-déterminés / Adversaire
          # ----------------- -------------- ---------------
          for effect in target.effect_list
            case effect
            when 0x6F # Abri / Detection
              if (target == actor and @enemy_skill.effect != 0xDF) or (target == enemy and @actor_skill.effect != 0xDF) or
                 (target == actor and @enemy_skill.effect != 0x108) or (target == enemy and @actor_skill.effect != 0x108) # Ruse
                index = target.effect_list.index(0x6F)
                ind = target.effect[index][1]
                if damage > 0 and ind == 2
                  damage = 0
                  draw_text("#{target.given_name}", "est protégé!")
                  wait(40)
                  return
                end
              else
                if target == actor
                  draw_text("#{@enemy_skill.name} de #{enemy.given_name}", "contourne la défense ennemie!")
                else
                  draw_text("#{@actor_skill.name} de #{actor.given_name}", "contourne la défense ennemie!")
                end
                wait(40)
              end
            when 0x74 # Endure/Tenacité
              index = target.effect_list.index(0x74)
              ind = target.effect[index][1]
              if target.hp - damage <= 0 and ind == 2
                damage = target.hp - 1
                draw_text("#{target.given_name}", "tient le coup!")
                wait(40)
              end
            end
          end

          # ----------------- -------------- ---------------
          #                 Capacités spéciales
          # ----------------- -------------- ---------------
          unless target.effect_list.include?(0xEF) or target.effect_list.include?(0xF7) # Suc Digestif / Soucigraine
            case target.ability
            when 10 # Absorb Volt / Volt Absorb (ab)
              if user_skill.type_electric? and damage > 0
                damage = 0
                bonus = target.max_hp / 4
                heal(target, target_sprite, target_status, bonus)
                draw_text("#{target.ability_name} de #{target.given_name}", "restaure ses PV.")
                wait(40)
              end
            when 11 # Absorb Eau / Water Absorb (ab)
              if user_skill.type_water? and damage > 0
                damage = 0
                bonus = target.max_hp / 4
                heal(target, target_sprite, target_status, bonus)
                draw_text("#{target.ability_name} de #{target.given_name}", "restaure ses PV.")
                wait(40)
              end
            when 18 # Torche / Flash Fire (ab)
              if user_skill.type_fire? and not(target.ability_active)
                damage = 0
                target.ability_active = true
                draw_text("#{target.ability_name} de #{target.given_name}", "s'active!")
                wait(40)
              end
            when 25 # Garde Mystik / Wonder Guard (ab)
              if efficiency != 1
                damage = 0
                draw_text("#{target.ability_name} de #{target.given_name}", "le protège!")
                wait(40)
              end
            when 26 # Levitate (ab)
              if user_skill.type_ground? and !target.effect_list.include?(0xD7)
                damage = 0
                draw_text("#{target.ability_name} de #{target.given_name}", "le protège!")
                wait(40)
              end
            end
          end

          # Cas de Vol Magnétik
          if target.ability != 26 and target.effect_list.include?(0xFC) and
              !(target.effect_list.include?(0xEF) or target.effect_list.include?(0xF7))
            if user_skill.type_ground? and !target.effect_list.include?(0xD7)
              damage = 0
              draw_text("VOL MAGNETIK de #{target.given_name}", "le protège!")
              wait(40)
            end
          end

          effective_damage = 0
          # Dommages
          for i in 1..damage
            effective_damage += 1
            target.remove_hp(1)
            target_status.refresh
            if target.max_hp >= 144 and effective_damage % (target.max_hp / 144 + 1) != 0
              next
            end
            Graphics.update
            Graphics.update
            if target.dead?
              # Loyauté
              target.drop_loyalty
              break
            end
          end
          damage = effective_damage

          # Redéfinition des derniers points de dommage infligés
          if user == @actor #and damage != 0
            $battle_var.enemy_last_taken_damage = damage
          elsif user == @enemy #and damage != 0
            $battle_var.actor_last_taken_damage = damage
          end

          # Multi_hit
          if target.dead?
            total_hit -= multi_hit
            multi_hit = 0
          end

          #------------------------------------------------------------
          # Effets post-attaque et programmation des attaques
          #------------------------------------------------------------
          # Effectiveness

          if multi_hit == 0
            post_attack(info, damage, user_skill.power)
          end

          # --------------------------- ---------------------------------
          # Détermination de l'application de l'effet supplémentaire
          # --------------------------- ---------------------------------
          ec_rate = rand(101)
          effect_applied = ec_rate <= user_skill.effect_chance

          # Serene Grace / Sérenité (ab)
          if user.ability == 32 and not (user.effect_list.include?(0xEF) or user.effect_list.include?(0xF7))
            effect_applied = ec_rate <= (user_skill.effect_chance * 2)
          end

          # --------------------------- ---------------------------------
          # Prise en compte du pourcentage de chance que l'effet s'active
          #                Si l'ennemi est mort ou pas mort
          # --------------------------- ---------------------------------
          if ((user_skill.effect_chance != 0 and effect_applied) or
              user_skill.effect_chance == 0)
            case user_skill.effect
            # ----------------- -------------- -------------------
            #  Dommages/Récupération Post-attaques / Utilisateur
            # ----------------- -------------- ------------------
            when 0x07 # Self-destruct
              rec_damage = user.hp
              self_damage(user, user_sprite, user_status, rec_damage)
              draw_text("#{user.given_name}", "se sacrifie.")
              wait(40)
            when 0x08 # Devoreve / Dream eater
              bonus = damage / 2
              if damage > 0 and bonus == 0
                bonus = 1
              end
              # Liquid ooze / Suintement (ab)
              if target.ability != 64 and not (target.effect_list.include?(0xEF) or target.effect_list.include?(0xF7))
                heal(user, user_sprite, user_status, bonus)
                draw_text("L'énergie du #{target.given_name}", "est draînée.")
                wait(40)
              else
                self_damage(user, user_sprite, user_status, bonus)
                draw_text("#{target.ability_name} de #{target.given_name}", "réduit les PV.")
                wait(40)
              end
            when 0x30 # Bélier
              recoil_damage = damage / 4
              if damage > 0 and recoil_damage == 0
                recoil_damage = 1
              end
              # Head Rock / Tete de rock (ab) // Struggle
              if (user.ability != 69 and !(user.effect_list.include?(0xEF) or
                  user.effect_list.include?(0xF7))) or user_skill.id == 165
                self_damage(user, user_sprite, user_status, recoil_damage)
                draw_text("#{user.given_name} se blesse", "en frappant.")
                wait(40)
              end
            when 0xC6 # Damoclès
              recoil_damage = damage / 3
              if damage > 0 and recoil_damage == 0
                recoil_damage = 1
              end
              # Head Rock / Tete de rock (ab) // Struggle
              if (user.ability != 69 and not (user.effect_list.include?(0xEF) or
                  user.effect_list.include?(0xF7))) or user_skill.id == 165
                self_damage(user, user_sprite, user_status, recoil_damage)
                draw_text("#{user.given_name} se blesse", "en frappant.")
                wait(40)
              end
            when 0xFD # Boutefeu
              recoil_damage = damage / 3
              if damage > 0 and recoil_damage == 0
                recoil_damage = 1
              end
              # Head Rock / Tete de rock (ab) // Struggle
              if (user.ability != 69 and not (user.effect_list.include?(0xEF) or
                  user.effect_list.include?(0xF7))) or user_skill.id == 165
                self_damage(user, user_sprite, user_status, recoil_damage)
                draw_text("#{user.given_name} se blesse", "en frappant.")
                wait(40)
              end
              # Brûlure : 1 chance / 10
              if rand(100) < 10
                status_check(user, 3)
              end
            when 0x03 # Leech
              bonus = damage / 2
              if damage > 0 and bonus == 0
                bonus = 1
              end
              heal(user, user_sprite, user_status, bonus)
              draw_text("L'énergie du #{target.given_name}", "est draînée.")
              wait(40)
            when 0x20 # Heal
              bonus = user.max_hp / 2
              heal(user, user_sprite, user_status, bonus)
              draw_text("#{user.given_name}", "se soigne!")
              wait(40)
            when 0x25 # Rest / Repos
              status_check(user, 4, true)
              user_status.refresh
              user.status_count = 3 # Dort pour 2 tours seulement
              bonus = user.max_hp
              heal(user, user_sprite, user_status, bonus)
              draw_text("#{user.given_name} a regagné", "son énergie.")
              wait(40)
            when 0x5B # Balance / Pain Split
              middle = (user.hp + target.hp)/2
              user_diff = middle - user.hp
              heal(user, user_sprite, user_status, user_diff)
              target_diff = middle - target.hp
              heal(target, target_sprite, target_status, target_diff)
            when 0x7A # Cadeau
              if gift
                bonus = target.hp / 4
                heal(target, target_sprite, target_status, bonus)
              end
              draw_text("Surprise!")
              wait(40)
            when 0x84 # Morning sun / Aurore
              weather = $battle_var.weather[0]
              case weather
              when 1 # Rainy
                bonus = user.max_hp / 4
              when 2 # Sunny
                bonus = user.max_hp * 2 / 3
              when 3 # Sandstorm
                bonus = user.max_hp / 4
              when 4 # Hail
                bonus = user.max_hp / 4
              when 0
                bonus = user.max_hp / 2
              end
              heal(user, user_sprite, user_status, bonus)
            when 0x85 # Synthesis / Synthese
              weather = $battle_var.weather[0]
              case weather
              when 1 # Rainy
                bonus = user.max_hp / 4
              when 2 # Sunny
                bonus = user.max_hp * 2 / 3
              when 3 # Sandstorm
                bonus = user.max_hp / 4
              when 4 # Hail
                bonus = user.max_hp / 4
              when 0
                bonus = user.max_hp / 2
              end
              heal(user, user_sprite, user_status, bonus)
            when 0x86 # Rayon Lune
              weather = $battle_var.weather[0]
              case weather
              when 1 # Rainy
                bonus = user.max_hp / 4
              when 2 # Sunny
                bonus = user.max_hp * 2 / 3
              when 3 # Sandstorm
                bonus = user.max_hp / 4
              when 4 # Hail
                bonus = user.max_hp / 4
              when 0
                bonus = user.max_hp / 2
              end
              heal(user, user_sprite, user_status, bonus)
            when 0x8E # Belly drum / Cognobidon
              damage = user.max_hp / 2
              self_damage(user, user_sprite, user_status, damage)
            when 0xA2 # Avale
              bonus = 0
              if user.effect_list.include?(0xA0)
                index = user.effect_list.index(0xA0)
                case user.effect[index][2]
                when 1
                  bonus = user.max_hp / 4
                when 2
                  bonus = user.max_hp / 2
                when 3
                  bonus = user.max_hp
                end
              end
              heal(user, user_sprite, user_status, bonus)
            when 0xD6 # Atterissage
              bonus = user.max_hp / 2
              heal(user, user_sprite, user_status, bonus)
              user.skill_effect(0xD6, 2)
              draw_text("#{user.given_name}", "perd son type Vol!")
              wait(40)

            # ----------------- -------------- -------------------
            #                  Autres
            # ----------------- -------------- ------------------
            when 0x22 # Pay Day / Jackpot
              draw_text("#{tagret.given_name}", "lâche de l'argent!")
              #$battle_var.add_money(5*target.level)
              $battle_var.money_payday += 5*user.level
              wait(40)
            when 0x26 # OHKO
              draw_text("K.O. en un coup!")
              wait(40)
            when 0x50 # Two_turn reverse
              user.skill_effect(0x50, 2)
            when 0x1D # Multihit
              if multi_hit == 0
                draw_text("#{target.given_name}", "est touché #{total_hit.to_s} fois!")
                wait(40)
              else
                draw_text("... #{(total_hit - multi_hit).to_s} fois...")
              end
            when 0xE0 # Picore
              if target.item_hold == [205..248]
                #if target == enemy
                #  use_item(target.item_hold)
                #end
                target.item_hold = 0
                draw_text("#{user.given_name} a mangé","la baie de #{target.given_name}")
                wait(40)
                draw_text("(Effet de baie non implanté, désolé)")
                wait(10)
              end
            end
          end

          faint_check(user)

          # --------------------------- ---------------------------------
          # Prise en compte du pourcentage de chance que l'effet s'active
          #                     Si l'ennemi n'est pas mort
          # --------------------------- ---------------------------------
          if ((user_skill.effect_chance != 0 and effect_applied) or
              user_skill.effect_chance == 0) and not(target.dead?) and
              (user_skill.power == 0 or (user_skill.power > 0 and efficiency != -2)) and # Cas d'une attaque dégat sans être efficace
              not (target.ability == 19 and user_skill.effect_chance > 0 and
              not (target.effect_list.include?(0xEF) or target.effect_list.include?(0xF7))) # Ecran Poudre / Shield Dust (ab)
            # ----------------- -------------- ---------------
            #                     Utilisateur
            # ----------------- -------------- ---------------
            case user_skill.effect
            # ----------------- -------------- ---------------
            #               Stage Effect
            # ----------------- -------------- ---------------
            when 0x0A
              n = target.change_atk(+1)
              raise_stat("ATK", target, n)
            when 0x0B
              n = target.change_dfe(+1)
              raise_stat("DFE", target, n)
            when 0x0D
              n = target.change_ats(+1)
              raise_stat("ATS", target, n)
            when 0x10
              n = target.change_eva(+1)
              raise_stat("EVA", target, n)
            when 0x12
              n = target.change_atk(-1)
              reduce_stat("ATK", target, n)
            when 0x13
              n = target.change_dfe(-1)
              reduce_stat("DFE", target, n)
            when 0x14
              n = target.change_spd(-1)
              reduce_stat("SPD", target, n)
            when 0x17
              n = target.change_acc(-1)
              reduce_stat("ACC", target, n)
            when 0x18
              n = target.change_eva(-1)
              reduce_stat("EVA", target, n)
            when 0x32
              n = target.change_atk(+2)
              raise_stat("ATK", target, n)
            when 0x33
              n = target.change_dfe(+2)
              raise_stat("DFE", target, n)
            when 0x34
              n = target.change_spd(+2)
              raise_stat("SPD", target, n)
            when 0x35
              n = target.change_ats(+2)
              raise_stat("ATS", target, n)
            when 0x36
              n = target.change_dfs(+2)
              raise_stat("DFS", target, n)
            when 0x3A
              n = target.change_atk(-2)
              reduce_stat("ATK", target, n)
            when 0x3B
              n = target.change_dfe(-2)
              reduce_stat("DFE", target, n)
            when 0x3C
              n = target.change_spd(-2)
              reduce_stat("SPD", target, n)
            when 0x3E
              n = target.change_dfs(-2)
              reduce_stat("DFS", target, n)
            when 0x44
              n = target.change_atk(-1)
              reduce_stat("ATK", target, n)
            when 0x45
              n = target.change_dfe(-1)
              reduce_stat("DFE", target, n)
            when 0x46
              n = target.change_spd(-1)
              reduce_stat("SPD", target, n)
            when 0x47
              n = target.change_ats(-1)
              reduce_stat("ATS", target, n)
            when 0x48
              n = target.change_dfs(-1)
              reduce_stat("DFS", target, n)
            when 0x49
              n = target.change_acc(-1)
              reduce_stat("ACC", target, n)
            when 0x6C
              target.skill_effect(0x6C)
              draw_text("#{target.given_name} est tout", "petit!")
              wait(40)
              n = target.change_eva(+1)
              raise_stat("EVA", target, n)
            when 0x76 # Swagger
              n = target.change_atk(+2)
              raise_stat("ATK", target, n)
              status_check(target, 6)
              target_status.refresh
            when 0xA6 # Flatter
              n = target.change_ats(+2)
              raise_stat("ATS", target, n)
              status_check(target, 6)
              target_status.refresh
            when 0x8A
              n = user.change_dfe(+1)
              raise_stat("DFE", user, n)
            when 0x8B
              n = user.change_atk(+1)
              raise_stat("ATK", user, n)
            when 0x8C # Ancient power
              n = user.change_atk(+1)
              raise_stat("ATK", user, n)
              n = user.change_dfe(+1)
              raise_stat("DFE", user, n)
              n = user.change_spd(+1)
              raise_stat("SPD", user, n)
              n = user.change_ats(+1)
              raise_stat("ATS", user, n)
              n = user.change_dfs(+1)
              raise_stat("DFS", user, n)
            when 0x8E # Belly / Drum Cognobion
              n = user.change_atk(+12)
              raise_stat("ATK", user, n)
            when 0xA8 # Memento
              n = target.change_atk(-2)
              reduce_stat("ATK", target, n)
              n = target.change_ats(-2)
              reduce_stat("ATS", target, n)
              damage = user.hp
              self_damage(user, user_sprite, user_status, damage)
            when 0xB6 # Superpower
              n = user.change_atk(-1)
              reduce_stat("ATK", user, n, true)
              n = user.change_dfe(-1)
              reduce_stat("DFE", user, n, true)
            when 0xCC # Overheat / Psycho Boost
              n = user.change_ats(-2)
              reduce_stat("ATS", user, n, true)
            when 0xCD # Tickle
              n = target.change_atk(-1)
              reduce_stat("ATK", target, n)
              n = target.change_dfe(-1)
              reduce_stat("DFE", target, n)
            when 0xCE # Cosmic Power
              n = user.change_dfe(+1)
              raise_stat("DFE", user, n)
              n = user.change_dfs(+1)
              raise_stat("DFS", user, n)
            when 0xD0 # Bulk Up
              n = user.change_atk(+1)
              raise_stat("ATK", user, n)
              n = user.change_dfe(+1)
              raise_stat("DFE", user, n)
            when 0xD3 # Calm Mind
              n = user.change_ats(+1)
              raise_stat("ATS", user, n)
              n = user.change_dfs(+1)
              raise_stat("DFS", user, n)
            when 0xD4 # Dragon Dance
              n = user.change_atk(+1)
              raise_stat("ATK", user, n)
              n = user.change_spd(+1)
              raise_stat("SPD", user, n)
            when 0x8F # Psych Up / Boost
              user.atk_stage = target.atk_stage
              user.dfe_stage = target.dfe_stage
              user.spd_stage = target.spd_stage
              user.ats_stage = target.ats_stage
              user.dfs_stage = target.dfs_stage
              user.acc_stage = target.acc_stage
              user.eva_stage = target.eva_stage
              draw_text("#{user.given_name} copie les stats", "de "+ "#{target.given_name}"+"!")
              wait(40)
            when 0x6D # Malédiction  / Curse
              if not(user.type_ghost?) # Non-ghost
                n = user.change_spd(-1)
                reduce_stat("SPD", user, n, true)
                n = user.change_atk(+1)
                raise_stat("ATK", user, n)
                n = user.change_dfe(+1)
                raise_stat("DFE", user, n)
              elsif user.type_ghost?
                draw_text("#{user.given_name} maudit", "#{target.given_name}!")
                wait(40)
                damage = user.max_hp / 2
                self_damage(user, user_sprite, user_status, damage)
                target.skill_effect(0x6D)
              end
            when 0x19 # Haze / Buée Noire
              user.reset_stat_stage
              enemy.reset_stat_stage
              raise_stat(0, target)
            when 0x107 # Rayon Chargé
              n = user.change_ats(+1)
              raise_stat("ATS", user, n)

            # ----------------- -------------- ---------------
            #               Déroulement du combat
            # ----------------- -------------- ---------------
            when 0x1C # Expulsion du combat
              # Ventouse / Suction cups (ab)
              if target.ability == 21 and not (target.effect_list.include?(0xEF) or target.effect_list.include?(0xF7))
                draw_text("#{target.ability_name} de #{target.given_name}", "l'empêche d'être expulsé.")
                wait(40)
              else
                if target == @enemy
                  end_battle_flee_enemy(true)
                elsif target == @actor
                  end_battle_flee(true)
                end
              end
            when 0x73 # Weather / sandstorm
              $battle_var.set_sandstorm(5)
              draw_text("Une tempête de sable", "se lève...")
              animation = $data_animations[494]
              @actor_sprite.animation(animation, true)
              loop do
                @actor_sprite.update
                Graphics.update
                Input.update
                if not(@actor_sprite.effect?)
                  break
                end
              end
              wait(20)
            when 0x88 # Weather / Rain dance
              $battle_var.set_rain(5)
              draw_text("Il commence à pleuvoir.")
              animation = $data_animations[493]
              @actor_sprite.animation(animation, true)
              loop do
                @actor_sprite.update
                Graphics.update
                Input.update
                if not(@actor_sprite.effect?)
                  break
                end
              end
              wait(20)
            when 0x89 # weather / sunny
              $battle_var.set_sunny(5)
              draw_text("Le soleil brille.")
              animation = $data_animations[492]
              @actor_sprite.animation(animation, true)
              loop do
                @actor_sprite.update
                Graphics.update
                Input.update
                if not(@actor_sprite.effect?)
                  break
                end
              end
              wait(20)
            when 0xA4 # Hail / Grele
              $battle_var.set_hail(5)
              draw_text("Il commence à grêler.")
              animation = $data_animations[495]
              @actor_sprite.animation(animation, true)
              loop do
                @actor_sprite.update
                Graphics.update
                Input.update
                if not(@actor_sprite.effect?)
                  break
                end
              end
              wait(20)
            when 0x99 # Teleport
              if user == @actor
                end_battle_flee
              else
                end_battle_flee_enemy
              end
            # ----------------- -------------- ---------------
            #             Attaques particulières
            # ----------------- -------------- ---------------

            when 0x55 # Trempette
              draw_text("Mais rien ne se passe...")
              wait(40)
            when 0x64 # Dépit/Spite
              amount = rand(4)+2
              string1 = " a perdu #{amount.to_s} PP!"
              draw_text(target_last_used.name, string1)
              wait(40)
              target_last_used.pp -= amount
            when 0x7E # Magnitude / Ampleur
              draw_text("Séisme de magnitude...", "#{info[3].to_s}!")
              wait(40)
            when 0x69 # Thief / Larcin
              if target.ability == 60 and not (target.effect_list.include?(0xEF) or target.effect_list.include?(0xF7))
                draw_text("#{target.ability_name} de #{target.given_name}", "empêche le vol d'objet!")
                wait(40)
              elsif user.item_hold == 0 and target.item_hold != 0
                user.item_hold = target.item_hold
                target.item_hold = 0
                draw_text("#{user.given_name} vole ", "#{user.item_name}!")
                wait(40)
              end
            when 0xB1 # Trick
              if target.ability == 60 and not (target.effect_list.include?(0xEF) or target.effect_list.include?(0xF7))
                draw_text("#{target.ability_name} de #{target.given_name}", "empêche le vol d'objet!")
                wait(40)
              elsif not(user.item_hold == 0 and target.item_hold == 0)
                hold = user.item_hold
                user.item_hold = target.item_hold
                target.item_hold = hold
                if user.item_hold == 0
                  string = "et ne reçoit rien!"
                else
                  string = "et reçoit #{user.item_name}!"
                end
                draw_text("#{user.given_name} échange les objets", string)
                wait(40)
              end
            when 0xBC # Knock Off
              if target.hp > 0 and target.item_hold != 0
                draw_text("#{target.given_name} lâche ", Item.name(target.item_hold) + "!")
                target.item_hold = 0
                wait(40)
              end
            # ----------------- -------------- ---------------
            #             Modificateur de status
            # ----------------- -------------- ---------------
            # 0: Normal, 1: Poison, 2: Paralysé, 3: Brulé,
            # 4:Sommeil, 5:Gelé;    6: Confus,   7: Flinch, 8:Toxic
            when 0x01 # Sleep
              status_check(target, 4)
              target_status.refresh
            when 0x02 # Poison
              status_check(target, 1)
              target_status.refresh
            when 0x04 # Burn
              status_check(target, 3)
              target_status.refresh
            when 0x05 # Freeze
              status_check(target, 5)
              target_status.refresh
            when 0x06 # Paralyze
              status_check(target, 2)
              target_status.refresh
            when 0x1F # Flinch
              status_check(target, 7)
              target_status.refresh
            when 0x21 # Toxic
              status_check(target, 8)
              target_status.refresh
            when 0xCA # Toxic
              status_check(target, 8)
              target_status.refresh
            when 0x31 # Confuse
              status_check(target, 6)
              target_status.refresh
            when 0xC7 # Confuse
              status_check(target, 6)
              target_status.refresh
            when 0x24 # Triplattaque
              choice_effect = 0
              case rand(3)
              when 0
                choice_effect = 2
              when 1
                choice_effect = 3
              when 2
                choice_effect = 5
              end
              status_check(target, choice_effect)
              target_status.refresh
            when 0x42 # Poison (sur)
              status_check(target, 1)
              target_status.refresh
            when 0x43 # Paralyze (affected by immunity)
              status_check(target, 2)
              target_status.refresh
            when 0x4C # Confuse
              status_check(target, 6)
              target_status.refresh
            when 0x4D # Poison/Double dar
              status_check(target, 1)
              target_status.refresh
            when 0x5C # Flinch for Snore/Ronflement
              status_check(target, 7)
              target_status.refresh
            when 0x7D # Defrost move
              status_check(target, 3)
              target_status.refresh
            when 0x92 # Twister / Ouragan
              status_check(target, 7)
              target_status.refresh
            when 0x96 # Flinch
              status_check(target, 7)
              target_status.refresh
            when 0x98 # Thunder / paralyze
              status_check(target, 2)
              target_status.refresh
            when 0x9B2 # Bounce / Rebond
              status_check(target, 2)
              target_status.refresh
              #index = user.effect_list.index(0x9B2)
              #user.effect.delete_at(index)
            when 0xA7 # Burn
              status_check(target, 3)
              target_status.refresh
            when 0xC8 # Burn
              status_check(target, 3)
              target_status.refresh
            when 0xD1 # Poison Tail
              status_check(target, 1)
              target_status.refresh
            when 0xFE # Crocs Eclair
              if rand(2) == 0
                status_check(target, 2)
                target_status.refresh
              else
                status_check(target, 7)
                target_status.refresh
              end
            when 0xFF # Crocs Givre
              if rand(2) == 0
                status_check(target, 5)
                target_status.refresh
              else
                status_check(target, 7)
                target_status.refresh
              end
            when 0x100 # Crocs Feu
              if rand(2) == 0
                status_check(target, 3)
                target_status.refresh
              else
                status_check(target, 7)
                target_status.refresh
              end
            when 0x66 # Glas de soin / Heal Bell / Aromatherapy
              user.cure
              if user == @actor
                draw_text("L'équipe est soignée!")
                wait(40)
                @party.cure_party
              end
            when 0xAB # Stimulant / Smelling Salt
              if user.paralyzed?
                user.cure
                user_status.refresh
              end
            when 0xC1 # Refresh
              if user.paralyzed? or user.burn? or user.poisoned?
                user.cure
                user_status.refresh
              end
            when 0x1B # Confuse - Mania / Thrash
              index = user.effect_list.index(0x1B)
              if not(user.confused?) and user.effect[index][1] == 1
                status_check(user, 6)
                user_status.refresh
              end
            # ----------------- -------------- ---------------
            #        Modificateur d'effets sur la durée
            # ----------------- -------------- ---------------
            when 0x1E # Conversion / Adaptation
              list = []
              for i in 0..user.skills_set.length-1
                list.push(i)
              end
              list.shuffle!

              chosen_type = user.skills_set[list.pop].type
              until chosen_type != 0 and
                  not([user.type1, user.type2].include?(chosen_type))
                chosen_type = user.skills_set[list.pop].type
              end
              user.skill_effect(0x1E, -1, chosen_type)
              string = type_string(chosen_type) + "!"
              draw_text("#{user.given_name} est", "maintenant de type " + string)
              wait(40)
            when 0x23 # Light screen / Mur Lumière
              target.skill_effect(0x23, 5)
              draw_text("#{user.given_name}", "est protégé!")
              wait(40)
            when 0x2A # Multi Turn Attack
              if not(user.effect_list.include?(0x2A))
                turn = rand(4) + 3
                user.skill_effect(0x2A, turn)
                draw_text("#{target.given_name} est","piégé par " + user_skill.name + "!")
                wait(40)
              end
            when 0x54 # Leech Seed / Vampigraine
              user.skill_effect(0x54)
              draw_text("#{target.given_name}", "est infecté!")
              wait(40)
            when 0x2F # Focus energy / Puissance
              user.skill_effect(0x2F)
              draw_text("#{user.given_name}", "se gonfle!")
              wait(40)
            when 0x2E # Brume / Mist
              user.skill_effect(0x2E, 5)
              draw_text("#{user.given_name} s'entoure", "de brume!")
              wait(40)
            when 0x39 # Transform / Morphing
              if user.effect_list.include?(0x56) # Cure Disable / Entrave
                index = user.effect_list.index(0x56)
                skill_index = user.effect[index][2]
                user.skills_set[skill_index].enable
              end

              set = []
              for skill in target.skills_set
                adskill = skill.clone
                adskill.define_ppmax(5)
                adskill.refill
                adskill.enable
                set.push(adskill)
              end

              data = user.clone
              user.skill_effect(0x39, -1, data)
              draw_text("#{user.given_name}", "se métamorphose!")
              if user == @actor
                @actor.skills_set = set
                @actor.transform_effect(target)
                @actor_sprite.bitmap = RPG::Cache.battler(@enemy.battler_back, 0)
                @actor_sprite.ox = @actor_sprite.bitmap.width / 2
                @actor_sprite.oy = @actor_sprite.bitmap.height
                #@actor_sprite.tone = Tone.new(200,0,200,180)
              else
                @enemy.skills_set = set
                @enemy.transform_effect(target)
                @enemy_sprite.bitmap = RPG::Cache.battler(@actor.battler_face, 0)
                #@enemy_sprite.tone = Tone.new(200,0,200,180)
              end
              wait(40)
            when 0x41 # Reflect / Protection
              target.skill_effect(0x41, 5)
              draw_text("#{user.given_name}", "est protégé!")
              wait(40)
            when 0x4B # Sky attack / TTA
              status_check(target, 7)
              target_status.refresh
            when 0x51 # Frénésie / Rage
              if not(user.effect_list.include?(0x51))
                user.skill_effect(0x51, -1, 0)
              end
            when 0x52 # Copie / Mimic
              cloned_skill = target_last_skill.clone
              cloned_skill.define_ppmax(5)
              cloned_skill.refill
              user.skill_effect(0x52, -1, [user_skill.clone, cloned_skill])
              index = user.skills_set.index(user_skill)
              user.skills_set[index] = cloned_skill
              draw_text("#{user.given_name} copie", cloned_skill.name+"!")
              wait(40)
            when 0x56 # Disable / Entrave
              index = target.skills_set.index(target_last_skill)
              if index != nil
                target.skill_effect(0x56, rand(4) + 2, index)
                target.skills_set[index].disable
                draw_text(target.skills_set[index].name+" est bloqué!")
                wait(40)
              end
            when 0x5A # Encore
              index = target.skills_set.index(target_last_skill)
              target.skill_effect(0x5A, rand(4) + 3, index)
            when 0x5E # Lock-on / Verrouillage
              user.skill_effect(0x5E, 2)
              draw_text("#{user.given_name} cible #{target.given_name}!")
              wait(40)
            when 0x5F # Gribouille // Sketch
              index = user.skills_set.index(user_last_skill)
              user.skills_set[index] = target_last_skill
              draw_text("#{user.given_name} a copié", target_last_skill.name+"!")
              wait(40)
            when 0x62 # Prélèvement destin / Destiny Bond
              user.skill_effect(0x62, 2)
              draw_text("#{user.given_name} lie son" , "destin.")
              wait(40)
            when 0x6A # Regard Noir / Mean Look
              target.skill_effect(0x6A)
              draw_text("#{target.given_name}", "ne peut plus fuir!")
              wait(40)
            when 0x6B # Cauchemar/Nightmare
              target.skill_effect(0x6B)
              draw_text("#{target.given_name} fait des" , "cauchemars!")
              wait(40)
            when 0x6F # Abri / Détection
              if user.effect_list.include?(0x6F)
                index = user.effect_list.index(0x6F)
                effect = user.effect[index]
                effect[1] = 2
                effect[2] += 1
              else
                user.skill_effect(0x6F, 2, 1)
              end
              draw_text("#{user.given_name}", "se protège!")
              wait(40)
            when 0x72 # Requiem / Perish Song
              if not(user.effect_list.include?(0x72))
                user.skill_effect(0x72, 4)
              end
              if not(enemy.effect_list.include?(0x72))
                enemy.skill_effect(0x72, 4)
              end
              draw_text("Une chanson déprimante.")
              wait(40)
            when 0x71 # Clairvoyance / Fore Sight
              target.skill_effect(0x71, -1)
              draw_text("#{user.given_name} identifie ", "#{target.given_name}.")
              wait(40)
            when 0x74 # Tenacité/Endure
              if user.effect_list.include?(0x74)
                index = user.effect_list.index(0x74)
                effect = user.effect[index]
                effect[1] = 2
                effect[2] += 1
              else
                user.skill_effect(0x74, 1)
              end
              draw_text("#{user.given_name} résiste!")
              wait(40)
            when 0x75 # Roulade/Rollout
              if not(user.effect_list.include?(0x75))
                user.skill_effect(0x75, 5, 5)
              elsif damage > 0
                index = user.effect_list.index(0x75)
                user.effect[index][2] -= 1
              elsif damage == 0
                index = user.effect_list.index(0x75)
                user.effect.delete_at(index)
              end
            when 0x77 # Taillade / Fury Cutter
              if not(user.effect_list.include?(0x77))
                user.skill_effect(0x77, -1, -1)
              elsif damage > 0
                index = user.effect_list.index(0x77)
                user.effect[index][2] -= 1
              end
            when 0x78 # Attract
              target.skill_effect(0x78)
              draw_text("#{target.given_name} tombe amoureux", "de #{user.given_name}"+"!")
              wait(40)
            when 0x7C # Safeguard / Rune protect
              target.skill_effect(0x7C, 5)
              draw_text("#{target.given_name}", "est protégé!")
              wait(40)
            when 0x81 # Rapid Spin / Tour rapide
              list = [0x54, 0x2A]
              for effect in list
                if target.effect_list.include?(effect)
                  index = target.effect_list.index(effect)
                  target.effect.delete_at(index)
                  draw_text("#{user.given_name}", "se libère!")
                  wait(40)
                end
              end
              $battle_var.reset_ground_effect(user, actor)
            when 0x9C # Defense Curl / Boul'Armure
              n = user.change_dfe(+1)
              raise_stat("DFE", user, n)
              user.skill_effect(0x9C)
            when 0x9F # Uproar / Brouhaha
              turn = rand(3)+3
              user.skill_effect(0x9F, turn)
              draw_text("#{user.given_name}", "fait un BROUHAHA!")
              wait(40)
            when 0xA0 # Stockpile
              if user.effect_list.include?(0xA0)
                index = user.effect_list.index(0xA0)
                case user.effect[index][2]
                when 1
                  user.effect[index][2] = 2
                  draw_text("#{user.given_name}", "se charge!")
                  wait(40)
                when 2
                  user.effect[index][2] = 3
                  draw_text("#{user.given_name}", "se charge!")
                  wait(40)
                end
                if user.effect[index][2] > 3
                  draw_text("#{user.given_name}", "est chargé à bloc!")
                  wait(40)
                end
              else
                user.skill_effect(0xA0, -1, 1)
                draw_text("#{user.given_name}", "se charge!")
                wait(40)
              end
            when 0xA1 # Spit up / Relache
              if user.effect_list.include?(0xA0)
                index = user.effect_list.index(0xA0)
                user.effect.delete_at(index)
              end
            when 0xA2 # Swallow / Avale
              if user.effect_list.include?(0xA0)
                index = user.effect_list.index(0xA0)
                user.effect.delete_at(index)
              end
            when 0xA5 # Tourment
              index = target.skills_set.index(target_last_skill)
              target.skill_effect(0xA5, -1, index)
              target.skills_set[index].disable
              draw_text("#{target.given_name}", "est tourmenté!")
              wait(40)
            when 0xAE # Charge / Chargeur
              if user.effect_list.include?(0xAE)
                index = user.effect_list.index(0xAE)
                user.effect.delete_at(index)
              end
              user.skill_effect(0xAE, 2)
              draw_text("#{user.given_name}", "est chargé!")
              wait(40)
            when 0xAF # Taunt / Provoc
              target.skill_effect(0xAF, 2)
              draw_text("#{user.given_name} cède à la", "provocation!")
              wait(40)
            when 0xB5 # Ingrain / Racines
              user.skill_effect(0xB5)
              draw_text("#{user.given_name}" , "est enraciné!")
              wait(40)
            when 0xBB # Yawn
              target.skill_effect(0xBB, 2)
              draw_text("#{user.given_name}" , "baîlle!")
              wait(40)
            when 0xC2 # Grudge / Rancune
              user.skill_effect(0xC2, 2)
              draw_text("#{user.given_name}" , "est rancunier!")
              wait(40)
            when 0xC9 # Mud Sport
              user.skill_effect(0xC9)
              draw_text("#{user.given_name}" , "est couvert de boue!")
              wait(40)
            when 0xD2 # Water Sport
              user.skill_effect(0xD2)
              draw_text("#{user.given_name}" , "est mouillé! ... ...")
              wait(40)
            when 0xD7 # Gravity
              target.skill_effect(0xD7)
              draw_text("#{target.given_name}" , "est collé au sol!")
              wait(40)
            when 0xE1 # Vent Arrière
              user.skill_effect(0xE1)
              draw_text("#{user.given_name}" , "est plus rapide!")
            when 0xE4 # Demi-Tour
              faint_check(target)
              if $pokemon_party.number_alive > 1
                scene_temp = Pokemon_Party_Menu.new(0, @z_level + 100, "map", nil, true)
                scene_temp.main
                return_data_temp = scene_temp.return_data
                # Récupération des données
                @switch_id = return_data_temp
                # Switch
                actor_pokemon_switch
              end
            when 0xE8 # Embargo
              target.skill_effect(0xE8, 6)
              draw_text("#{target.given_name} ne peut" , "plus utiliser d'objet!")
              wait(40)
            when 0xEC # Anti-Soin
              target.skill_effect(0xEC, 6)
              draw_text("#{target.given_name} ne peut" , "plus se soigner!")
              wait(40)
            when 0xEE # Astuce Force
              user.skill_effect(0xEE)
              draw_text("#{user.given_name} échange" , "son Attaque et sa Défense!")
              wait(40)
            when 0xEF # Suc Digestif
              target.skill_effect(0xEF)
              draw_text("SUC DIGESTIF annule le" , "talent de #{target.given_name}!")
              wait(40)
            when 0xF0 # Air Veinard
              user.skill_effect(0xF0, 6)
              draw_text("#{user.given_name} est" , "protégé des coups critiques!")
              wait(40)
            when 0xF7 # Soucigraine
              target.skill_effect(0xF7)
              draw_text("Le talent de #{target.given_name}" , "est maintenant Insomnia!")
              wait(40)
            when 0xFB # Anneau Hydro
              user.skill_effect(0xFB)
              draw_text("#{user.given_name} s'enveloppe" , "d'un ANNEAU HYDRO!")
              wait(40)
            when 0xFC # Vol Magnétik
              user.skill_effect(0xFC)
              draw_text("#{user.given_name} lévite" , "grâce à VOL MAGNETIK!")
              wait(40)
            end
          end

          # ----------------- -------------- ------------------
          #     Contrôle des effets adverses / Adversaire
          # ----------------- -------------- ------------------
          for effect in target.effect_list
            case effect
            when 0x62 # Prélèvement destin / Destiny Bond
              if target.dead?
                damage = user.hp
                draw_text("#{target.given_name}", "est lié par le destin.")
                self_damage(user, user_sprite, user_status, damage)
                wait(40)
                faint_check(user)
              end
            when 0xC2 # Grudge
              if target.dead? and not(user.dead?)
                user_skill.pp = 0
              end
            when 0x1A # Bide / Patience
              index = target.effect_list.index(0x1A)
              target.effect[index][2] += damage
            when 0x51 # Frénésie / Rage
              if damage > 0 and multi_hit == 0 # Compte une seule fois
                index = target.effect_list.index(0x51)
                target.change_atk(+1)
                target.effect[index][2] += 1
              end
            end
          end

          faint_check(target)


          # ----------- ---------------- --------------
          #            Capacités spéciales
          # ----------- ---------------- --------------
          unless target.effect_list.include?(0xEF) or target.effect_list.include?(0xF7) # Suc Digestif / Soucigraine
            case target.ability
            when 28 # Synchro (ab)
              if target.ability_token != nil
                draw_text("#{target.ability_name} de #{target.given_name}", "inflige le même statut!")
                wait(40)
                status_check(user, target.ability_token, true)
                user_status.refresh
                target.ability_token = nil
              end
            when 16 # Déguisement / Color change (ab)
              type = user_skill.type
              if [user.type1, user.type2].include?(type) and type != 0 and
                  type != user.ability_token and damage > 0
                user.ability_token = type
                string = type_string(type)
                draw_text("#{target.ability_name} de #{target.given_name}", "change le type en " + string + "!")
                wait(40)
              end
            when 9 # Static (ab)
              # Contact + dommages + 30% chance # force?
              if user_skill.direct? and damage > 0 and rand(100) < 30
                draw_text("#{target.ability_name} de #{target.given_name}", "paralyse #{user.given_name}!")
                wait(40)
                status_check(user, 2, true)
                user_status.refresh
                wait(40)
              end
            when 24 # Peau dure / Rough skin (ab)
              if user_skill.direct? and damage > 0
                draw_text("#{target.ability_name} de #{target.given_name}", "blesse #{user.given_name}!")
                rec_damage = user.max_hp / 16
                self_damage(user, user_sprite, user_status, rec_damage)
                wait(40)
              end
            when 27 # Pose Spore / Effect Spore (ab)
              # Contact + dommages + 10% chance # force?
              if user_skill.direct? and damage > 0 and rand(100) < 10
                draw_text("#{target.ability_name} de #{target.given_name}", "laisse des spores!")
                wait(40)
                status_check(user, [1, 2, 4][rand(3)], true)
                user_status.refresh
                wait(40)
              end
            when 38 # Point poison / Poison point (ab)
              # Contact + dommages + 30% chance # force?
              if user_skill.direct? and damage > 0 and rand(100) < 30
                draw_text("#{target.ability_name} de #{target.given_name}", "empoisonne #{user.given_name}!")
                wait(40)
                status_check(user, 1, true)
                user_status.refresh
                wait(40)
              end
            when 49 # Corps ardent / Flame body (ab)
              # Contact + dommages + 30% chance # force?
              if user_skill.direct? and damage > 0 and rand(100) < 30
                draw_text("#{target.ability_name} de #{target.given_name}", "brûle #{user.given_name}!")
                wait(40)
                status_check(user, 3, true)
                user_status.refresh
                wait(40)
              end
            when 56 # Joli sourire / Cute charm (ab)
              # Contact + dommages + 30% chance # force?
              if user_skill.direct? and damage > 0 and rand(100) < 30 and
                  not(target.effect_list.include?(0x78) or (target.gender + user.gender) != 3)
                user.skill_effect(0x78)
                draw_text("#{target.ability_name} de #{target.given_name}", "séduit #{user.given_name}!")
                wait(40)
              end
            end
          end

          faint_check(target)

        else
          #-------------------------------------------------------
          # Miss
          #--------------------------------------------------------
          case user_skill.effect
          when 0x07 # Self_destruct
            rec_damage = user.hp
            self_damage(user, user_sprite, user_status, rec_damage)
            draw_text("#{user.given_name}","se sacrifie.")
            wait(40)
            faint_check(user)
          when 0x2D # Miss and self_damage
            damage = info[0]
            rec_damage = damage/2
            draw_text("#{user.given_name}","retombe au sol!")
            self_damage(user, user_sprite, user_status, rec_damage)
            wait(30)
            faint_check(user)
          when 0x68 # Triple Kick
            multi_hit = 0 #Arret si échec
          when 0x9B2 # Bounce / Rebond
            if user.effect_list.include?(0x9B2)
              index = user.effect_list.index(0x9B2)
              user.effect.delete_at(index)
            end
          when 0x75 # Roulade/Rollout
            if user.effect_list.include?(0x75)
              index = user.effect_list.index(0x75)
              user.effect.delete_at(index)
            end
          end
        end

        #-------------------------------------------------------
        # Réduction compteur d'effets ?
        #--------------------------------------------------------
        # user.skill_effect_end_turn
        user_status.refresh
        target_status.refresh
      end
    end

    #------------------------------------------------------------
    # Gestion des dêgats automatique en combat
    # Skill utilisé sur l'adversaire
    # Dommages Infligés - user_skill = class Skill, enemy = class Pokemon
    # Renvoie: [damage, critical (true/false), efficency (-2, -1,0,1)]
    #------------------------------------------------------------
    def damage_calculation(user_skill, user, target, critical_special = 0, shortcut = false, int_only = false)
      if user == @actor
        user_last_skill = $battle_var.actor_last_used
        user_last_taken_damage = $battle_var.actor_last_taken_damage
      elsif user == @enemy
        user_last_skill = $battle_var.enemy_last_used
        user_last_taken_damage = $battle_var.enemy_last_taken_damage
      end
      if target == @actor
        target_last_skill = $battle_var.actor_last_used
        target_last_taken_damage = $battle_var.actor_last_taken_damage
      elsif target == @enemy
        target_last_skill = $battle_var.enemy_last_used
        target_last_taken_damage = $battle_var.enemy_last_taken_damage
      end
      last_skill = $battle_var.last_used

      critical_hit = critical_decision(target, critical_special)
      level = user.level
      statistic_refresh_modif
      user.statistic_refresh_modif
      if user_skill.physical
        atk = (critical_hit and user.atk_stage < 0) ? user.atk_basis : user.atk
        dfe = (critical_hit and target.dfe_stage > 0) ? target.dfe_basis : target.dfe
      elsif user_skill.special
        atk = (critical_hit and user.ats_stage < 0) ? user.ats_basis : user.ats
        dfe = (critical_hit and target.dfs_stage > 0) ? target.dfs_basis : target.dfs
      else
        atk = (critical_hit and user.atk_stage < 0) ? user.atk_basis : user.atk
        dfe = (critical_hit and target.dfe_stage > 0) ? target.dfe_basis : target.dfe
      end

      base_damage = user_skill.power
      user_type1 = user.type1
      user_type2 = user.type2
      skill_type = user_skill.type
      target_type1 = target.type1
      target_type2 = target.type2
      weather = $battle_var.weather[0]

      # ------------- -------------- ---------------
      #        Programmation des objets
      # ------------- -------------- ---------------
      #            Boosts de type
      # ------------- -------------- ---------------
      case user.item_name
      when "MOUCH.SOIE"
        atk *= user_type1 == 1 ? 1.1 : 1
      when "CHARBON"
        atk *= user_type1 == 2 ? 1.1 : 1
      when "EAU MYSTIQUE"
        atk *= user_type1 == 3 ? 1.1 : 1
      when "AIMANT"
        atk *= user_type1 == 4 ? 1.1 : 1
      when "GRAIN MIRACL"
        atk *= user_type1 == 5 ? 1.1 : 1
      when "GLACETERNEL"
        atk *= user_type1 == 6 ? 1.1 : 1
      when "CEINT.NOIRE"
        atk *= user_type1 == 7 ? 1.1 : 1
      when "PIC VENIN"
        atk *= user_type1 == 8 ? 1.1 : 1
      when "SABLE DOUX"
        atk *= user_type1 == 9 ? 1.1 : 1
      when "BEC POINTU"
        atk *= user_type1 == 10 ? 1.1 : 1
      when "CUILLERTORDU"
        atk *= user_type1 == 11 ? 1.1 : 1
      when "POUDRE ARG."
        atk *= user_type1 == 12 ? 1.1 : 1
      when "PIERRE DURE"
        atk *= user_type1 == 13 ? 1.1 : 1
      when "RUNE SORT"
        atk *= user_type1 == 14 ? 1.1 : 1
      when "CROC DRAGON"
        atk *= user_type1 == 15 ? 1.1 : 1
      when "PEAU METAL"
        atk *= user_type1 == 16 ? 1.1 : 1
      when "LUNET.NOIRES"
        atk *= user_type1 == 17 ? 1.1 : 1
      end


      # ------------- -------------- ---------------
      #        Programmation des attaques
      # ------------- -------------- ---------------
      #      Redéfinition base_damage (puissance)
      # ------------- -------------- ---------------
      data = nil

      case user_skill.effect
      when 0x07 # Self_destruct
        dfe = dfe / 2
      when 0x63 # Base damage variant
        a = user.hp * 48.0 / user.max_hp
        if a >= 33
          base_damage = 20
        elsif a >= 17
          base_damage = 40
        elsif a >= 10
          base_damage = 80
        elsif a >= 5
          base_damage = 100
        elsif a >= 2
          base_damage = 150
        elsif a < 2
          base_damage = 200
        end
      when 0x7E # Magnitude / Ampleur
        a = rand(100)
        if a < 5
          data = 4
          base_damage = 10
        elsif a < 15
          data = 5
          base_damage = 30
        elsif a < 35
          data = 6
          base_damage = 50
        elsif a < 65
          data = 7
          base_damage = 70
        elsif a < 85
          data = 8
          base_damage = 90
        elsif a < 95
          data = 9
          base_damage = 110
        else
          data = 10
          base_damage = 150
        end
      when 0x68 # Triple Kick/Triple Pied
        if user.effect_list.include?(0x68)
          index = user.effect_list.index(0x68)
          base_damage += 10 * user.effect[index][2]
        end
      when 0x75 # Rollout / Roulade
        # Bonus cumulatif
        if user.effect_list.include?(0x75)
          index = user.effect_list.index(0x75)
          base_damage *= (5-user.effect[index][1])**2
        end
        # Defense Curl/Boul'Armure bonus
        if user.effect_list.include?(0x9C)
          base_damage *= 2
        end
      when 0x77  # Fury Cutter / Taillade
        if user.effect_list.include?(0x77)
          index = user.effect_list.index(0x77)
          multiplier = - user.effect[index][1]
          if multiplier < 5
            base_damage *= multiplier**2
          elsif multiplier >= 5
            base_damage *= 5**2
          end
        end
      when 0x79 # Return / Retour
        base_damage = user.loyalty * 10 / 25
      when 0x7B # Frustration
        base_damage = (255 - user.loyalty) * 10 / 25
      when 0xBE # Base damage basé sur hp
        base_damage = [1, user.hp * 150 / user.max_hp].max
      when 0xC4 # Low Kick
        string = Pokemon_Info.weight(target.id)
        weight = string[0..string.length-2].to_f
        if weight < 10
          base_damage = 20
        elsif weight < 25
          base_damage = 40
        elsif weight < 50
          base_damage = 60
        elsif weight < 100
          base_damage = 80
        elsif weight < 200
          base_damage = 100
        else
          base_damage = 120
        end
      when 0xD9 # Réveil Forcé
        if target.asleep?
          base_damage *= 2
          loop do
            target.sleep_check
            break if not target.sleep_check
          end
          draw_text("#{target.given_name}","se réveille de force!")
        end
      when 0xDB # Gyroballe
        base_damage = 25 * (user.spd / target.spd)
      when 0xDD # Saumure
        if target.hp/target.max_hp < 0.5 then base_damage *= 2 end
      when 0xDE # Don Naturel - Type et Puissance
        item_berry = true
        # Type
        if user.item_hold == [205, 221, 237]
          skill.type = 2    # Feu
        elsif user.item_hold == [206, 222, 238]
          skill.type = 3    # Eau
        elsif user.item_hold == [207, 223, 239]
          skill.type = 4    # Électrik
        elsif user.item_hold == [208, 224, 240]
          skill.type = 5    # Plante
        elsif user.item_hold == [209, 225, 241]
          skill.type = 6    # Glace
        elsif user.item_hold == [210, 226, 242]
          skill.type = 7    # Combat
        elsif user.item_hold == [211, 227, 243]
          skill.type = 8    # Poison
        elsif user.item_hold == [212, 228, 244]
          skill.type = 9    # Sol
        elsif user.item_hold == [213, 229, 245]
          skill.type = 10   # Vol
        elsif user.item_hold == [214, 230, 246]
          skill.type = 11   # Psy
        elsif user.item_hold == [215, 231, 247]
          skill.type = 12   # Insecte
        elsif user.item_hold == [216, 232, 248]
          skill.type = 13   # Roche
        elsif user.item_hold == [217, 233]
          skill.type = 14   # Spectre
        elsif user.item_hold == [218, 234]
          skill.type = 15   # Dragon
        elsif user.item_hold == [219, 235]
          skill.type = 16   # Ténèbres
        elsif user.item_hold == [220, 236]
          skill.type = 17   # Acier
        else
          skill.type = 1
          item_berry = false
        end
        # Puissance
        if user.item_hold == [205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220]     # Baies de niveau 1
          base_damage = 60
        elsif user.item_hold == [221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236]  # Baies de niveau 2
          base_damage = 70
        elsif user.item_hold == [237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248]                      # Baies de niveau 3
          base_damage = 80
        else
          base_damage = 50
        end
        # Enlève l'objet si le joueur a une baie
        if item_berry then user.item_hold = 0 end
      when 0xE3 # Fulmifer
        base_damage = target_last_skill.base_damage * 1.5
      when 0xE6 # Représailles
        if (user == @enemy and @strike_first) or (user == @actor and !@strike_first)
          if user_last_taken_damage > 0
            base_damage *= 2
          end
        end
      when 0xE7 # Assurance
        if (user == @enemy and @strike_first) or (user == @actor and !@strike_first)
          if target_last_skill.effect == [0x30, 0xC6, 0x8E]
            base_damage *= 2
          end
        end
      when 0xE9 # Dégommage
        if user.item_hold == [74, 82, 85, 92..93, 96..97, 100, 102, 109, 205..252, 331]
          base_damage = 10
        elsif user.item_hold == [13..73, 75..80, 84, 87, 89..91, 98..99, 101, 103,
                                 106..108, 110..112, 114..116, 177..181, 184..191]
          base_damage = 30
        elsif user.item_hold == 117
          base_damage = 40
        elsif user.item_hold == [83, 331]
          base_damage = 50
        elsif user.item_hold == [94, 182]
          base_damage = 60
        elsif user.item_hold == [81, 87]
          base_damage = 70
        elsif user.item_hold == [95, 192]
          base_damage = 80
        elsif user.item_hold == [113, 183, 261..276]
          base_damage = 90
        elsif user.item_hold == [86]
          base_damage = 100
        else
          base_damage = 1
        end
        if user.item_hold == 88 # Pics Toxic
          status_check(target, 8)
          target_status.refresh
        elsif user.item_hold == 98 # Roche Royale
          status_check(target, 7)
          target_status.refresh
        elsif user.item_hold == [93, 96] # Herbe Blanche / Herbe Mental
          #user.hold_item_use
        end
        user.item_hold = 0
      when 0xEB # Atout
        case user_skill.pp
        when 1
          base_damage = 200
        when 2
          base_damage = 80
        when 3
          base_damage = 60
        when 4
          base_damage = 50
        else
          base_damage = 40
        end
      when 0xED # Essorage / Presse
        base_damage = 110 * (target.hp/target.max_hp)
      when 0xF5 # Punition (base + augmentations de stats)
        augment_bonus = 0
        if target.atk_stage > 0 then augment_bonus += target.atk_stage end
        if target.dfe_stage > 0 then augment_bonus += target.dfe_stage end
        if target.spd_stage > 0 then augment_bonus += target.spd_stage end
        if target.eva_stage > 0 then augment_bonus += target.eva_stage end
        if target.acc_stage > 0 then augment_bonus += target.acc_stage end
        if target.dfs_stage > 0 then augment_bonus += target.dfs_stage end
        if target.ats_stage > 0 then augment_bonus += target.ats_stage end
        base_damage = 60 + 20 * augment_bonus
        if base_damage > 200 then base_damage = 200 end
      when 0x106 # Jugement
        # Type
        if user.item_hold == 261
          skill.type = 2    # Feu
        elsif user.item_hold == 262
          skill.type = 3    # Eau
        elsif user.item_hold == 263
          skill.type = 4    # Électrik
        elsif user.item_hold == 264
          skill.type = 5    # Plante
        elsif user.item_hold == 265
          skill.type = 6    # Glace
        elsif user.item_hold == 266
          skill.type = 7    # Combat
        elsif user.item_hold == 267
          skill.type = 8    # Poison
        elsif user.item_hold == 268
          skill.type = 9    # Sol
        elsif user.item_hold == 269
          skill.type = 10   # Vol
        elsif user.item_hold == 270
          skill.type = 11   # Psy
        elsif user.item_hold == 271
          skill.type = 12   # Insecte
        elsif user.item_hold == 272
          skill.type = 13   # Roche
        elsif user.item_hold == 273
          skill.type = 14   # Spectre
        elsif user.item_hold == 274
          skill.type = 15   # Dragon
        elsif user.item_hold == 275
          skill.type = 16   # Ténèbres
        elsif user.item_hold == 276
          skill.type = 17   # Acier
        else
          skill.type = 1    # Normal
        end
      when 0x10A # Casse-couilles
        if target.male?
          base_damage *= 2
        end
      end

      # Cas de Moi d'Abord
      if @me_first
        base_damage *= 1.5
        @me_first = false
      end

      # --------- --------------- ----------
      #       Protections adverses
      # --------- --------------- ----------
      for effect in target.effect_list
        case effect
        when 0x9B0 # Dig / Tunnel upx2 Magnitude / Earthquake
          if [0x7E, 0x93].include?(user_skill.effect)
            base_damage *= 2
          end
        when 0x9B1 # Vol / Fly upx2
          if [0x95, 0x98, 0x92].include?(user_skill.effect)
            base_damage *= 2
          end
        when 0x9B2 # Bounce upx2
          if [0x95, 0x98, 0x92].include?(user_skill.effect)
            base_damage *= 2
          end
        when 0x9B3 # Dive + Surf
          if user_skill.id == 15
            base_damage *= 2
          end
        when 0x1E # Conversion / Adaptation
          index = target.effect_list.index(0x1E)
          target_type1 = target.effect[index][2]
          target_type2 = 0
        end
      end

      # --------- --------------- ----------
      #        Bonus Capacités Spéciales
      # --------- --------------- ----------
      unless user.effect_list.include?(0xEF) or user.effect_list.include?(0xF7) # Suc Digestif / Soucigraine
        case user.ability
        when 18 # Flash Fire / Torche (ab)
          if user.ability_active and user_skill.type_fire?
            base_damage *= 1.5
          end
        when 37 # Huge Power / Coloforce (ab)
          if user_skill.physical
            atk *= 2
          end
        when 74 # Pure Power / Fore pure (ab)
          if user_skill.physical
            atk *= 2
          end
        when 55 # Agitation / Hustle (ab)
          if user_skill.physical
            atk *= 1.5
          end
        when 57 # Plus (ab)
          if target.ability == 58 and user_skill.special # Minus
            atk *= 1.5
          end
        when 58 # Minus (ab)
          if target.ability == 57 and user_skill.special # Plus
            atk *= 1.5
          end
        when 62 # Cran / Guts (ab)
          if user.status != 0 and user_skill.physical
            atk *= 1.5
          end
        when 65 # Overgrow / Engrais (ab)
          if user.hp < (user.max_hp/3) and user_skill.type_grass?
            base_damage *= 1.5
          end
        when 66 # Brasier / Blaze (ab)
          if user.hp < (user.max_hp/3) and user_skill.type_fire?
            base_damage *= 1.5
          end
        when 67 # Torrent (ab)
          if user.hp < (user.max_hp/3) and user_skill.type_water?
            base_damage *= 1.5
          end
        when 68 # Essaim / Swarm (ab)
          if user.hp < (user.max_hp/3) and user_skill.type_insect?
            base_damage *= 1.5
          end
        end
      end

      unless target.effect_list.include?(0xEF) or target.effect_list.include?(0xF7) # Suc Digestif / Soucigraine
        case target.ability
        when 47 # Thick Fat / Isograisse (ab)
          if user_skill.type_fire? or user_skill.type_ice?
            atk /= 2
          end
        when 59 # Meteo / Forecast (ab)
          if target.ability_token == nil
            target.ability_token = 1 # Normal
          end
          target_type1 = target.ability_token
          target_type2 = 0
        when 16 # Déguisement / Color Change (ab)
          if target.ability_token == nil
            target.ability_token = 1
          end
          target_type1 = target.ability_token
          target_type2 = 0
        when 63 # Marvel Scale / Ecaille Spe (ab)
          if target.status != 0 and user_skill.physical
            dfe *= 1.5
          end
        end
      end

      # --------- --------------- ---------- ---------------
      #        Dommages infligés et calculs coefficients
      # --------- --------------- ---------- ---------------
      pre_damage = (((level*2/5.0+2)*base_damage*atk/dfe)/50)
      multiplier = 1

      # Effets de la météo
      # Airlock / Cloud Nine (ab)
      if not([13, 77].include?(user.ability) or [13, 77].include?(target.ability) and
          not (user.effect_list.include?(0xEF) or user.effect_list.include?(0xF7)) and
          not (target.effect_list.include?(0xEF) or target.effect_list.include?(0xF7)))
        if ($battle_var.sunny? and skill_type == 2) or ($battle_var.rain? and skill_type == 3)
          # Ensoleillé + Feu ou Pluie + Eau
          multiplier *= 1.5
        end
        if ($battle_var.sunny? and skill_type == 3) or ($battle_var.rain? and skill_type == 2)
          # Ensoleillé + Eau ou Pluie + Feu
          multiplier *= 0.5
        end
        # Météo - Lance-Soleil / Solarbeam en cas de mauvais temps
        if user_skill.effect == 0x97 and [1, 3, 4].include?(weather)
          multiplier *= 0.5
        end
      end

      # Conversion / Adaptation
      if user.effect_list.include?(0x1E)
        index = user.effect_list.index(0x1E)
        user_type1 = user.effect[index][2]
        user_type2 = 0
      end

      # Forecast / Meteo (ab) // Déguisement / Color Change (ab)
      if (user.ability == 59 or user.ability == 16) and not (user.effect_list.include?(0xEF) or user.effect_list.include?(0xF7))
        user_type1 = user.ability_token
        user_type2 = 0
      end

      # Bonus même type (STAB)
      if skill_type == user_type1 or skill_type == user_type2
        multiplier *= 1.5
      end

      # Weather Ball / Ball'Meteo
      if user_skill.effect == 0xCB
        case weather
        when 1 # Pluie
          skill_type = 3 # Eau
        when 2 # Sunny
          skill_type = 2 # Feu
        when 3 # Tempete Sable
          skill_type = 13 # Roche
        when 4 # Hail
          skill_type = 6 # Glace
        end
      end

      # Complément statut
      # Brulure // Guts / Cran (ab) // Facade
      if user.status == 3 and user_skill.physical and not(user.ability == 62 and
          not (user.effect_list.include?(0xEF) or user.effect_list.include?(0xF7))) and
          user_skill.effect != 0xA9
        multiplier *= 0.5
      end

      # ------------------ ----------
      #  Programmation des attaques
      # ------------------ -----------
      # Protections et malus adverses
      for effect in target.effect_list
        case effect
        when 0x23 # Mur Lumière / Light Screen
          if user_skill.special and not(critical_hit)
            multiplier *= 0.5
          end
        when 0x41 # Protection / Reflect
          if user_skill.physical and not(critical_hit)
            multiplier *= 0.5
          end
        when 0xAE # Charge / Chargeur
          if skill_type == 4
            multiplier *= 2
          end
        when 0xC9 # Mud Sport / Lance-Boue
          if skill_type == 4
            multiplier *= 0.5
          end
        when 0xD2 # Water Sport / Tourniquet
          if skill_type == 2
            multiplier *= 0.5
          end
        when 0x6C # Minimize / Lilliput
          if user_skill.effect == 0x96
            multiplier *= 2
          end
        when 0x71 # Clairvoyance / Foresight
          if [1, 7].include?(skill_type) and [target_type1, target_type2].include?(14)
            skill_type = 0
          end
        end
      end

      # Bonus efficacité du type // Struggle / Lutte + Gravité
      rate = element_rate(target_type1, target_type2, skill_type, user_skill.effect, target.effect_list)
      if user_skill.id != 165
        multiplier *= rate/100.0
      end
      # Etude efficacité
      if rate > 100.0 # Super efficace
        efficiency = 1
      elsif rate < 100.0 and rate > 0 # Pas très efficace
        efficiency = -1
      elsif rate == 0 # Inefficace
        efficiency = -2
      elsif rate == 100.0 # Normal
        efficiency = 0
      end

      # Propriétés attaque
      case user_skill.effect
      when 0xA1 # Relache / Stockage // Spit up / Stockpile
        if user.effect_list.include?(0xA0)
          index = user.effect_list.index(0xA0)
          multiplier *= user.effect[index][2]
          damage = pre_damage * multiplier
          return [Integer(damage), false, efficiency]
        end
      when 0xA9 # Facade
        if [1,2,3].include?(user.status)
          multiplier *= 2
        end
      when 0xAB # Smelling Salt / Stimulant
        if target.status == 2
          multiplier *= 2
        end
      end

      # Armurbaston / Battle Armor (ab) // Coque armure / Shell Armor (ab)
      if (target.ability == 4 or target.ability == 75) and not (target.effect_list.include?(0xEF) or target.effect_list.include?(0xF7))
        critical_hit = false
      end

      # Calcul IA
      if shortcut
        return base_damage * multiplier
      end

      # Damage weight
      multiplier *= (100 - rand(15)) / 100.0
      if critical_hit
        multiplier *= 2
      end

      # Minimum dommage
      damage = pre_damage * multiplier
      if damage < 1 and damage > 0
        damage = 1
      end

      if int_only
        return Integer(damage)
      else
        return [Integer(damage), critical_hit, efficiency, data]
      end
    end


    #------------------------------------------------
    #           Calcul de précision
    #------------------------------------------------
    def accuracy_check(user_skill, user, target) #actor: user
      n = user_skill.accuracy

      # ------------- ------------------ --------------------
      #             Attaques self-cible, buff
      # ------------- ------------------- -------------------
      if user == target
        return n = 100
      end

      # ------------- ------------------ --------------------
      #                Capacités spéciales
      # ------------- ------------------- -------------------
      unless target.effect_list.include?(0xEF) or target.effect_list.include?(0xF7) # Suc Digestif / Soucigraine
        case target.ability
        when 8 # Voile Sable / Sand Veil (ab)
          if $battle_var.sandstorm?
            n *= 0.8
          end
        end
      end

      unless user.effect_list.include?(0xEF) or user.effect_list.include?(0xF7) # Suc Digestif / Soucigraine
        case user.ability
        when 14 # Compoundeyes / Oeil Composé (ab)
          n *= 1.3
        when 55 # Hustle / Agitation (ab)
          if user_skill.physical
            n *= 0.8
          end
        end
      end

      for effect in user.effect_list
        case effect
        when 0x5E # Verrouillage / Lock-on
          return n = 100
        end
      end

      # ------------- ------------------ --------------------
      #             Attaques intouchables
      # ------------- ------------------- -------------------
      for effect in target.effect_list
        case effect
        when 0x9B0 # Tunnel
          if not([0x7E, 0x93, 0x26].include?(user_skill.effect) and user_skill.type == 9)
            return n = 0
          end
        when 0x9B1 # Vol / Flying
          if not([0xCF, 0x92, 0x95, 0x98].include?(user_skill.effect) or user_skill.id == 18)
            return n = 0
          end
        when 0x9B2 # Bounce / Rebond
          if not([0xCF, 0x92, 0x95, 0x98].include?(user_skill.effect) or user_skill.id == 18)
            return n = 0
          end
        when 0x9B1 # Dive / Plongée
          if not([57, 250].include?(user_skill.id))
            return n = 0
          end
        end
      end


      case user_skill.effect
      # ------------- ------------------ --------------------
      # Attaques réussites sous certaines conditions
      # ------------- ------------------- -------------------
      when 0x26 # OHKO
        if target.ability == 5 and not (target.effect_list.include?(0xEF) or target.effect_list.include?(0xF7)) # Fermeté / Sturdy (ab)
          return n = 0
        end
        if user.level > target.level
          return n += (user.level - target.level)
        else
          return n = 0
        end
      when 0x08 # Dream eater / Devorêve
        if not(target.asleep?)
          return n = 0
        end
      when 0x1C # Whirlwind, Roar
        number = rand(256)
        if number*(user.level + target.level)/256 + 1 == target.level/4
          return n = 0
        end
      when 0x98 # Thunder
        if $battle_var.sunny? # Soleil
          return n = 50
        end
      end

      # ------------- ------------------ --------------------
      #             Attaques à précision nulle
      # ------------- ------------------- -------------------
      if n == 0
        return n = 100
      end

      return n
    end

    # ----------- -------------- ------------- --------
    # Fonction détermination des coups critiques
    # ----------- -------------- ------------- --------
    def critical_decision(target, critical_special = 0)
      rate = 0
      rate += critical_special
      if target.effect_list.include?(0xF0) # Air Veinard
        return false
      end
      case rate
      when 0
        critical_chance = rand(15)
      when 1
        critical_chance = rand(7)
      when 2
        critical_chance = rand(3)
      when 3
        critical_chance = rand(2)
      end
      if rate >= 4
        critical_chance = rand(1)
      end
      if critical_chance == 0
        return true
      else
        return false
      end
    end

    #------------------------------------------------------------
    # Taux de résultat aux dégâts
    #------------------------------------------------------------
    def element_rate(target_type1, target_type2, skill_type, skill_effect, target_effect)
      result = 100.0
      result1 = result
      if $data_table_type[target_type1][skill_type] != nil
        result = result * $data_table_type[target_type1][skill_type]
        result1 = result
        # Gravité, Atterissage et Oeil Miracle
        if (skill_type == 9 and target_type1 == 10 and (target_effect.include?(0xD6) or target_effect.include?(0xD7))) or (skill_type == 11 and target_type1 == 16 and target_effect.include?(0xD8))
          result = 100.0
          result1 = result
        end
      else
        print("Erreur : vérifiez la table des types, case #{target_type1} #{skill_type}")
      end
      if $data_table_type[target_type2][skill_type] != nil
        result = result * $data_table_type[target_type2][skill_type]
        # Gravité, Atterissage et Oeil Miracle
        if (skill_type == 9 and target_type2 == 10 and (target_effect.include?(0xD6) or target_effect.include?(0xD7))) or (skill_type == 11 and target_type2 == 16 and target_effect.include?(0xD8))
          result = result1
        end
      else
        print("Erreur : vérifiez la table des types, case #{target_type2} #{skill_type}")
      end
      if skill_effect == 0xE3 then return 100.0 end
      return result
    end

    #------------------------------------------------------------
    #    Conséquences du switch sur le Pokémon
    #------------------------------------------------------------
    def switch_effect(actor, enemy)
      # Reset de statut : Toxic
      if actor.toxic?
        actor.reset_toxic_count
      end
      # Reset de staut : Confuse
      if actor.confused?
        actor.cure_state
      end

      # Reset capacité spéciale
      actor.ability_active = false
      actor.ability_token = nil

      unless actor.effect_list.include?(0xEF) or actor.effect_list.include?(0xF7)
        case actor.ability
        when 30 # Natural cure / Medic Nature (ab)
          actor.cure
        end
      end

      # Effets supprimés lors du switch
      for effect in actor.effect
        case effect[0]
        when 0x1A # Bide / Patience
          actor.effect.delete(effect)
        when 0x1B # Mania / Thrash
          actor.effect.delete(effect)
        when 0x1E # Adaptation / Conversion
          actor.effect.delete(effect)
        when 0x2A # Multi turn Attack
          actor.effect.delete(effect)
        when 0x2F # Focus Energy / Puissance
          actor.effect.delete(effect)
        when 0x39 # Morphing / Transform
          index = actor.effect_list.index(0x39)
          actor.transform_effect( actor.effect[index][2] , true )
          actor.effect.delete(effect)
        when 0x51 # Rage / Frénésie
          actor.change_atk(-effect[2])
          actor.effect.delete(effect)
        when 0x52 # Copie / Mimic
          skill_index = actor.skills_set.index(effect[2][1])
          actor.skills_set[skill_index] = effect[2][0]
          actor.effect.delete(effect)
        when 0x54 # Vampigraine
          actor.effect.delete(effect)
        when 0x56 # Entrave / Disable
          index = effect[0][2]
          actor.skills_set[index].enable
          actor.effect.delete(effect)
        when 0x5A # Encore
          actor.effect.delete(effect)
        when 0x72 # Perish Song / Requiem
          actor.effect.delete(effect)
        when 0x6C # Minimize / Lilliput
          actor.effect.delete(effect)
        when 0x6D # Curse
          actor.effect.delete(effect)
        when 0x78 # Attraction
          actor.effect.delete(effect)
        when 0x9C # Boul'Armure / Defense Curl
          actor.effect.delete(effect)
        when 0x9F # Uproar / Brouhaha
          actor.effect.delete(effect)
        when 0xA5 # Torment / Tourment
          index = actor.effect_list.index(0xA5)
          skill_index = actor.effect[index][2]
          actor.skills_set[skill_index].enable
          actor.effect.delete(effect)
        when 0xAE # Charge / Chargeur
          actor.effect.delete(effect)
        when 0xAF # Provoc / Taunt
          for skill in actor.skills_set
            if skill.power == 0 and not(skill.enabled?)
              skill.enable
            end
          end
          actor.effect.delete(effect)
        when 0xC9 # Mud Sport
          actor.effect.delete(effect)
        when 0xD2 # Water Sport
          actor.effect.delete(effect)
        when 0xD7 # Gravité
          actor.effect.delete(effect)
        when 0xD8 # Oeil Miracle
          actor.effect.delete(effect)
        when 0xE8 # Embargo
          actor.effect.delete(effect)
        when 0xEC # Anti-Soin
          actor.effect.delete(effect)
        when 0xEE # Astuce Force
          actor.effect.delete(effect)
        when 0xEF # Suc Digestif
          actor.effect.delete(effect)
        when 0xF7 # Soucigraine
          actor.effect.delete(effect)
        when 0xFB # Anneau Hydro
          actor.effect.delete(effect)
        when 0xFC # Vol Magnétik
          actor.effect.delete(effect)
        end
      end

      for effect in enemy.effect
        case effect[0]
        when 0x6A # Regard noir / Mean Look
          enemy.effect.delete(effect)
        when 0x71 # Clairvoyance / Foresight
          enemy.effect.delete(effect)
        when 0x78 # Attraction
          enemy.effect.delete(effect)
        when 0x54 # Vampigraine
          enemy.effect.delete(effect)
        end
      end
    end

  end
end