#==============================================================================
# ■ Pokemon_Battle_Wild
# Pokemon Script Project - Krosk
# 20/07/07
#-----------------------------------------------------------------------------
# Scène à ne pas modifier de préférence
#-----------------------------------------------------------------------------
# Système de Combat - Pokémon Sauvage
#-----------------------------------------------------------------------------

#-----------------------------------------------------------------------------
# 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
#-----------------------------------------------------------------------------

#-----------------------------------------------------------------------------
# $battle_var.action_id
#   0 : Phase de Sélection
#   1 : Sélection Item
#   2 : Switch Pokémon
#   4 : Switch Fin de Tour
#-----------------------------------------------------------------------------

#-----------------------------------------------------------------------------
# Ordre de déroulement du combat (update)
#
#
#-----------------------------------------------------------------------------

module POKEMON_S
  #------------------------------------------------------------ 
  # Pokemon_Battle_Wild
  #   scene
  #------------------------------------------------------------ 
  class Pokemon_Battle_Wild < Pokemon_Battle_Core
    attr_accessor :z_level
    attr_accessor :actor_status
    attr_accessor :actor
    #------------------------------------------------------------ 
    # Fonction d'initialisation
    # Appel: $scene = POKEMON_S::Pokemon_Battle_Wild.new(
    #           party, pokemon, ia)
    #     party: $pokemon_party (classe Pokemon_Party)
    #     pokemon: class Pokemon
    #     ia: Fausse AI
    #------------------------------------------------------------
    def initialize(party, pokemon, ia = false, lose_able = false)
      @z_level = 100
      @ia = ia
      @lose = lose_able
      $sauvage = true
     
      $battle_var.reset
     
      # Assignations données des Pokémons
      @enemy = pokemon
      @enemy.statistic_refresh
      @enemy.hp = @enemy.max_hp
      ###@enemy = $pokemon_party.actors[0].clone
      if not(@enemy.given_name.include?("sauvage"))
        @enemy.given_name += " sauvage"
      end
      $battle_var.enemy_party.actors[0] = @enemy
      @party = party
     
      # Mise à jour Pokedex: Pokémon vu
      $data_pokedex[@enemy.id][0] = true
     
      # Génération ordre de combat
      @battle_order = Array.new(@party.size)
      @battle_order.fill {|i| i}
     
      # Désignation 1er Pokémon au combat
      # @actor désigne le (class) Pokémon
      actor_index = 0
      @actor = @party.actors[actor_index]
      if @actor == nil
        print("Attention, vous n'avez pas de Pokémon dans votre équipe! Réglez ce bug.")
      end
      while @actor.dead?
        actor_index += 1
        @actor = @party.actors[actor_index]
      end
   
     
      # Correction ordre combat (Pokémon vivant en premier)
      @battle_order = switch(@battle_order, 0, actor_index)
     
      # Remise à zéro résultat
      $battle_var.result_flee = false
      $battle_var.result_flee_enemy = false
      $battle_var.result_win = false
      $battle_var.result_defeat = false
     
      # Initialisation des variables de combat
      @phase = 0
      # 0 Non décidé, 1 Attaque, 2 Switch, 3 Item, 4 Fuite
      @actor_action = 0
      @enemy_action = 0
     
      @start_actor_battler = Player.battler # $trainer_battler
      @start_enemy_battler = @enemy.battler_face
     
      $battle_var.have_fought.push(@actor.party_index)
      $battle_var.battle_order = @battle_order
      $battle_var.in_battle = true
     
      @actor.reset_stat_stage
      @enemy.reset_stat_stage
      @actor.skill_effect_reset
      @enemy.skill_effect_reset
      @actor_skill = nil
      @enemy_skill = nil
      @actor.ability_active = false
      @enemy.ability_active = false
      @item_id = 0   # item utilisé
    end
 
       
    #------------------------------------------------------------ 
    # Animations pré-combat
    #------------------------------------------------------------ 
    def pre_battle_transition
      # Jingle et BGM
      $game_system.bgm_play($game_system.battle_bgm)
      Audio.me_play("Audio/ME/battle_jingle.mid")
      Graphics.freeze
     
      # Sélection transition
      s = (rand(BATTLE_TRANS)+1).to_s
      @background.bitmap = RPG::Cache.picture("black.png")
      Graphics.transition(100, "Graphics/Transitions/battle"+ s +".png")
      Audio.me_stop
     
      # Dessin
      Graphics.freeze
      @background.bitmap = RPG::Cache.battleback(@battleback_name)
      @message_background.bitmap = $game_variables[5000]["menu_dp"] ? RPG::Cache.battleback("dummy_" + $game_map.battleback_name  + ".png") : RPG::Cache.battleback(BATTLE_MSG)
      @enemy_sprite.bitmap = RPG::Cache.battler(@start_enemy_battler, 0)
      ###@enemy_sprite.bitmap = RPG::Cache.battler("ENEMY.png", 0)
      @enemy_sprite.ox = @enemy_sprite.bitmap.width / 2
      @enemy_sprite.oy = @enemy_sprite.bitmap.height / 2
      @enemy_sprite.x -= 782
      @enemy_sprite.color = Color.new(60,60,60,128)
      @enemy_ground.bitmap = RPG::Cache.battleback(@ground_name)
      @enemy_ground.ox = @enemy_ground.bitmap.width / 2
      @enemy_ground.oy = @enemy_ground.bitmap.height / 2
      @enemy_ground.zoom_x = @enemy_ground.zoom_y = 2.0/3
      @enemy_ground.x -= 782
      @actor_ground.bitmap = RPG::Cache.battleback(@ground_name)
      @actor_ground.ox = @actor_ground.bitmap.width / 2
      @actor_ground.oy = @actor_ground.bitmap.height
      @actor_ground.x += 782
      @actor_sprite.bitmap = RPG::Cache.battler(@start_actor_battler, 0)
      @actor_sprite.ox = @actor_sprite.bitmap.width / 2
      @actor_sprite.oy = @actor_sprite.bitmap.height
      @actor_sprite.x += 782
      Graphics.transition(50, "Graphics/Transitions/battle0.png")
    end
   
    def pre_battle_animation
      # Glissement des sprites
      loop do
        @enemy_sprite.x += 17
        @enemy_ground.x += 17
        @actor_sprite.x -= 17
        @actor_ground.x -= 17
        Graphics.update
        if @enemy_sprite.x == 464
          until @enemy_sprite.color.alpha <= 0
            @enemy_sprite.color.alpha -= 20
            Graphics.update
          end
          break
        end
      end
     
      # Texte
      draw_text("Un " + @enemy.given_name, "apparait!")
      if FileTest.exist?(@enemy.cry)
        Audio.se_play(@enemy.cry)
      end
     
      # Arrivé du panel de l'adversaire
      @enemy_status.x -= 300
      @enemy_status.visible = true
      if @enemy.shiny
        animation = $data_animations[496]
        @enemy_sprite.animation(animation, true)
      end
      loop do
        @enemy_sprite.x -= 3*(-1)**(@enemy_sprite.x)
        @enemy_status.x += 20
        @enemy_sprite.update
        Graphics.update
        if @enemy_status.x == 23
          until not(@enemy_sprite.effect?)
            @enemy_sprite.update
            Graphics.update
          end
          @enemy_sprite.x = 464
          break
        end
      end
     
      # Attente appui de touche
      loop do
        Graphics.update
        Input.update
        if Input.trigger?(Input::C)
          $game_system.se_play($data_system.decision_se)
          break
        end
      end
     
      # Dégagement du sprite dresseur
      loop do
        @actor_sprite.x -= 20
        Graphics.update
        if @actor_sprite.x <= -200
          @actor_sprite.bitmap = RPG::Cache.battler(@actor.battler_back, 0)
          ###@actor_sprite.bitmap = RPG::Cache.battler("ACTOR.png", 0)
          break
        end
      end
     
      # Envoi du pokémon (animation)
      launch_pokemon
     
      @text_window.contents.clear
      Graphics.update
    end
   
    #------------------------------------------------------------ 
    # Déroulement
    #------------------------------------------------------------
    def enemy_skill_decision
      action = true
      # ------- ---------- --------- --------
      #    Saut de phase de sélection (ennemi)
      #   action = false  : saut
      #   action = true   : pas de saut
      # ------- ---------- --------- --------
      action = phase_jump(true)
     
      @enemy_action = 1
     
      # Décision skill ennemi
      if not(@actor.dead?) and action
        list = []
        for i in 0..@enemy.skills_set.size - 1
          list.push(i)
        end
        list.shuffle!
        # Skill sans PP // Lutte
        @enemy_skill = Skill.new(165)
        # ----------
        for i in list
          if @enemy.skills_set.usable?
            @enemy_skill = @enemy.skills_set
          end
        end
      end
     
      if @ia and not(@actor.dead?) and action
        # Skill sans PP // Lutte
        @enemy_skill = Skill.new(165)
       
        rate_list = {}
        i = 0
        for skill in @enemy.skills_set
          if skill.usable?
            rate_list = ia_rate_calculation(skill, @enemy, @actor)
          else
            rate_list = 0
          end
          i += 1
        end
       
        # Tri dans l'ordre decroissant de valeur
        sorted_list = rate_list.sort {|a,b| b[1]<=a[1]}
       
        #for element in sorted_list
        #  print(@enemy.skills_set[element[0]].name)
        #  print(element[1])
        #end
       
        # Decision prioritaire: max dégat ou soin
        # Valeur seuil: 200
        # si une attaque/défense dépasse ce seuil, il est choisi
        if sorted_list[0][1] > 200
          @enemy_skill = @enemy.skills_set[sorted_list[0][0]]
        else
          # Decision par pallier
          i = rand(100)
          # Taux de decision
          taux = [100, 25, 5, 0]
          for a in 0..3
            if i <= taux[a] and sorted_list[a] != nil and sorted_list[a][1] != 0
              @enemy_skill = @enemy.skills_set[sorted_list[a][0]]
            end
          end
        end
      end
     
      if not(action) # Reprise du skill précédent
        @enemy_skill = $battle_var.enemy_last_used
      end
    end
   
    #------------------------------------------------------------ 
    # Rounds
    #------------------------------------------------------------               
    def end_battle_check
      @actor_status.refresh
      @enemy_status.refresh
      if @enemy.dead? and not(@party.dead?)
        end_battle_victory
      elsif @actor.dead?
        if @party.dead?
          end_battle_defeat
        else
          draw_text("Voulez-vous appeler", "un autre Pokémon?")
          if draw_choice
            $battle_var.window_index = @action_window.index
            scene = POKEMON_S::Pokemon_Party_Menu.new(0)
            scene.main
            return_data = scene.return_data
            # Switch de Pokémon
            if $battle_var.action_id == 4 or $battle_var.action_id == 6
              @switch_id = return_data
              actor_pokemon_switch
            end
          elsif run_able?(@actor, @enemy)
            run
          else
            fail_flee
            $battle_var.window_index = @action_window.index
            scene = POKEMON_S::Pokemon_Party_Menu.new(0)
            scene.main
            return_data = scene.return_data
            # Switch de Pokémon
            if $battle_var.action_id == 4 or $battle_var.action_id == 6
              @switch_id = return_data
              actor_pokemon_switch
            end
          end
        end
      end
    end
   
    #------------------------------------------------------------ 
    # Items
    #------------------------------------------------------------    
    def actor_item_use # items à utiliser
      # Item déjà utilisé ie remplacé par 0
      if @item_id == 0
        return
      end
      if Item.data(@item_id)["flee"]
        end_battle_flee
        return
      end
      if Item.data(@item_id)["ball"]
        ball_data = Item.data(@item_id)["ball"]
        if catch_pokemon(ball_data)
          @enemy.given_name = @enemy.name
          @enemy.ball_data = ball_data
          # Changement de surnom
          string1 = "Voulez-vous changer le"
          string2 = "surnom de " + @enemy.given_name + "?"
          draw_text(string1, string2)
          if draw_choice
            draw_text("")
            scene = POKEMON_S::Pokemon_Name.new(@enemy, @z_level + 50)
            scene.main
          end
          # Intégration au PC
          if $pokemon_party.size < 6
            $pokemon_party.add(@enemy)
          else
            $pokemon_party.store_captured(@enemy)
            string1 = @enemy.given_name
            string2 = "est envoyé au PC."
            draw_text(string1, string2)
            wait(40)
          end
          $battle_var.result_win = true
          end_battle
        end
      end
    end

   

    #------------------------------------------------------------ 
    # Lancer de pokéball
    #------------------------------------------------------------        
    def catch_pokemon(ball_data)
      # Initialisation des données
      ball_name = ball_data[0]
      ball_rate = ball_data[1]
      ball_sprite = ball_data[2]
      ball_open_sprite = ball_data[3]
      ball_color = ball_data[4]
      if @enemy.asleep? or @enemy.frozen?
        status_multiplier = 2
      elsif @enemy.burn? or @enemy.paralyzed? or
          @enemy.poisoned? or @enemy.toxic?
        status_multiplier = 1.5
      else
        status_multiplier = 1
      end
     
      if ball_rate.type == Array
        case ball_rate[0]
        when "type"
          if ball_rate[1].include?(@enemy.type1)
            ball_rate = ball_rate[2]
          elsif ball_rate[1].include?(@enemy.type2)
            ball_rate = ball_rate[2]
          elsif ball_rate[3] != nil
            ball_rate = ball_rate[3]
          else
            ball_rate = 1
          end
        when "id"
          if ball_rate[1].include?(@enemy.id)
            ball_rate = ball_rate[2]
          elsif ball_rate[3] != nil
            ball_rate = ball_rate[3]
          else
            ball_rate = 1
          end
        when "level"
          max = 99
          if ball_rate[2] != nil
           
            max = ball_rate[2]
          end
          ball_rate = eval( sprintf( ball_rate[1], @enemy.level ) )
          if ball_rate <= 1
            ball_rate = 1
          end
          if ball_rate >= max
            ball_rate = max
          end
        when "time"
          max = 99
          if ball_rate[2] != nil
            max = ball_rate[2]
          end
          ball_rate = eval( sprintf( ball_rate[1], $battle_var.round ) )
          if ball_rate <= 1
            ball_rate = 1
          end
          if ball_rate >= max
            ball_rate = max
          end
        when "vol"
          if ball_rate[2] != nil
            ball_rate = ball_rate[2]
          else
            ball_rate = 1
          end
        when "genre"
          if ball_rate[1][@actor.gender] != nil
            ball_rate = eval(sprintf(ball_rate[1][@actor.gender], @actor_gender))
          else
            if ball_rate[1][0] != nil
              ball_rate = eval(sprintf(ball_rate[1][0], 0))
            else
              ball_rate = 1
            end
          end
        when "taille"
          height = Pokemon_Info.height(@enemy.id).split(' ')[0].to_i
          ball_rate = eval(sprintf(ball_rate[1], height))
          if ball_rate == nil or ball_rate < 1
            ball_rate = 1
          end
        when "poids"
          weight = Pokemon_Info.weight(@enemy.id).split(' ')[0].to_i
          ball_rate = eval(sprintf(ball_rate[1], weight))
          if ball_rate == nil or ball_rate < 1
            ball_rate = 1
          end
        when "infos"
          ball_rate = eval(ball_rate[2].gsub(/%([0-9]+)d/) { ball_rate[1][$1.to_i - 1] })
        when "formule"
          ball_rate = eval(ball_rate[1])
          ball_rate = 1 if ball_rate.type != Integer
        else
          ball_rate = 1
        end
      end
     
      multiplier = @enemy.rareness * (ball_rate)
      maxhp = @enemy.maxhp_basis
      hp = @enemy.hp
      catch_rate = Integer((((maxhp * 3 - hp * 2)*multiplier).to_f/(maxhp*3).to_f)*status_multiplier)
      catch_value = Integer(1048560 / (Math.sqrt(Math.sqrt(16711680/catch_rate.to_f))))
      list = [rand(65536), rand(65536), rand(65536), rand(65536)]
      j = 4 # nombre de fois que la balle oscille
      for i in list
        j -= i > catch_value ? 1 : 0
      end
     
      # Procédure / Animation
      # Lancer
      draw_text(Player.name + " utilise", ball_name + "!")
      @ball_sprite = Sprite.new
      @ball_sprite.bitmap = RPG::Cache.picture(ball_sprite)
      @ball_sprite.x = -25
      @ball_sprite.y = 270
      @ball_sprite.z = @z_level + 16
      t = 0.0
      pi = Math:I
      loop do
        t += 16
        @ball_sprite.y = (270.0 - 230.0 * Math.sin(2 * pi / 3.0 * t / 445.0)).to_i
        @ball_sprite.x = -15 + t
        Graphics.update
        if @ball_sprite.x >= 445
          @ball_sprite.bitmap = RPG::Cache.picture(ball_open_sprite)
          break
        end
      end
     
      count = j
     
      # "Aspiration"
      @enemy_sprite.color = ball_color
      @enemy_sprite.color.alpha = 0
      @ball_sprite.z -= 2
      until @enemy_sprite.color.alpha >= 255
        @flash_sprite.opacity += 50
        @enemy_sprite.color.alpha += 50
        Graphics.update
      end
      Audio.se_play("Audio/SE/Pokeopen.wav")
      loop do
        @enemy_sprite.zoom_x -= 0.1
        @enemy_sprite.zoom_y -= 0.1
        @enemy_sprite.opacity -= 25
        @flash_sprite.opacity -= 25
        Graphics.update
        if @enemy_sprite.zoom_x <= 0.1
          @flash_sprite.opacity = 0
          @enemy_sprite.opacity = 0
          break
        end
      end
      @ball_sprite.bitmap = RPG::Cache.picture(ball_sprite)
     
      # Oscillement
      t = 0
      r = 0
      loop do
        t += 1
        @ball_sprite.y = 81 + 50*(1-Math.exp(-t/20.0)*(Math.cos(t*2*pi/30.0)).abs)
        if @ball_sprite.y >= 81+45 and r < 6
          r += 1
          Audio.se_play("Audio/SE/Pokerebond.wav")
        end
        Graphics.update
        if t >= 60
          break
        end
      end
     
      while count > 0
        count -= 1
        t = 0
        Audio.se_play("Audio/SE/Pokemove.wav")
        loop do
          t += 4
          @ball_sprite.angle = 40*Math.sin(2*pi*t/100.0)
          @ball_sprite.x = 449 - 12*Math.sin(2*pi*t/100.0)
          @ball_sprite.y = 131 + 12*Math.sin(2*pi*t/100.0)
          Graphics.update
          if t == 100
            @ball_sprite.angle = 0
            break
          end
        end
      end
     
      if j != 4
        # Echappé
        @ball_sprite.bitmap = RPG::Cache.picture(ball_open_sprite)
        @ball_sprite.z -= 1
        Audio.se_stop
        Audio.se_play("Audio/SE/Pokeopenbreak.wav")
        @enemy_sprite.oy = @enemy_sprite.bitmap.height
        @enemy_sprite.y += @enemy_sprite.bitmap.height / 2 + 34
        loop do
          @enemy_sprite.opacity += 25
          @enemy_sprite.zoom_x += 0.1
          @enemy_sprite.zoom_y += 0.1
          @ball_sprite.opacity -= 25
          @flash_sprite.opacity += 25
          Graphics.update
          if @enemy_sprite.zoom_x >= 1
            @enemy_sprite.oy = @enemy_sprite.bitmap.height / 2
            @enemy_sprite.y -= @enemy_sprite.bitmap.height / 2 + 34
            Graphics.update
            @ball_sprite.dispose
            break
          end
        end
        until @enemy_sprite.color.alpha <= 0
          @enemy_sprite.color.alpha -= 25
          @flash_sprite.opacity -= 25
          Graphics.update
        end
        @enemy_sprite.color.alpha = 0
        @enemy_sprite.opacity = 255
        @flash_sprite.opacity = 0
        Graphics.update
       
        string1 = j == 3 ? "Mince!" : j == 2 ? "Aaaah!" : j == 1 ? "Raah!" : "Oh non!"
        string2 = j == 3 ? "Ca y était presque!" : j == 2 ? "Presque!" : j == 1 ? "Ca y était presque!" : "Le POKéMON s'est libéré!"
        draw_text(string1, string2)
        wait(40)
      else
        # Attrapé
        Audio.me_play("Audio/ME/PkmRS-Caught.mid")
        @enemy_caught = true
        draw_text("Et hop! " + @enemy.given_name , "est attrapé!")
        wait(50)
        wait_hit
       
        if not($data_pokedex[@enemy.id][1])
          draw_text(@enemy.name + " est ajouté", "au pokédex.")
          wait(50)
          wait_hit
          $data_pokedex[@enemy.id][0] = true
          $data_pokedex[@enemy.id][1] = true
          scene = POKEMON_S::Pokemon_Detail.new(@enemy.id, false)
          scene.main
          wait_hit
          wait(40)
        end
       
        until @ball_sprite.opacity <= 0
          @ball_sprite.opacity -= 25
          Graphics.update
        end
        $pokemon_party.incr_nb_matchs
        for actor in $pokemon_party.actors
          if $battle_var.have_fought.include?(actor.party_index)
            actor.fight[0] += 1
            if actor.dead? and not(actor.vaudou)
              actor.vaudou = (actor.medaille == nil ? false : $data_medaille[actor.medaille][4])
              if actor.vaudou
                draw_text(actor.name + " subit la","malédiction !")
                wait(40)
                wait_hit
              end
            else
              actor.fight[1] += 1
            end
          end
        end
      end
      if j != 4
        return false
      elsif j == 4
        return true
      end
    end
   
   
   
    #------------------------------------------------------------ 
    # Fin de combat
    #------------------------------------------------------------     
    def end_battle_victory
      $pokemon_party.incr_nb_matchs
      for actor in $pokemon_party.actors
        if $battle_var.have_fought.include?(actor.party_index)
          actor.fight[0] += 1
          if actor.dead? and not(actor.vaudou)
            actor.vaudou = actor.medaille == nil ? false : $data_medaille[actor.medaille][4]
            if actor.vaudou
              draw_text(actor.name + " subit la","malédiction !")
              wait(40)
              wait_hit
            end
          else
            actor.fight[1] += 1
          end
        end
      end
      #Audio.bgm_fade(800)
      $battle_var.result_win = true
      @actor_status.z = @z_level + 15
     
      #$game_system.me_play($game_system.battle_end_me)
      Audio.me_play("Audio/ME/fainted_jingle.mid")
      Audio.bgm_play("Audio/BGM/PkmRS-Victory.mid")
     
      # Réduction du nombre de participants
      $battle_var.have_fought.uniq!
      for index in $battle_var.have_fought
        actor = $pokemon_party.actors[index]
        if actor.dead?
          $battle_var.have_fought.delete(index)
        end
      end
      number = $battle_var.have_fought.length
      @enemy.skill_effect_reset
      @enemy.reset_stat_stage
      evolve_checklist = []
      type = 1
     
      # PIECE RUNE/AMULET COIN
      money_rate = 1
      # EXP SHARE/MULTI EXP
      exp_share_number = 0
      for pokemon in $pokemon_party.actors
        if not(pokemon.dead?) and Item.data(pokemon.item_hold)["expshare"]
          exp_share_number += 1
        end
      end
     
      # Exp de bataille
      for actor in $pokemon_party.actors
        if actor.dead?
          next
        end
       
        amount = nil
        if $battle_var.have_fought.include?(actor.party_index)
          amount = actor.exp_calculation(@enemy.battle_list, @enemy.level, number, type, exp_share_number)
          # Tag objet
          if Item.data(actor.item_hold)["amuletcoin"]
            money_rate = 2
          end
        end
        if Item.data(actor.item_hold)["expshare"] and
            not($battle_var.have_fought.include?(actor.party_index)) and not(actor.dead?)
          amount = actor.exp_calculation(@enemy.battle_list, @enemy.level, number, type, exp_share_number, 0)
        end
        if amount != nil
          actor.skill_effect_reset
          actor.reset_stat_stage
          actor.add_bonus(@enemy.battle_list)
          draw_text(actor.given_name + " a gagné", amount.to_s + " points d'expérience!")
          Graphics.update
          wait_hit
       
          for i in 1..amount
            actor.add_exp_battle(1)
            if actor.level_check
              actor.level_up(self)
              evolve_checklist.push(actor)
            end
            if actor == @actor
              if @actor.exp_list[@actor.level+1] != nil and @actor.level < MAX_LEVEL
                divide = (@actor.exp_list[@actor.level+1]-@actor.exp_list[@actor.level])/192
                if divide == 0
                  divide = 1
                end
                if (@actor.exp - @actor.exp_list[@actor.level])%divide == 0
                  @actor_status.exp_refresh
                  Graphics.update
                end
              end
            end
          end
        end
      end
     
     
      @actor_status.refresh
      Graphics.update
      if $battle_var.money > 0
        $battle_var.money *= money_rate
        draw_text(Player.name + " gagne " + ($battle_var.money).to_s + "$!")
        $pokemon_party.add_money($battle_var.money)
        wait(40)
      end
     
      wait(30)
      $game_system.bgm_play($game_temp.map_bgm)
      for actor in evolve_checklist
        info = actor.evolve_check
        if info != false
          scene = POKEMON_S::Pokemon_Evolve.new(actor, info, @z_level + 200)
          scene.main
        end
      end
      end_battle
    end
   
   
  end
 
end

---------- Erreur de script : Interpreter Bis ----------
----- Type
NoMethodError

----- Message
- ARGS - []
Section110:1018:in `appel_menu_equipe'undefined method `tourne' for nil:NilClass

----- Position dans Interpreter Bis
Ligne 452

----- Backtrace
Script : Interpreter Bis | Ligne : 452 | Méthode : in `command_355'
Script : Loading | Ligne : 1 | Méthode : in `command_355'
Script : Interpreter 2 | Ligne : 215 | Méthode : in `eval'
Script : Interpreter Bis | Ligne : 452 | Méthode : in `command_355'
Script : Interpreter 2 | Ligne : 215 | Méthode : in `execute_command'
Script : Interpreter 1 | Ligne : 199 | Méthode : in `update'
Script : Interpreter 1 | Ligne : 113 | Méthode : in `loop'
Script : Interpreter 1 | Ligne : 204 | Méthode : in `update'
Script : Interpreter 1 | Ligne : 130 | Méthode : in `update'
Script : Interpreter 1 | Ligne : 113 | Méthode : in `loop'
Script : Interpreter 1 | Ligne : 204 | Méthode : in `update'
Script : Scene_Map | Ligne : 61 | Méthode : in `alias_update'
Script : Scene_Map | Ligne : 58 | Méthode : in `loop'
Script : Scene_Map | Ligne : 79 | Méthode : in `alias_update'
Script : MAPPANEL | Ligne : 90 | Méthode : in `old_update'
Script : TempsJourNuit | Ligne : 248 | Méthode : in `update_passminimap'
Script : Minimap | Ligne : 44 | Méthode : in `update'
Script : Scene_Map | Ligne : 25 | Méthode : in `old_main'
Script : Scene_Map | Ligne : 19 | Méthode : in `loop'
Script : Scene_Map | Ligne : 30 | Méthode : in `old_main'
Script : TempsJourNuit | Ligne : 237 | Méthode : in `main_passminimap'
Script : Minimap | Ligne : 31 | Méthode : in `main'
Script : Main | Ligne : 50

#==============================================================================
# ■ Interpreter
# Pokemon Script Project - Krosk
# 18/07/07
#-----------------------------------------------------------------------------
# Scène à modifier à loisir
#-----------------------------------------------------------------------------
# Fonctions du logiciel
#-----------------------------------------------------------------------------

class Interpreter
  #--------------------------------------------------------------------------
  # Fonction communes
  #     parameter : 1 ID、0 Equipe
  #--------------------------------------------------------------------------
  def iterate_actor(parameter)
    if parameter == 0
      for actor in $pokemon_party.actors
        yield actor
      end
    else
      actor = $pokemon_party.actors[$game_variables[4]]
      yield actor if actor != nil
    end
  end
 
  #--------------------------------------------------------------------------
  # Ajouter / Retirer monnaie
  #--------------------------------------------------------------------------
  def command_125
    value = operate_value(@parameters[0], @parameters[1], @parameters[2])
    $pokemon_party.add_money(value)
    return true
  end
 
  #--------------------------------------------------------------------------
  # Ajouter / Retirer objets
  #--------------------------------------------------------------------------
  def command_126
    value = operate_value(@parameters[1], @parameters[2], @parameters[3])
    $pokemon_party.add_item(@parameters[0], value)
    return true
  end
 
  #--------------------------------------------------------------------------
  # Modifier les PV
  #--------------------------------------------------------------------------
  def command_311
    value = operate_value(@parameters[1], @parameters[2], @parameters[3])
    iterate_actor(@parameters[0]) do |actor|
      if actor.hp > 0
        if @parameters[4] == false and actor.hp + value <= 0
          actor.hp = 1
        else
          actor.hp += value
        end
      end
    end
    $game_temp.gameover = $pokemon_party.dead?
    return true
  end
 
  #--------------------------------------------------------------------------
  # Infliger statut
  #--------------------------------------------------------------------------
  def command_313
    iterate_actor(@parameters[0]) do |actor|
      if @parameters[1] == 0
        if @parameters[2] == 9
          actor.hp = 0
        else
          actor.status = @parameters[2]
        end
      elsif actor.status == @parameters[2]
        actor.cure
      elsif actor.dead? and @parameters[2] == 9
        actor.hp = actor.max_hp
      end
    end
    return true
  end

  #--------------------------------------------------------------------------
  # Soigner complètement
  #-------------------------------------------------------------------------- 
  def command_314
    iterate_actor(@parameters[0]) do |actor|
      actor.refill
    end
    return true
  end
 
  #--------------------------------------------------------------------------
  # Ajouter de l'exp
  #--------------------------------------------------------------------------  
  def command_315
    # 操作する値を取得
    value = operate_value(@parameters[1], @parameters[2], @parameters[3])
    # イテレータで処理
    iterate_actor(@parameters[0]) do |actor|
      # アクターの EXP を変更
      actor.exp += value
      if actor.level_check
        actor.level_up
        if actor.evolve_check != false
          scenebis = Pokemon_Evolve.new(actor, actor.evolve_check)
          scenebis.main
          Graphics.transition
        end
      end
    end
    # 継続
    return true
  end
 
  #--------------------------------------------------------------------------
  # Régler le niveau
  #--------------------------------------------------------------------------
  def command_316
    value = operate_value(@parameters[1], @parameters[2], @parameters[3])
    iterate_actor(@parameters[0]) do |actor|
      if value > 0
        for i in 1..value
          actor.level_up
          if actor.evolve_check != false
            scenebis = Pokemon_Evolve.new(actor, actor.evolve_check)
            scenebis.main
            Graphics.transition
          end
        end
      else
        actor.level += value
        if actor.level <= 0
          actor.level = 1
        end
      end
      actor.statistic_refresh
    end
    return true
  end
 
  #--------------------------------------------------------------------------
  # Enseigner compétence
  #--------------------------------------------------------------------------
  def command_318
    actor = $pokemon_party.actors[$game_variables[4]]
    if actor != nil
      if @parameters[1] == 0
        enseigner_capacite(actor, @parameters[2])
      else
        actor.forget_skill(@parameters[2])
      end
    end
    # 継続
    return true
  end
 
  #--------------------------------------------------------------------------
  # Modifier nom
  #--------------------------------------------------------------------------
  def command_320
    # アクターを取得
    actor = $pokemon_party.actors[$game_variables[4]]
    # 名前を変更
    if actor != nil
     
      if @parameters[1] != ""
        actor.given_name = @parameters[1]
      else
        name_pokemon(actor)
      end
    end
    # 継続
    return true
  end
 
  #--------------------------------------------------------------------------
  # Démarrer un combat
  #-------------------------------------------------------------------------- 
  def command_301
    call_battle_trainer(@parameters[0], true, @parameters[1], @parameters[2], $data_trainer[@parameters[0]][8])
    current_indent = @list[@index].indent
    $game_temp.battle_proc = Proc.new { |n| @branch[current_indent] = n }
    #@index += 1
    return true
  end
 
  #--------------------------------------------------------------------------
  # Action conditionnelle
  #--------------------------------------------------------------------------
  def command_111
    # ローカル変数 result を初期化
    result = false
    # 条件判定
    case @parameters[0]
    when 0  # スイッチ
      result = ($game_switches[@parameters[1]] == (@parameters[2] == 0))
    when 1  # 変数
      value1 = $game_variables[@parameters[1]]
      if @parameters[2] == 0
        value2 = @parameters[3]
      else
        value2 = $game_variables[@parameters[3]]
      end
      case @parameters[4]
      when 0  # と同値
        result = (value1 == value2)
      when 1  # 以上
        result = (value1 >= value2)
      when 2  # 以下
        result = (value1 <= value2)
      when 3  # 超
        result = (value1 > value2)
      when 4  # 未満
        result = (value1 < value2)
      when 5  # 以外
        result = (value1 != value2)
      end
    when 2  # セルフスイッチ
      if @event_id > 0
        key = [$game_map.map_id, @event_id, @parameters[1]]
        if @parameters[2] == 0
          result = ($game_self_switches[key] == true)
        else
          result = ($game_self_switches[key] != true)
        end
      end
    when 3  # タイマー
      if $game_system.timer_working
        sec = $game_system.timer / Graphics.frame_rate
        if @parameters[2] == 0
          result = (sec >= @parameters[1])
        else
          result = (sec <= @parameters[1])
        end
      end
    when 4  # アクター
      if pokemon_numero($game_variables[4]) != nil
        case @parameters[2]
        when 1
          result = (pokemon_numero($game_variables[4]).name == @parameters[3])
        when 2  # スキル
          result = (pokemon_numero($game_variables[4]).skill_learnt?(@parameters[3]))
        when 5
          if @parameters[3] == 9
            result = pokemon_numero($game_variables[4]).dead?
          else
            result = (pokemon_numero($game_variables[4]).status == @parameters[3])
          end
        end
      end
    when 6  # キャラクター
      character = get_character(@parameters[1])
      if character != nil
        result = (character.direction == @parameters[2])
      end
    when 7  # ゴールド
      if @parameters[2] == 0
        result = ($pokemon_party.money >= @parameters[1])
      else
        result = ($pokemon_party.money <= @parameters[1])
      end
    when 8  # アイテム
      result = ($pokemon_party.item_number(@parameters[1]) > 0)
    when 11  # ボタン
      result = (Input.press?(@parameters[1]))
    when 12  # スクリプト
      result = eval(@parameters[1])
    end
    # 判定結果をハッシュに格納
    @branch[@list[@index].indent] = result
    # 判定結果が真だった場合
    if @branch[@list[@index].indent] == true
      # 分岐データを削除
      @branch.delete(@list[@index].indent)
      # 継続
      return true
    end
    # 条件に該当しない場合 : コマンドスキップ
    return command_skip
  end
 
  #--------------------------------------------------------------------------
  # Shop
  #--------------------------------------------------------------------------
  def command_302
    shop_list = [@parameters[1]]
    loop do
      @index += 1
      if @list[@index].code == 605
        shop_list.push(@list[@index].parameters[1])
      else
        break
      end
    end
    unless $game_variables[5000]["compteurs"] == nil
      if $game_variables[5000]["compteurs"] != nil and
          $game_variables[5000]["compteurs"][0].tourne
        bool = $game_variables[5000]["compteurs"][1]
        $game_variables[5000]["compteurs"][0].arreter
        $game_variables[5000]["compteurs"][1] = bool
      end
    end
    $scene = Pokemon_Shop.new(shop_list)
    @wait_count = 2
    @index -= 1
    return true
  end
 
  #--------------------------------------------------------------------------
  # Gestion de Variables
  #--------------------------------------------------------------------------
  def command_122
    # 値を初期化
    value = 0
    # オペランドで分岐
    case @parameters[3]
    when 0  # 定数
      value = @parameters[4]
    when 1  # 変数
      value = $game_variables[@parameters[4]]
    when 2  # 乱数
      value = @parameters[4] + rand(@parameters[5] - @parameters[4] + 1)
    when 3  # アイテム
      value = $pokemon_party.item_number(@parameters[4])
    when 4  # アクター
      actor = $pokemon_party.actors[$game_variables[4]]
      if actor != nil
        case @parameters[5]
        when 0  # レベル
          value = actor.level
        when 1  # EXP
          value = actor.exp
        when 2  # Type1
          value = actor.type1
        when 3  # type2
          value = actor.type2
        when 4  # HP
          value = actor.hp
        when 5  # max_hp
          value = actor.max_hp
        when 6  # 腕力
          value = actor.atk
        when 7  # 器用さ
          value = actor.dfe
        when 8  # 素早さ
          value = actor.spd
        when 9  # 魔力
          value = actor.ats
        when 10  # 攻撃力
          value = actor.dfs
        when 11  # 物理防御
          value = actor.gender
        when 12  # 魔法防御
          value = actor.id
        when 13  # 回避修正
          value = actor.loyalty
        end
      end
    when 6  # キャラクター
      character = get_character(@parameters[4])
      if character != nil
        case @parameters[5]
        when 0  # X 座標
          value = character.x
        when 1  # Y 座標
          value = character.y
        when 2  # 向き
          value = character.direction
        when 3  # 画面 X 座標
          value = character.screen_x
        when 4  # 画面 Y 座標
          value = character.screen_y
        when 5  # 地形タグ
          value = character.terrain_tag
        end
      end
    when 7  # その他
      case @parameters[4]
      when 0  # マップ ID
        value = $game_map.map_id
      when 1  # パーティ人数
        value = $pokemon_party.actors.size
      when 2  # ゴールド
        value = $pokemon_party.money
      when 3  # 歩数
        value = $pokemon_party.steps
      when 4  # プレイ時間
        value = Graphics.frame_count / Graphics.frame_rate
      when 5  # タイマー
        value = $game_system.timer / Graphics.frame_rate
      when 6  # セーブ回数
        value = $game_system.save_count
      end
    end
    for i in @parameters[0] .. @parameters[1]
      # 操作で分岐
      case @parameters[2]
      when 0  # 代入
        $game_variables = value
      when 1  # 加算
        $game_variables += value
      when 2  # 減算
        $game_variables -= value
      when 3  # 乗算
        $game_variables *= value
      when 4  # 除算
        if value != 0
          $game_variables /= value
        end
      when 5  # 剰余
        if value != 0
          $game_variables %= value
        end
      end
      # 上限チェック
      if $game_variables > 99999999
        $game_variables = 99999999
      end
      # 下限チェック
      if $game_variables < -99999999
        $game_variables = -99999999
      end
    end
    # マップをリフレッシュ
    $game_map.need_refresh = true
    # 継続
    return true
  end
 
  #--------------------------------------------------------------------------
  # Inserer un script
  #--------------------------------------------------------------------------
  def command_355
    # script に 1 行目を設定
    script = @list[@index].parameters[0] + "\n"
    # ループ
    loop do
      # 次のイベントコマンドがスクリプト 2 行目以降の場合
      if @list[@index+1].code == 655
        # script に 2 行目以降を追加
        script += @list[@index+1].parameters[0] + "\n"
      # イベントコマンドがスクリプト 2 行目以降ではない場合
      else
        # ループ中断
        break
      end
      # インデックスを進める
      @index += 1
    end
    $running_script = "MAP #{@map_id} EVENT #{@event_id}\nSCRIPT\n#{script}"
    (eval(script) or true)
  end
 
end

#==============================================================================
# ■ Interpreter
# Pokemon Script Project - Krosk
# 18/07/07
#-----------------------------------------------------------------------------
# Scène à modifier à loisir
#-----------------------------------------------------------------------------
# Fonctions personnelles "Insérer un script"
#-----------------------------------------------------------------------------

class Interpreter
  include POKEMON_S
 
  #-----------------------------------------------------------------------------
  # call_battle_wild
  #   Appel d'un combat contre un Pokémon sauvage quelconque
  #   (Pour un légendaire mobile, cf fonction suivante)
  #   id: id Pokémon
  #   level: niveau du Pokémon sauvage
  #-----------------------------------------------------------------------------
  def call_battle_wild(id_data, level, shiny = false, ia = false)
    $game_temp.map_bgm = $game_system.playing_bgm
    $game_system.bgm_stop
    if id_data.type == Fixnum
      id = id_data
    elsif id_data.type == String
      id = id_conversion(id_data)
    end
    pokemon = Pokemon.new(id, level, shiny)
    $scene = Pokemon_Battle_Wild.new($pokemon_party, pokemon, ia)
    @wait_count = 2
    return true
  end
  alias demarrer_combat call_battle_wild

  #-----------------------------------------------------------------------------
  # call_battle_existing
  #   Appel d'un combat contre un Pokémon défini
  #   (Pour un légendaire mobile par exemple déjà créé)
  #   pokemon: class Pokemon
  #-----------------------------------------------------------------------------
  def call_battle_existing(pokemon, ia = false)
    $game_temp.map_bgm = $game_system.playing_bgm
    $game_system.bgm_stop
    if pokemon == nil or pokemon.dead?
      return false
    end
    $scene = Pokemon_Battle_Wild.new($pokemon_party, pokemon, ia)
    @wait_count = 2
    return true
  end
  alias demarrer_combat_existant call_battle_existing
 
  #-----------------------------------------------------------------------------
  # call_battle_trainer
  #   Appel d'un combat contre un Dresseur
  #   id: id Dresseur
  #-----------------------------------------------------------------------------
  def call_battle_trainer(id, ia = true, run_able = false, lose_able = false, niveau = 2)
    $game_temp.map_bgm = $game_system.playing_bgm
    $game_system.bgm_stop
    $scene = Pokemon_Battle_Trainer.new($pokemon_party, id, ia, run_able, lose_able, niveau)
    @wait_count = 2
    return true
  end
 
  #-----------------------------------------------------------------------------
  # set_encounter(rate, listx)
  #   Définition de liste de rencontre des Pokémons
  #   rate: de 1 à 50 de préférence
  #   listx: (x = tag du terrain) [[id, level, rareté], [id, level], ...]
  #----------------------------------------------------------------------------- 
  def set_encounter(rate = 0, list1 = [], list2 = [], list3 = [], list4 = [])
    $random_encounter = [0]
    $random_encounter[0] = rate
    $random_encounter[1] = list1
    $random_encounter[2] = list2
    $random_encounter[3] = list3
    $random_encounter[4] = list4
    @wait_count = 2
    return false
  end
 
  def set_encounter_name(rate, list1 = [], list2 = [], list3 = [], list4 = [])
    for pokemon in list1
      pokemon[0] = id_conversion(pokemon[0])
    end
    for pokemon in list2
      pokemon[0] = id_conversion(pokemon[0])
    end
    for pokemon in list3
      pokemon[0] = id_conversion(pokemon[0])
    end
    for pokemon in list4
      pokemon[0] = id_conversion(pokemon[0])
    end
    set_encounter(rate, list1, list2, list3, list4)
  end
 
  #-----------------------------------------------------------------------------
  # run_computer
  #   Appel de PC
  #-----------------------------------------------------------------------------
  def run_computer
    unless $game_variables[5000]["compteurs"] == nil
      if $game_variables[5000]["compteurs"] != nil and
          $game_variables[5000]["compteurs"][0].tourne
        bool = $game_variables[5000]["compteurs"][1]
        $game_variables[5000]["compteurs"][0].arreter
        $game_variables[5000]["compteurs"][1] = bool
      end
    end
    $scene = Pokemon_Computer.new
    @wait_count = 2
    return false
  end
  alias demarrer_pc run_computer
 
  def enable_pokedex
    $data_pokedex[0] = true
  end
  alias activer_pokedex enable_pokedex
 
  #-----------------------------------------------------------------------------
  # heal_party
  #   Refill du Centre Pokémon
  #----------------------------------------------------------------------------- 
  def heal_party_center
    $pokemon_party.refill_party
  end
  alias soigner_equipe heal_party_center
 
  #-----------------------------------------------------------------------------
  # add_pokemon(id_data, level, shiny)
  #   Ajout d'un Pokémon dans l'équipe
  #-----------------------------------------------------------------------------
  def add_pokemon(id_data, level = 5, shiny = false)
    if id_data.type == Fixnum
      id = id_data
    elsif id_data.type == String
      id = id_conversion(id_data)
    end
    pokemon = Pokemon.new(id, level, shiny)
    $pokemon_party.add(pokemon)
  end
  alias ajouter_pokemon add_pokemon
 
  def add_or_store_pokemon(id_data, level = 5, shiny = false)
    if id_data.type == Fixnum
      id = id_data
    elsif id_data.type == String
      id = id_conversion(id_data)
    end
    pokemon = Pokemon.new(id, level, shiny)
    $pokemon_party.add_or_store(pokemon)
  end
  alias ajouter_stocker_pokemon add_or_store_pokemon
 
  def add_pokemon_parameter(hash)
    if hash["ID"] == nil or hash["NV"] == nil
      return
    end
    pokemon = Pokemon.new(hash["ID"], hash["NV"], hash["SHINY"])
    if hash["GR"] != nil and ["F", "M", "I"].include?(hash["GR"])
      pokemon.set_gender(hash["GR"])
    end
    if hash["FORM"] != nil
      if hash["FORM"].type == Fixnum
        pokemon.form = hash["FORM"]
      elsif hash["FORM"].type == Array
        pokemon.form = hash["FORM"][rand(hash["FORM"].size)]
      end
    end
    if hash["MOVE"] != nil and hash["MOVE"].type == Array
      i = 0
      for skill in hash["MOVE"]
        if skill != nil and skill != "AUCUN"
          pokemon.skills_set = Skill.new(Skill_Info.id(skill))
        end
        if skill == "AUCUN"
          pokemon.skills_set = nil
        end
        i += 1
      end
      pokemon.skills_set.compact!
    end
    if hash["OBJ"] != nil
      if hash["OBJ"].type == Fixnum
        pokemon.item_hold = hash["OBJ"]
      elsif hash["OBJ"].type == String
        pokemon.item_hold = Item.id(hash["OBJ"])
      end
    end
    if hash["STAT"] != nil and hash["STAT"].type == Array and
        hash["STAT"].length == 6
      pokemon.dv_modifier(hash["STAT"])
    end
    if hash["BALL"] != nil and hash["BALL"].type == String
      pokemon.ball_data = $item.data($item.id(hash["BALL"])["ball"])
    end
    if hash["TRAINER_ID"] != nil and hash["TRAINER_ID"].type == Fixnum
      pokemon.trainer_id = hash["TRAINER_ID"]
    end
    if hash["TRAINER_NAME"] != nil and hash["TRAINER_NAME"].type == String
      pokemon.trainer_id = hash["TRAINER_NAME"]
    end
    ajouter_pokemon_cree(pokemon)
  end
  alias ajouter_pokemon_param add_pokemon_parameter

  def store_pokemon(id_data, level = 5, shiny = false)
    if id_data.type == Fixnum
      id = id_data
    elsif id_data.type == String
      id = id_conversion(id_data)
    end
    pokemon = Pokemon.new(id, level, shiny)
    $pokemon_party.store_captured(pokemon)
  end
  alias stocker_pokemon store_pokemon
 
  #-----------------------------------------------------------------------------
  # add_and_name_pokemon(id_data, level)
  #   Ajout d'un Pokémon dans l'équipe
  #-----------------------------------------------------------------------------
  def add_and_name_pokemon(id_data, level = 5, shiny = false)
    if id_data.type == Fixnum
      id = id_data
    elsif id_data.type == String
      id = id_conversion(id_data)
    end
    pokemon = Pokemon.new(id, level, shiny)
    name_pokemon(pokemon)
    $pokemon_party.add(pokemon)
  end
  alias ajouter_et_nommer_pokemon add_and_name_pokemon
 
  #-----------------------------------------------------------------------------
  # add_created_pokemon(pokemon)
  #   Ajout d'un Pokémon (objet de classe Pokemon) dans l'équipe
  #-----------------------------------------------------------------------------
  def add_created_pokemon(pokemon)
    $pokemon_party.add(pokemon)
  end
  alias ajouter_pokemon_cree add_created_pokemon
 
  def add_store_created_pokemon(pokemon)
    $pokemon_party.add_or_store(pokemon)
  end
  alias ajouter_stocker_pokemon_cree add_store_created_pokemon
 
  #-----------------------------------------------------------------------------
  # remove_pokemon(id_data)
  #   Enleve un seul Pokémon de l'équipe par son ID ou son nom
  #-----------------------------------------------------------------------------
  def remove_pokemon(id_data)
    if id_data.type == Fixnum
      id = id_data
    elsif id_data.type == String
      id = id_conversion(id_data)
    elsif id_data.type == Pokemon
      $pokemon_party.actors.delete(id_data)
      return
    end
    $pokemon_party.remove_id(pokemon_index(id))
  end
  alias retirer_pokemon remove_pokemon
 
  #-----------------------------------------------------------------------------
  # remove_pokemon_index(index)
  #   Enleve un seul Pokémon de l'équipe par son index
  #-----------------------------------------------------------------------------
  def remove_pokemon_index(index)
    $pokemon_party.remove_id(index)
  end
  alias retirer_pokemon_index remove_pokemon_index
 
 
  #-----------------------------------------------------------------------------
  # create_pokemon(id, level)
  #   Crèe un Pokémon, à utiliser comme il se doit
  #-----------------------------------------------------------------------------
  def create_pokemon(id_data, level, shiny = false)
    if id_data.type == Fixnum
      id = id_data
    elsif id_data.type == String
      id = id_conversion(id_data)
    end
    return pokemon = Pokemon.new(id, level, shiny)
  end
 
  #-----------------------------------------------------------------------------
  # make_pokemon(slot, id, level, shiny)
  #   Crèe un Pokémon, et le stocke
  #-----------------------------------------------------------------------------
  def make_pokemon(slot, id_data=[], level=[], shiny = false)
    hash = nil
    if id_data.type == Fixnum
      id = id_data
    elsif id_data.type == String
      id = id_conversion(id_data)
    elsif slot.type == Hash and id_data.type == Array and level.type == Array and not(shiny)
      hash = slot
      slot = hash["SLOT"]
      id_data = hash["ID"]
      level = hash["NV"]
      shiny = hash["SHINY"]
    end
    if $existing_pokemon[slot] == nil
      $existing_pokemon[slot] = Pokemon.new(id, level, shiny)
      if hash != nil
        if hash["OBJ"].type == Fixnum or hash["OBJ"].type == String
          $existing_pokemon[slot].item_hold = hash["OBJ"].type == Fixnum ? hash["OBJ"] : Item_id(hash["OBJ"])
        end
        if hash["DV"] and hash["DV"].size == 6
          $existing_pokemon[slot].dv_modifier(hash["DV"])
        end
        if hash["MOVE"].type == Array and hash["MOVE"].size == 4
          i = 0
          for skill in pokemon_data[4]
            if skill != nil and skill != "AUCUN"
              $existing_pokemon[slot].skills_set = Skill.new(Skill_Info.id(skill))
            end
            if skill == "AUCUN"
              $existing_pokemon[slot].skills_set = nil
            end
            i += 1
          end
          $existing_pokemon[slot].skills_set.compact!
        end
        if hash["GR"] != nil
          $existing_pokemon[slot].set_gender(hash["GR"])
        end
        if hash["FORM"].type == Fixnum
          $existing_pokemon[slot].form = hash["FORM"]
        elsif hash["FORM"].type == Array
          $existing_pokemon[slot].form = hash["FORM"]
        end
        if hash["SHINY"] and [true,false].include?(hash["SHINY"])
          $existing_pokemon[slot].shiny = hash["SHINY"]
        end
        if hash["TSTATS"].type == Array and hash["TSTATS"].size == 6
          $existing_pokemon[slot].table_stats = hash["TSTATS"]
        end
        if hash["TTYPE"].type == Array and hash["TTYPE"].size == $data_table_type.size
          $existing_pokemon[slot].table_type = hash["TTYPE"]
        end
        if hash["STYPE"].type == Array and hash["TTYPE"].size == $data_table_type.size
          $existing_pokemon[slot].table_skill_type = hash["TTYPE"]
        end
        if hash["NATURE"].type == String
          for i in 0...POKEMON_S::NATURE.size
            if POKEMON_S::NATURE[0] == hash["NATURE"]
              $existing_pokemon[slot].nature = POKEMON_S::NATURE
              break
            end
          end
        elsif hash["NATURE"].type == Array and hash["NATURE"].size == 6
          $existing_pokemon[slot].nature = hash["NATURE"]
        end
      end
    end
  end
  alias enregistrer_pokemon make_pokemon
 
  #-----------------------------------------------------------------------------
  # existing_pokemon?(slot)
  #   Demande si un slot est occupé
  #-----------------------------------------------------------------------------
  def existing_pokemon?(slot)
    if $existing_pokemon[slot] != nil
      return true
    end
    return false
  end
  alias pokemon_existant? existing_pokemon?
 
  #-----------------------------------------------------------------------------
  # erase_existing_pokemon(slot)
  #   Efface un pokémon au slot
  #-----------------------------------------------------------------------------
  def erase_existing_pokemon(slot)
    $existing_pokemon[slot] = nil
    return false
  end
  alias effacer_pokemon_existant erase_existing_pokemon
 
  #-----------------------------------------------------------------------------
  # call_pokemon(slot)
  #   Renvoie le pokemon (class) dans un slot.
  #-----------------------------------------------------------------------------
  def call_pokemon(slot)
    return $existing_pokemon[slot]
  end
  alias appel_pokemon call_pokemon
 
  #-----------------------------------------------------------------------------
  # skill_conversion
  #   Conversion script -> BDD par exportation
  #-----------------------------------------------------------------------------  
  def skill_conversion
    # Conversion
    for id in 1..$data_skills_pokemon.length-1
      skill = Skill.new(id)
     
      if $data_skills[id] == nil
        $data_skills[id] = RPG::Skill.new
      end
     
      $data_skills[id].name = skill.name
      $data_skills[id].element_set = [skill.type]
      if skill.power > 200
        $data_skills[id].atk_f = 200
        $data_skills[id].eva_f = skill.power - 200
      else
        $data_skills[id].atk_f = skill.power
        $data_skills[id].eva_f = 0
      end
      $data_skills[id].hit = skill.accuracy
      $data_skills[id].power = skill.effect
      $data_skills[id].pdef_f = skill.effect_chance
      $data_skills[id].sp_cost = skill.ppmax
      case skill.target
      when 1
        $data_skills[id].scope = 0
      when 0
        $data_skills[id].scope = 1
      when 8
        $data_skills[id].scope = 2
      when 4
        $data_skills[id].scope = 3
      when 20
        $data_skills[id].scope = 4
      when 40
        $data_skills[id].scope = 5
      when 10
        $data_skills[id].scope = 7
      end
      $data_skills[id].animation1_id = skill.user_anim_id
      $data_skills[id].animation2_id = skill.target_anim_id
      $data_skills[id].description = skill.description
      $data_skills[id].variance = skill.direct? ? 1 : 0
      $data_skills[id].mdef_f = skill.priority
      if skill.map_use != 0
        $data_skills[id].occasion = 0
        $data_skills[id].common_event_id = skill.map_use
      else
        $data_skills[id].occasion = 1
        $data_skills[id].common_event_id = 0
      end
     
      # Effacement
      $data_skills[id].plus_state_set = []
      $data_skills[id].minus_state_set = []
      $data_skills[id].agi_f = 0
      $data_skills[id].str_f = 0
      $data_skills[id].dex_f = 0
      $data_skills[id].agi_f = 0
      $data_skills[id].int_f = 0
    end
   
    file = File.open("Skills.rxdata", "wb")
    Marshal.dump($data_skills, file)
    file.close
  end
 
 
  #-----------------------------------------------------------------------------
  # pokemon_conversion
  #   Conversion script -> BDD par exportation
  # $data_enemies et $data_classes
  #-----------------------------------------------------------------------------  
  def pokemon_conversion
    # Inscription des noms
    for i in 118..175
      if $data_weapons == nil
        $data_weapons = RPG::Weapon.new
      end
      $data_weapons.name = Item.name(i)
    end
   
    # Inscription des capa spé
    for i in 1..77
      if $data_armors == nil
        $data_armors = RPG::Armor.new
      end
      $data_armors.name = $data_ability[0]
      $data_armors.description = $data_ability[1]
    end
   
   
    # Conversion
    for id in 1..$data_pokemon.length-1
      pokemon = Pokemon.new(id)
     
      if $data_enemies[id] == nil
        $data_enemies[id] = RPG::Enemy.new
      end
     
      if $data_classes[id] == nil
        $data_classes[id] = RPG::Class.new
      end
     
      # Reset données
      $data_enemies[id].mdef = 0
      $data_enemies[id].pdef = 0
      $data_enemies[id].actions = []
     
      $data_classes[id].weapon_set = []
      $data_classes[id].armor_set = []
     
      # Nom
      $data_enemies[id].name = pokemon.name
      $data_enemies[id].battler_name = "Front_Male/"+sprintf("%03d",id)+".png"
     
      # ID secondaire
      $data_enemies[id].maxsp = id
     
      # Base Stats
      $data_enemies[id].maxhp = pokemon.base_hp
      $data_enemies[id].agi = pokemon.base_spd
      $data_enemies[id].int = pokemon.base_ats
      $data_enemies[id].str = pokemon.base_atk
      $data_enemies[id].dex = pokemon.base_dfe
      $data_enemies[id].atk = pokemon.base_dfs
     
      # Apprentissage des skills
      $data_classes[id].learnings = []
      for skill in pokemon.skills_table
        learning = RPG::Class::Learning.new
        learning.level = skill[1]
        learning.skill_id = skill[0]
        $data_classes[id].learnings.push(learning)
      end
     
      # CT/CS: support script
     
      # Exp Type
      $data_classes[id].weapon_set.push(pokemon.exp_type + 15)
     
      # Evolution
      $data_classes[id].name = ""
     
      # Evolution unique
      if pokemon.evolve_list.length == 2
        # Evolution naturelle seulement
        name = pokemon.evolve_list[1][0]
        data = pokemon.evolve_list[1][1]
        if data.type == Fixnum and name != ""
          $data_classes[id].name = name + "/" + data.to_s
          $data_classes[id].weapon_set.push(22)
        elsif data == "loyal"
          $data_classes[id].name = name#"L" + "/" + name
          $data_classes[id].weapon_set.push(24)
        elsif data == "trade"
          $data_classes[id].name = name#"T" + "/" + name
          $data_classes[id].weapon_set.push(25)
        elsif data == "stone"
          $data_classes[id].name = name#"S" + "/" + name
          $data_classes[id].weapon_set.push(23)
        end
      else
        # Evolution spéciale/multiple
        $data_classes[id].weapon_set.push(26)
      end
     
      # Type
      if pokemon.type1 != 0
        $data_enemies[id].element_ranks[pokemon.type1] = 1
        $data_classes[id].element_ranks[pokemon.type1] = 3
      end
      if pokemon.type2 != 0
        $data_enemies[id].element_ranks[pokemon.type2] = 2
        $data_classes[id].element_ranks[pokemon.type2] = 3
      end
     
      # Rareté
      $data_enemies[id].gold = pokemon.rareness
     
      # Genre
      $data_classes[id].armor_set = []
      case Pokemon_Info.female_rate(id) # Female rate
      when -1
        $data_classes[id].armor_set.push(2)
      when 0
        $data_classes[id].armor_set.push(3)
      when 12.5
        $data_classes[id].armor_set.push(4)
      when 25
        $data_classes[id].armor_set.push(5)
      when 50
        $data_classes[id].armor_set.push(6)
      when 75
        $data_classes[id].armor_set.push(7)
      when 87.5
        $data_classes[id].armor_set.push( 8)
      when 100
        $data_classes[id].armor_set.push(9)
      else
        $data_classes[id].armor_set.push(6)
      end
     
      # Loyauté
      case pokemon.loyalty
      when 0
        $data_classes[id].armor_set.push(11)
      when 35
        $data_classes[id].armor_set.push(12)
      when 70
        $data_classes[id].armor_set.push(13)
      when 90
        $data_classes[id].armor_set.push(14)
      when 100
        $data_classes[id].armor_set.push(15)
      when 140
        $data_classes[id].armor_set.push(16)
      else
        $data_classes[id].armor_set.push(13)
      end
     
      # EV et Base Exp
      i = 0
      for element in pokemon.battle_list
        if i == pokemon.battle_list.length-1
          $data_enemies[id].exp = element
          next
        end
       
        case element
        when 1
          $data_classes[id].weapon_set.push(2+i)
        when 2
          $data_classes[id].weapon_set.push(8+i)
        when 3
          $data_classes[id].weapon_set.push(2+i)
          $data_classes[id].weapon_set.push(8+i)
        end
        i += 1
      end
     
      # Breed Groupe
      for group in pokemon.breed_group
        $data_classes[id].armor_set.push(group + 17)
      end
     
      # Egg Hatch
      case pokemon.hatch_step
      when 1280
        $data_classes[id].weapon_set.push(28)
      when 2560
        $data_classes[id].weapon_set.push(29)
      when 3840
        $data_classes[id].weapon_set.push(28)
        $data_classes[id].weapon_set.push(29)
      when 5120
        $data_classes[id].weapon_set.push(30)
      when 6400
        $data_classes[id].weapon_set.push(30)
        $data_classes[id].weapon_set.push(28)
      when 7680
        $data_classes[id].weapon_set.push(30)
        $data_classes[id].weapon_set.push(29)
      when 8960
        $data_classes[id].weapon_set.push(30)
        $data_classes[id].weapon_set.push(29)
        $data_classes[id].weapon_set.push(28)
      when 10240
        $data_classes[id].weapon_set.push(31)
      when 20480
        $data_classes[id].weapon_set.push(32)
      when 30720
        $data_classes[id].weapon_set.push(31)
        $data_classes[id].weapon_set.push(32)
      else
        $data_classes[id].weapon_set.push(30)
      end
     
      # Liste CT/CS
      for element in pokemon.skills_allow
        if element.type == Fixnum
          $data_classes[id].weapon_set.push(33 + element)
        end
        if element.type == Array
          $data_classes[id].weapon_set.push(33 + 50 + element[0])
        end
      end
     
      # Capa Spé
      list = []
      for i in 1..$data_ability.length-1
        list.push($data_ability[0])
      end
      for ability in Pokemon_Info.ability_list(id)
        abid = list.index(ability) + 1
        $data_classes[id].armor_set.push(abid + 33)
      end
     
      # Attaque par accouplement
      r = 0
      for skill in pokemon.breed_move
        if $data_enemies[id].actions[r] == nil
          $data_enemies[id].actions[r] = RPG::Enemy::Action.new
        end
        $data_enemies[id].actions[r].kind = 1
        $data_enemies[id].actions[r].skill_id = skill
        r += 1
      end
    end
   
    file = File.open("Enemies.rxdata", "wb")
    Marshal.dump($data_enemies, file)
    file.close
    file = File.open("Classes.rxdata", "wb")
    Marshal.dump($data_classes, file)
    file.close
    file = File.open("Weapons.rxdata", "wb")
    Marshal.dump($data_weapons, file)
    file.close
    file = File.open("Armors.rxdata", "wb")
    Marshal.dump($data_armors, file)
    file.close
  end
 
  #-----------------------------------------------------------------------------
  # item_conversion
  #   Conversion script -> BDD par exportation
  # $data_items
  #-----------------------------------------------------------------------------
  def item_conversion
    for i in 1..$data_item.length-1
      data = $data_item
      item = RPG::Item.new
     
      if data == nil or data == []
        $data_items = item
        next
      end
     
      item.id = i
      item.name = data[0]
      item.icon_name = data[1]
      item.description = data[3]
      item.price = data[4]
     
      # Texte objet utilisé
      if data[6] != nil and data[6] != ""
        item.description += "//" + data[6]
      end
     
      # Poche
      case data[2]
      when "ITEM"
        item.element_set.push(28)#23
      when "BALL"
        item.element_set.push(29)
      when "TECH"
        item.element_set.push(30)
      when "BERRY"
        item.element_set.push(31)
      when "KEY"
        item.element_set.push(32)
      else
        item.element_set.push(28)
      end
     
      # Profil
      for j in 0...data[5].length
        if data[5][j]
          item.element_set.push(34 + j)
        end
      end
     
      # Logdata
      if data[8] != nil
        item.recover_hp_rate = data[8][0]
        item.recover_hp = data[8][1]
        item.recover_sp_rate = data[8][2]
        item.recover_sp = data[8][3]
      end
      if data[9] != nil
        item.minus_state_set = data[9]
      end
     
      # Conversion Event
      if data[7] != nil and data[7][0] == "event"
        item.common_event_id = data[7][1]
      end
     
      $data_items = item
     
    end
   
    file = File.open("Items.rxdata", "wb")
    Marshal.dump($data_items, file)
    file.close
  end
   
  #-----------------------------------------------------------------------------
  # id_conversion(name)
  #   Renvoie l'id du Pokémon nommé name
  #----------------------------------------------------------------------------- 
  def id_conversion(name)
    for id in 1..$data_pokemon.length-1
      if name == Pokemon_Info.name(id)
        return id
      end
    end
  end
 
  #-----------------------------------------------------------------------------
  # draw_choice
  #   Fenêtre de choix Oui, non
  #-----------------------------------------------------------------------------  
  def draw_choice(arg1 = "OUI", arg2 = "NON")
    window = Window_Command.new(1, [arg1, arg2], $fontsizebig)
    width = [window.contents.text_size(arg1).width, window.contents.text_size(arg2).width].max + 16
    window.dispose
    @command = Window_Command.new(width + 32, [arg1, arg2], $fontsizebig)
    @command.x = 605 - width
    @command.y = 215
    @command.z = 10000
    loop do
      Graphics.update
      Input.update
      @command.update
      if Input.trigger?(Input::C) and @command.index == 0
        @command.dispose
        @command = nil
        #Input.update
        @wait_count = 2
        return true
      elsif Input.trigger?(Input::C) and @command.index == 1
        @command.dispose
        @command = nil
        #Input.update
        @wait_count = 2
        return false
      elsif Input.trigger?(Input::B)
        @command.dispose
        @command = nil
        #Input.update
        @wait_count = 2
        return false
      end
    end
  end
 
  #-----------------------------------------------------------------------------
  # cry_pokemon
  #   Effet sonore: cri du Pokémon
  #-----------------------------------------------------------------------------
  def cry_pokemon(id_data)
    if id_data.type == String
      id = id_conversion(id_data)
    elsif id_data.type == Fixnum
      id = id_data
    end
    ida = sprintf("%03d", id)
    filename = "Audio/SE/Cries/" + ida + "Cry.wav"
    if FileTest.exist?(filename)
      Audio.se_play(filename)
    end
    return true
  end
 
  #-----------------------------------------------------------------------------
  # complete_pokedex
  #   Complète le Pokédex
  #-----------------------------------------------------------------------------
  def complete_pokedex
    for i in 1..$data_pokedex.length-1
      $data_pokedex = [true, true]
    end
  end
 
  #-----------------------------------------------------------------------------
  # name_pokemon
  #   Scene de nom
  #-----------------------------------------------------------------------------
  def name_pokemon(pokemon)
    if pokemon == nil
      return false
    end
    Graphics.freeze
    name_scene = Pokemon_Name.new(pokemon)
    name_scene.main
    name_scene = nil
    Graphics.transition
    return true
  end
 
  #-----------------------------------------------------------------------------
  # Dresseur
  #   forcer : true  - le dresseur vous reperera meme si vous etes derriere un
  #                    bloc non traversable (option par defaut)
  #            false - le dresseur vous reperera uniquement si aucun bloc non
  #                    traversable se trouve entre vous et lui
  #-----------------------------------------------------------------------------
  def trainer_spotted(cases = 0, forcer = true)
    distance = cases
    character = $game_map.events[@event_id]
    if $game_player.moving?
      bool = false
    end
    case character.direction
    when 4 # Tourné vers la gauche
      if cases == 0
        distance = 10
      end
      if character.y == $game_player.y and
          character.x - $game_player.x >= 0 and
          (character.x - $game_player.x).abs <= distance
        $game_player.turn_right
        bool = true
      end
    when 8 # Tourné vers le haut
      if cases == 0
        distance = 7
      end
      if character.x == $game_player.x and
          character.y - $game_player.y >= 0 and
          (character.y - $game_player.y).abs <= distance
        $game_player.turn_down
        bool = true
      end
    when 6 # Tourné vers la droite
      if cases == 0
        distance = 10
      end
      if character.y == $game_player.y and
          character.x - $game_player.x <= 0 and
          (character.x - $game_player.x).abs <= distance
        $game_player.turn_left
        bool = true
      end
    when 2 # Tourné vers le bas
      if cases == 0
        distance = 7
      end
      if character.x == $game_player.x and
          character.y - $game_player.y <= 0 and
          (character.y - $game_player.y).abs <= distance
        $game_player.turn_up
        bool = true
      end
    end
    if Input.trigger?(Input::C) and $game_player.front_tile_event == character
      bool = true
    end
    if bool and not forcer
      d = character.direction
      if [4, 6].include?(character.direction)
        y = character.y
        min = character.x > $game_player.x ? $game_player.x : character.x
        max = character.x < $game_player.x ? $game_player.x : character.x
        for x in min..max
          bool = $game_map.passable?(x, y, d)
          break if not bool
        end
      else
        x = character.x
        min = character.y > $game_player.y ? $game_player.y : character.y
        max = character.y < $game_player.y ? $game_player.y : character.y
        for y in min..max
          bool = $game_map.passable?(x, y, d)
          break if not bool
        end
      end
    end
    return bool
  end
 
  def player_front_tile
    return $game_player.front_tile
  end
 
  def player_front_terrain_tag
    coord = $game_player.front_tile
    return $game_map.terrain_tag(coord[0], coord[1])
  end
 
  def player_front_passable?
    coord = $game_player.front_tile
    return $game_map.passable?(coord[0],coord[1], 10 - $game_player.direction)
  end
 
  # ------------------------------------------------------
  #                       Acessibilité
  # ------------------------------------------------------
 
  # ------------------------------------------------------
  # pokemon_numero(numero)
  #   Renvoie le Pokémon (objet de classe Pokemon) au numéro
  #   dans l'équipe: 0 = premier Pokémon, 1 = 2ème...
  # ------------------------------------------------------
  def pokemon_number(num)
    if num < 0 or num >= $pokemon_party.actors.length
      return nil
    end
    return $pokemon_party.actors[num]
  end
  alias pokemon_numero pokemon_number
 
  def pokemon_selected
    return pokemon_number(var(4))
  end
  alias pokemon_choisi pokemon_selected
 
  # ------------------------------------------------------
  # appel_menu_equipe
  #   Permet d'ouvrir une fenêtre de sélection du Pokémon.
  #   Renvoie -1, ou l'index du Pokémon (0 pour le premier,
  #   1 pour le suivant, 2 pour le suisuivant...
  # ------------------------------------------------------
  def call_party_menu
    unless $game_variables[5000]["compteurs"] == nil
      if $game_variables[5000]["compteurs"] != nil and
          $game_variables[5000]["compteurs"][0].tourne
        bool = $game_variables[5000]["compteurs"][1]
        $game_variables[5000]["compteurs"][0].arreter
        $game_variables[5000]["compteurs"][1] = bool
      end
    end
    Graphics.freeze
    scene = Pokemon_Party_Menu.new(0, 10000, "selection")
    scene.main
    data = scene.return_data
    scene = nil
    Graphics.transition
    $game_variables[4] = data
    return data
  end
  alias appel_menu_equipe call_party_menu
 
  # ------------------------------------------------------
  # enseigner_capacite(pokemon, skill_id)
  #   Permet d'enseigner une capacité à un pokemon (class), et d'écraser
  #   un skill choisi par le joueur si celui-ci a déjà plus de 4 skills.
  # ------------------------------------------------------
  def teach_skill(pokemon, skill_id)
    if skill_id.type == Fixnum
      id = skill_id
    elsif skill_id.type == String
      id = Skill_Info.id(skill_id)
    end
    if pokemon == nil
      return false
    end
    if not(pokemon.skill_learnt?(id))
      scene = Pokemon_Skill_Learn.new(pokemon, id)
      scene.main
      return scene.return_data
    end
    return false
  end
  alias enseigner_capacite teach_skill
 
  # ------------------------------------------------------
  # skill_selection
  #   Permet d'ouvrir une fenêtre de sélection d'un skill.
  #   Renvoie -1, ou l'index du de l'attaque (0 pour le premier,
  #   1 pour le suivant, 2 pour le suisuivant...
  # ------------------------------------------------------
  def skill_selection(pokemon)
    if pokemon == nil
      return -1
    end
    scene = Pokemon_Skill_Selection.new(pokemon)
    scene.main
    data = scene.return_data
    scene = nil
    $game_variables[5] = data
    return data
  end
 
  # ------------------------------------------------------
  # appliquer_objet(skill_id, pokemon)
  #   Permet d'imiter l'usage d'un objet.
  # ------------------------------------------------------
  def apply_item(id_data, pokemon = nil)
    if id_data.type == Fixnum
      item_id = id_data
    elsif id_data.type == String
      item_id = Skill_Info.id(id_data)
    end
    if Item.use_on_pokemon?(item_id)
      if pokemon == nil
        item_mode = "item_use"
        if Item.item_able_mode?(item_id)
          item_mode = "item_able"
        end
        scene = Pokemon_Party_Menu.new(0, 1000, item_mode, item_id)
        scene.main
        # return_data = [id item_utilisé, utilisé oui/non]
        data = scene.return_data
        scene = nil
        Graphics.transition
        return data[1]
      else
        $game_system.se_play($data_system.decision_se)
        result = Item.effect_on_pokemon(item_id, pokemon)
        if result[1] != ""
          draw_text(result[1])
          Input.update
          until Input.trigger?(Input::C)
            Input.update
            Graphics.update
          end
        end
        return result[0]
      end
    else
      data = Item.effect(item_id)
      used = data[0]
      string = data[1]
      return used
    end
  end
  alias appliquer_objet apply_item
 
  # ------------------------------------------------------
  # pokemon_possede(id)
  #   Renvoie si le pokémon est possédé ou non.
  # ------------------------------------------------------
  def got_pokemon(id_data)
    return false if $pokemon_party == nil
    return $pokemon_party.got_pokemon(id_data)
  end
  alias pokemon_possede got_pokemon
 
  # ------------------------------------------------------
  # pokemon_index(id)
  #   Renvoie l'index du Pokémon.
  # ------------------------------------------------------
  def get_pokemon(id_data)
    return $pokemon_party.get_pokemon(id_data)
  end
  alias pokemon_index get_pokemon
 
  # ------------------------------------------------------
  # sauv_retour(id)
  #   Enregistre une ou position du joueur dans le point de retour
  # ------------------------------------------------------
  def sauv_retour(map_id = $game_map.map_id, x = $game_player.x, y = $game_player.y)
    $game_variables[1] = map_id
    $game_variables[2] = x
    $game_variables[3] = y
  end

  # ------------------------------------------------------
  # var(id)
  #   $game_variables
  # ------------------------------------------------------
  def var(index)
    return $game_variables[index]
  end
 
  def switch(index)
    return $game_switches[index]
  end
 
  def equipe_vide?
    return $pokemon_party.actors.length == 0
  end
 
  # ------------------------------------------------------
  # actualiser_rencontre
  #   Update les rencontres aléatoires après un changement
  #   A appeler manuellement
  # ------------------------------------------------------
  def actualiser_rencontre
    if $scene.is_a?(Scene_Map)
      $scene.update_encounter
    end
  end
 
  # ------------------------------------------------------
  # ajouter_oeuf
  #   Ajoute un oeuf dont l'espèce est déterminée par id
  # ------------------------------------------------------
  def ajouter_oeuf(mother, father = nil)
    egg = Pokemon.new.new_egg(mother, father)
    ajouter_pokemon_cree(egg)
  end
 
  # ------------------------------------------------------
  # self_switch
  #   modifie la position de n'importe quel switch local
  #   de n'importe quel évent de n'importe quelle map
  # ------------------------------------------------------
  def self_switch(map_id, event_id, switch, statut)
    key = [map_id, event_id, switch]
    $game_self_switches[key] = statut
    if map_id == $game_map.map_id
      $game_map.need_refresh = true
    end
    return true
  end
 
  # ------------------------------------------------------
  # effectif_equipe
  #   Compte combien de membre appelable au combat
  # ------------------------------------------------------
  def effectif_equipe
    resultat = 0
    for member in $pokemon_party.actors
      if not member.egg?
        resultat += 1
      end
    end
    return resultat
  end
  end