module Alchimie # <-- module spécial car il contient pas mal de données
 
  #---------------------------------------------------------
  # UTILISATION :
  #---------------------------------------------------------
  # $scene = Scene_Alchimie.new
  # Appelle le menu d'alchimie afin de créer des objets
  #
  # $scene = Scene_Alchimie.new(true)
  # Appelle le menu d'alchimie, mais désactive la possibilité de créer un objet
  # Permet donc uniquement de voir les recettes sans les appliquer
  #
  # $game_party.learn_recette( type , id)
  # Apprend une recette. Remplacer type par 1 (objet) / 2 (arme) / 3 (équipement).
  # Remplacer id par l'ID de l'item dont il faut apprendre la recette.
  # id peut aussi être un tableau contenant plusieurs IDs :
  #
  # $game_party.learn_recette(2,[2,3])
  # Apprend les recettes des armes d'IDs 2 et 3.
  #
  # $game_party.forget_recette( type, id)
  # Même principe pour oublier une recette.
  #
  # Modifiez les paramètres ci-dessous afin
  # de personnaliser votre alchimie :
  #    * nombre de niveaux d'alchimiste
  #    * exp pour chaque niveau d'alchimiste
  #    * nombre de niveaux de recettes
  #    * taux de réussite différent pour chaque niveau de recette
  #    * exp gagnée en fonction du niveau de la recette
  #    * exp maximale
  #    * niveau auquel on obtient 99% de réussite pour chaque niveau de recette
  #    * évolution du taux de réussite à chaque niveau gagné.
  #    * taux de réussite maximal
  #    * découpage ou non en catégories
  #    * taux de réussite optimal dès le début
  #
  # Complétez les recettes plus bas.
  #
  # Contient également un sous-menu de statistiques.
  #---------------------------------------------------------
  # Place dans les crédits S\'il vous plait
  # Et bien sût, à placer au-dessus de Main.
  #---------------------------------------------------------
 
  #---------------------------------------------------------
  # Début des modifications :
  # Activez et modifiez ici les caractéristiques du menu d'alchimie.
  #---------------------------------------------------------
 
  def self.classification(type)
    case type
   
    # Classifications :
    # Rajoutez des classifications pour les recettes
    # ' "nom de la catégorie" ' => [ ' id 1 ' , ' id 2 ' , ' id 3 ' ... ],
    # N'oubliez pas les virgules
    # Si vous ne rajoutez aucun catégorie, il n'y en aura pas.
   
    # La catégorie Tout est ajoutée automatiquement
   
    # IMPORTANT :
    # Les catégories s'afficheront dans l'ordre alphabétique, et non dans l'ordre d'insertion
    # La catégorie Tout sera toujours la première
   
    # Des exemples ont déjà été insérés pour mieux montrer le fonctionnement.
   
    when 1
      return {
      "none" => []
      # Classification des objets :
 
      # Fin de la classification
      }
    when 2
      return {
      "none" => [],
      # Classification des armes :
      "Epées" => [],
      "Lances" => [],
      "Dagues" => [],
      "Haches" => [],
      "Griffes" => [],
      "Marteaux" => [],
      "Baguettes" => [],
      "Armes à feu" => [],
      "Arcs" => [],
      "Boomerangs" => [],
      "Autres" => []
      # Fin de la classification
      }
    when 3
      return {
      "none" => [],
      # Classification des équipements :
      "Casques" => [],
      "Armures" => [],
      "Ceintures" => [],
      "Bottes" => [],
      "Anneaux" => [],
      "Accessoires" => [],
      "Boucliers" => []
      # Fin de la classification
      }
    end
  end
 
  UNLOCKED = [[
  # Mettez ici les recettes débloquées dès le début.
  # Ces recettes peuvent être oubliéres avec $game_party.forget_recette
  # N'oubliez pas les virgules
  # Recettes d'items :
 
  # Fin
  ],[
  # Recettes d'armes :
 
  # Fin
  ],[
  # Recettes d'équipements :
 
  # Fin
  ]]
 
  # Si vous mettez true, toutes les recettes seront toujours débloquées
  # Elles ne pourront pas non plus être oubliées avec $game_party.forget_recette
  ALL_UNLOCKED = false
 
  EXP_LIST = [0,
  # Modifiez l'EXP correspondant aux niveaux d'alchimiste
  # N'oubliez pas de laisser le 0 au début et celui à la fin
  # N'oubliez pas les virgules
  # Le nombre de niveaux correspond au nombre de données, moins 1
  40,95,160,245,345,480,645,845,1085,1400,1790,2265,2825,3550,4450,5535,6815,8300,10000, # <-- Modifiez ici
  # Il y a 20 niveaux d'alchimiste par défaut
  0]
 
  EXP_RECETTE = [0,
  # Modifiez l'EXP accordée en fonction du niveau de la recette
  # N'oubliez pas de laisser le 0 au début
  # N'oubliez pas les virgules
  # Le niveau maximal qui pourra être accordé plus bas à une recette correspond au nombre de données, moins 1
  10,20,40,80,160 # <-- Modifiez ici
  # Il y a 5 niveaux de recettes par défaut
  ]
 
  # Changez ici la valeur maximale d'EXP
  EXP_MAX = 99999
 
  # Si vous mettez true, tous les taux de réussite seront à 100% dès le début
  TAUX_OPTIMAL = false
 
  # Modifiez ici la valeur maximale que peut prendre le taux de réussite (en %)
  # Mais quelque soit ce nombre, le taux ne pourra pas dépasser 100 % (pas la peine de mettre 999 %, ça affichera 100
  # tout de même)
  TAUX_RECETTE_MAX = 99
 
  TAUX_RECETTE = [0,
  # Modifiez ici le taux de réussite de base pour chaque niveau.
  # Le nombre de données doit être égal au nombre de données rentrées dans EXP_RECETTE
  # N'oubliez pas les virgules
  80,75,70,65,60 # <-- Modifiez ici
  # Le taux est bien sûr exprimé en %
  ]
 
  TAUX_MAX = [0,
  # Modifiez ici le niveau auquel le taux de réussite passe au TAUX_RECETTE_MAX, pour chaque niveau de recette
  # N'oubliez pas les virgules
  11,13,16,18,99
  # Placez tout à 99 pour enlever l'option
  ]
 
  # Si vous mettez ' true ' , tous les niveaux seront mis au TAUX_RECETTE_MAX de réussite une fois le niveau maximal atteint
  TAUX_LEVEL_MAX = true
 
  # Changer la valeur correspondant au gain de taux à chaque level-up
  TAUX_UPGRADE = 2
 
    def self.recette(type, id)
      case type
     
        # Recettes :
        # ' id de l'item ' ; recette = Alchimie::REC.new( ' niveau ', [' ingredient 1' , ' ingredient 2' , ' ingredient 3'  ... ])
        # Les 2 premiers paramètres sont obligatoires
        # Les recettes sont prévues pour recevoir jusqu'à 4 ingrédients. Vous pouvez en mettre beaucoup plus, mais
        # l'affichage sera défaillant (les derniers ingrédients ne s'afficheront pas car ils seront en dehors de la
        # fenêtre.
       
        # Ingredients ;
        # [ ' type '  (1 = objet / 2 = arme / 3 = équipement), ' id' , ' nombre ']
        # Les 2 premiers paramètres sont obligatoires.
        # Si ' nombre ' n'est pas spécifié, vaut 1
       
        # exemple :
        # when 36 ; recette = Alchimie::REC.new(3,[[1,6,2],[3,1]])
       
      when 1
        case id
        # liste des recettes d'items
        when 1 ; recette = Alchimie::REC.new(1 , [[ 1 , 2 , 1 ]])
        when 2 ; recette = Alchimie::REC.new(1 , [[ 1 , 1 , 2 ]])
        when 3 ; recette = Alchimie::REC.new(1 , [[ 1 , 2 , 2 ]])
         
        # fin de la liste
        else
          return nil
        end
      when 2
        case id
        # liste des recettes d'armes[
        when 2 ; recette = Alchimie::REC.new(1 , [[ 1 , 1 , 1 ]])
       
        # fin de la liste
        else
          return nil
        end
      when 3
        case id
        # liste des recettes d'équipements
        when 1 ;  recette = Alchimie::REC.new(1 , [[ 1 , 1 , 1 ]])
       
        # fin de la liste
        else
          return nil
        end
      end
    return recette
  end
 
  #---------------------------------------------------------
  # Fin des modifications
  #---------------------------------------------------------
 
  def self.exist?(type, id)
    return false if self.recette(type, id) == nil
    return true
  end
 
  def self.unlocked?(type, id)
    return true if Alchimie::ALL_UNLOCKED
    return false unless self.exist?(type, id)
    return false unless $game_party.recettes[type - 1].include?(id)
    return true
  end
 
  # La classe attribuée aux recettes
  # Permet de simplifier la lecture des données
 
class REC
 
  def initialize(lvl, ingredients)
    @niveau = lvl
    @ingredients = []
    for ing in ingredients
    ing.push(1) if ing.size == 2
    @ingredients.push(ing)
    end
    @ingredients = @ingredients.compact
  end
 
  def lvl
    return @niveau
  end
 
  def exp
    return Alchimie::EXP_RECETTE[@niveau]
  end
 
  def ing
    return @ingredients
  end
 
  def ing_size
    return @ingredients.size
  end
 
  def ing_type
    result = []
    for ing in @ingredients
      result.push(ing[0])
    end
    return result.compact
  end
 
  def ing_id
    result = []
    for ing in @ingredients
      result.push(ing[1])
    end
    return result.compact
  end
 
  def ing_num
    result = []
    for ing in @ingredients
      result.push(ing[2])
    end
    return result.compact
  end
 
  def draw_level
    result = ""
    for i in 1..@niveau
      result += "*"
    end
    return result
  end
end
end
 
# Modification de Game_Party
# Enregistre les recettes débloquées, le niveau d'alchimie, l'expérience, le nombre de recettes réussies, celui de recettes
# echouées, le taux actuel pour chaque niveau de recette ainsi que le nom du dernier objet créé.
 
class Game_Party < Game_Unit
 
  alias initialize_for_alchimie initialize
 
  attr_accessor :recettes
  attr_accessor :niv_alchi
  attr_accessor :exp_alchi
  attr_accessor :reussi_alchi
  attr_accessor :echoue_alchi
  attr_accessor :taux_achi
  attr_accessor :last_alchi
 
  def initialize
    initialize_for_alchimie
    @recettes = Alchimie::UNLOCKED
    @niv_alchi = 1
    @exp_alchi = 0
    @reussi_alchi = 0
    @echoue_alchi = 0
    @taux_alchi = Alchimie::TAUX_RECETTE
    if Alchimie::TAUX_OPTIMAL
      for i in 0..(@taux_alchi.size - 1)
        @taux_alchi[i] = 100
      end
    end
    @last_alchi = "-"
  end
 
  def up_taux_alchi
    for i in 1..5
      @taux_alchi[i] = [@taux_alchi[i] + Alchimie::TAUX_UPGRADE, Alchimie::TAUX_RECETTE_MAX].min
    end
    if Alchimie::TAUX_MAX.include?(@niv_alchi)
      @taux_alchi[Alchimie::TAUX_MAX.index(@niv_alchi)] = Alchimie::TAUX_RECETTE_MAX
    end
  end
 
  def next_level_alchi
    return Alchimie::EXP_LIST[@niv_alchi]
  end
 
  def recette_result(reussi)
    if reussi
      @reussi_alchi += 1
    else
      @echoue_alchi += 1
    end
  end
 
  def gain_exp_alchi(value)
    value = 0 - value if value < 0 
    @exp_alchi += value
    @exp_alchi = [[0,@exp_alchi].max, Alchimie::EXP_MAX].min
    if @exp_alchi >= next_level_alchi and @niv_alchi < (Alchimie::EXP_LIST.size - 1)
      level_up_alchi
    end
  end
 
  def level_up_alchi
    @niv_alchi += 1
    up_taux_alchi unless Alchimie::TAUX_OPTIMAL
  end
 
  def learn_recette(type, id)
    if id.is_a? (Integer)
      @recettes[type - 1].push(id) unless @recettes[type - 1].include?(id)
    elsif id.is_a? (Array)
      for n in id
        @recettes[type - 1].push(n) unless @recettes[type - 1].include?(n)
      end
    end
  end
 
  def forget_recette(type, id)
    if id.is_a? (Integer)
      @recettes[type - 1].delete(id)
    elsif number.is_a? (Array)
      for n in id
        @recettes[type - 1].delete(n)
      end
    end
  end
end
 
class Window_Alchi_A < Window_Base
 
  def initialize(x, y, text_up, text_down, text_index)
    @text_down = text_down
    @text_up = text_up
    @text_index = text_index
    super(144 - 3 * WLH + x, 135 + 3 * WLH + y, 272 + 3 * WLH, 32 + 2 * WLH)
    self.contents = Bitmap.new(width - 32, height - 32)
    refresh(@text_index)
  end
 
  def refresh(text_index)
    self.contents.clear
    self.contents.draw_text(4, -16, 200 + 3 * WLH, WLH + 32, @text_up)
    self.contents.draw_text(4, -16 + WLH, 228 + 3 * WLH, WLH + 32, @text_down[text_index])
  end
end
 
class Scene_Base
 
  def create_real_background(sprite_color_a, sprite_color_b, sprite_color_c, sprite_alpha)
    @menuback_sprite = Sprite.new
    @menuback_sprite.bitmap = $game_temp.background_bitmap
    @menuback_sprite.color.set(sprite_color_a, sprite_color_b, sprite_color_c, sprite_alpha)
    update_menu_background
  end
end
 
class Scene_Alchimie < Scene_Base
 
  def initialize(no_craft = false)
    $no_craft = no_craft
  else
 
  def start
    create_real_background(16,16,16,64)
    @select_window = Window_Command.new(227, [
    "Créer un objet",
    "Créer une arme",
    "Créer un équipement",
    "Statistiques"])
    @select_window.x = 210
    @select_window.y = 100
    @text_down = [
    "Fabrique des objets et des potions.",
    "Forge des armes vraiment puissantes !",
    "Crée tes propres bijoux et armures. ",
    "Regarde tes statistiques d'alchimie."
    ]
    @text_up = "Sélectionne la catégorie que tu veux :"
    @under_window = Window_Alchi_A.new(20, 20, @text_up, @text_down, @select_window.index)
    @window_chaudron = Window_Base.new(92, 100, 118, 128)
    @window_chaudron.contents.blt(0, 0, Cache.picture("Chaudron"), Rect.new(0, 0, 200, 200))
  end
 
  def update
    update_menu_background
    @window_chaudron.update
    @select_window.update
    @under_window.refresh(@select_window.index)
    if Input.trigger? (Input::C)
      Sound.play_decision
      case @select_window.index
      when 0
        if Alchimie.classification(1).size < 2
          $scene = Scene_Alchimie_Selection_Objet.new(1)
        else
          $scene = Scene_Alchimie_Selection_Categorie.new(1)
        end
      when 1
        if Alchimie.classification(2).size < 2
          $scene = Scene_Alchimie_Selection_Objet.new(2)
        else
          $scene = Scene_Alchimie_Selection_Categorie.new(2)
        end
      when 2
        if Alchimie.classification(3).size < 2
          $scene = Scene_Alchimie_Selection_Objet.new(3)
        else
          $scene = Scene_Alchimie_Selection_Categorie.new(3)
        end
      when 3
        $scene = Scene_Alchimie_Statistiques.new
      end
    elsif Input.trigger?(Input::B)
      Sound.play_cancel
      $scene = Scene_Map.new
    end
  end
 
  def terminate
    dispose_menu_background
    @window_chaudron.dispose
    @select_window.dispose
    @under_window.dispose
  end
end
 
class Scene_Alchimie_Selection_Objet < Scene_Base
 
  def initialize(type, categorie = "none")
    case type
    when 1
      @array_item_id = []
      for item in $data_items
        @array_item_id.push(item.id) if (Alchimie.exist?(1, item.id)) and (categorie == "none" or categorie == "Tout" or Alchimie.classification(1)[categorie].include? (item.id))
      end
      @array_item_id = @array_item_id.compact
      @array_item_name = []
      for id in @array_item_id
        if Alchimie.unlocked?(1, id)
          @array_item_name.push($data_items[id].name)
        else
          @array_item_name.push("??????")
        end
      end
    when 2
      @array_item_id = []
      for item in $data_weapons
        @array_item_id.push(item.id) if (Alchimie.exist?(2, item.id)) and (categorie == "none" or categorie == "Tout" or Alchimie.classification(2)[categorie].include? (item.id))
      end
      @array_item_id = @array_item_id.compact
      @array_item_name = []
      for id in @array_item_id
        if Alchimie.unlocked?(2, id)
          @array_item_name.push($data_weapons[id].name)
        else
          @array_item_name.push("??????")
        end
      end
    when 3
      @array_item_id = []
      for item in $data_armors
        @array_item_id.push(item.id) if (Alchimie.exist?(3, item.id)) and (categorie == "none" or categorie == "Tout" or Alchimie.classification(3)[categorie].include? (item.id))
      end
      @array_item_id = @array_item_id.compact
      @array_item_name = []
      for id in @array_item_id
        if Alchimie.unlocked?(3, id)
          @array_item_name.push($data_armors[id].name)
        else
          @array_item_name.push("??????")
        end
      end
    end
    @array_item_name = @array_item_name.compact
    @type = type
    @categorie = categorie
  end
 
  def start
    create_real_background(16,16,16,64)
    @title_window = Window_Base.new(100, 70, 320, 56)
    @title_window.contents.draw_text(16, 0, 320, 24, "Sélectionne l'objet à créer :")
    @select_window = Window_Command.new(320, @array_item_name, 2, 8, 32)
    @select_window.x = 100
    @select_window.y = 126
  end
 
  def update
    update_menu_background
    @title_window.update
    @select_window.update
    if Input.trigger?(Input::C)
      if @array_item_name[@select_window.index] == "??????"
        Sound.play_buzzer
      else
        Sound.play_decision
        $scene = Scene_Alchimie_Craft.new(@array_item_id, @select_window.index, @type, @categorie)
      end
    elsif Input.trigger?(Input::B)
      Sound.play_cancel
      if @categorie == "none"
        $scene = Scene_Alchimie.new
      else
        $scene = Scene_Alchimie_Selection_Categorie.new(@type)
      end
    end
  end
 
  def terminate
    @title_window.contents.dispose
    @title_window.dispose
    @select_window.dispose
  end
end
 
class Scene_Alchimie_Selection_Categorie < Scene_Base
 
  def initialize(type)
    @array_names = ["Tout"]
    Alchimie.classification(type).keys.sort!.each do |key|
      @array_names.push(key) unless key == "none"
    end
    @type = type
  end
 
  def start
    create_real_background(16,16,16,64)
    @title_window = Window_Base.new(100, 70, 320, 56)
    @title_window.contents.draw_text(16, 0, 320, 24, "Sélectionne une catégorie :")
    @select_window = Window_Command.new(320, @array_names, 2, 8, 32)
    @select_window.x = 100
    @select_window.y = 126
  end
 
  def update
    update_menu_background
    @title_window.update
    @select_window.update
    if Input.trigger?(Input::C)
      Sound.play_decision
      $scene = Scene_Alchimie_Selection_Objet.new(@type, @array_names[@select_window.index])
    elsif Input.trigger?(Input::B)
      Sound.play_cancel
      $scene = Scene_Alchimie.new
    end
  end
 
  def terminate
    @title_window.contents.dispose
    @title_window.dispose
    @select_window.dispose
  end
end
 
class Scene_Alchimie_Craft < Scene_Base
 
  def initialize(items, index, type, categorie = "none")
    @reussi = false
    @array_item_id = items
    @index = index
    @type = type
    @categorie = categorie
    @id = @array_item_id[@index]
    case @type
    when 1
      @item = $data_items[@id]
    when 2
      @item = $data_weapons[@id]
    when 3
      @item = $data_armors[@id]
    end
    @recette = Alchimie.recette(@type, @id)
  end
 
  def start
    create_real_background(16,16,16,64)
    @texte = [""]
    for i in 0..(@recette.ing_size - 1)
      @texte[i] = @recette.ing_num[i].to_s
      @texte[i].concat(" x ")
      case @recette.ing_type[i]
      when 1
        @texte[i] += $data_items[@recette.ing_id[i]].name
        @texte[i] += " ("
        @texte[i] += $game_party.item_number($data_items[@recette.ing_id[i]]).to_s
        @texte[i] += ")"
      when 2
        @texte[i] += $data_weapons[@recette.ing_id[i]].name
        @texte[i] += " ("
        @texte[i] += $game_party.item_number($data_weapons[@recette.ing_id[i]]).to_s
        @texte[i] += ")"
      when 3
        @texte[i] += $data_armors[@recette.ing_id[i]].name
        @texte[i] += " ("
        @texte[i] += $game_party.item_number($data_armors[@recette.ing_id[i]]).to_s
        @texte[i] += ")"
      end
    end
    @window_chaudron = Window_Base.new(100, 70, 120, 120)
    @window_chaudron.contents.blt(0, 0, Cache.picture("Chaudron"), Rect.new(0, 0, 200, 200))
    @recette_window = Window_Base.new(100, 190, 340, 160)
    for i in 0..(@texte.size - 1)
      break if @texte[i].empty?
      @recette_window.contents.draw_text(0, i * 24, 340, 24, @texte[i])
    end
    if possible? and not $no_craft
      @text_s = "Créer ! ("
      @text_s.concat([$game_party.taux_alchi[@recette.lvl], 100].min.to_s)
      @text_s.concat("%)")
      @recette_window.contents.draw_text(0, 96, 320, 24, @text_s, 1)
    end
    @item_window = Window_Base.new(220, 70, 220, 120)
    @item_window.contents.draw_text(28, 0, 240, 24, @item.name)
    @item_window.contents.draw_text(0, 32, 240, 24, "Niveau : " + @recette.draw_level)
    bitmap = Cache.system("Iconset")
    src_rect = Rect.new(@item.icon_index % 16 * 24, @item.icon_index / 16 * 24, 24, 24)
    @item_window.contents.blt(0, 0, bitmap, src_rect)
  end
 
  def update
    update_menu_background
    @recette_window.update
    @window_chaudron.update
    @item_window.update
    if Input.trigger?(Input::C)
      if possible? and not $no_craft
        Sound.play_decision
        create_item
      else
        Sound.play_buzzer
      end
    elsif Input.trigger?(Input::B)
      Sound.play_cancel
      $scene = Scene_Alchimie_Selection_Objet.new(@type, @categorie)
    elsif Input.press?(Input::L) or Input.press?(Input::UP) or Input.press?(Input::LEFT)
      Sound.play_cursor
      act = @id
      loop do
        if @index > 0
          @index -= 1
        else
          @index = @array_item_id.size - 1
        end
        break if act == @array_item_id[@index]
        break if Alchimie.unlocked?(@type, @array_item_id[@index])
      end
      $scene = Scene_Alchimie_Craft.new(@array_item_id, @index, @type, @categorie)
    elsif Input.press?(Input::R) or Input.press?(Input::DOWN) or Input.press?(Input::RIGHT)
      Sound.play_cursor
      act = @id
      loop do
        if @index < @array_item_id.size - 1
          @index += 1
        else
          @index = 0
        end
        break if act == @array_item_id[@index]
        break if Alchimie.unlocked?(@type, @array_item_id[@index])
      end
      $scene = Scene_Alchimie_Craft.new(@array_item_id, @index, @type, @categorie)
    end
  end
 
  def possible?
    unless Alchimie.unlocked? (@type, @id)
      return false
    else
      for i in 0..(@recette.ing_size - 1)
        case @recette.ing_type[i]
        when 1
          if @recette.ing_num[i] > $game_party.item_number($data_items[@recette.ing_id[i]])
            return false
          end
        when 2
          if @recette.ing_num[i] > $game_party.item_number($data_weapons[@recette.ing_id[i]])
            return false
          end
        when 3
          if @recette.ing_num[i] > $game_party.item_number($data_armors[@recette.ing_id[i]])
            return false
          end
        end
      end
    return true
    end
  end
 
  def create_item
    actual = $game_party.niv_alchi
    for i in 0..@recette.ing_size
      case @recette.ing_type[i]
      when 1
        $game_party.lose_item($data_items[@recette.ing_id[i]], @recette.ing_num[i])
      when 2
        $game_party.lose_item($data_weapons[@recette.ing_id[i]], @recette.ing_num[i])
      when 3
        $game_party.lose_item($data_armors[@recette.ing_id[i]], @recette.ing_num[i])
      end
    end
    if rand(100) <= [$game_party.taux_alchi[@recette.lvl], 100].min
      @reussi = true
    end
    final_text = recette_result
    @recette_window.contents.clear
    for i in 0..3
      break if @texte[i].empty?
      @recette_window.contents.draw_text(0, i * 24, 340, 24, @texte[i])
    end
    @recette_window.contents.draw_text(0, 84, 300, 24, final_text)
    Graphics.wait(50)
    if actual < $game_party.niv_alchi
      @recette_window.contents.clear
      @recette_window.contents.draw_text(0, 0, 300, 24, "Vous passez au niveau " + $game_party.niv_alchi.to_s + " !")
      @recette_window.contents.draw_text(0, 28, 300, 24, "Le taux de réussite augmente de 2 % !")
      for i in 1..4
        if $game_party.niv_alchi == Alchimie::TAUX_MAX[i]
          @recette_window.contents.draw_text(0, 56, 300, 24, "Vous maîtrisez les recettes de niveau " + i.to_s + " !")
        end
      end
      if $game_party.niv_alchi == (Alchimie::EXP_LIST.size - 1) and Alchimie::TAUX_LEVEL_MAX == true
        @recette_window.contents.draw_text(0, 56, 300, 24, "Vous maîtrisez à présent toutes les recettes !")
      end
    end
    Graphics.wait(50)
    $scene = Scene_Alchimie_Craft.new(@array_item_id, @index, @type, @categorie)
  end
 
  def recette_result
    $game_party.last_alchi = @item.name
    $game_party.recette_result(@reussi)
    if @reussi
      $game_party.gain_item(@item, 1)
      $game_party.gain_exp_alchi(@recette.exp)
      text = "Vous avez gagné un(e) "
      text.concat(@item.name)
      text.concat(" !")
    else
      $game_party.gain_exp_alchi(@recette.exp / 2)
      text = "Zut ! La recette a échoué !"
    end
    return text
  end
   
  def terminate
    @window_chaudron.dispose
    @recette_window.dispose
    @item_window.dispose
  end
end
end
 
class Scene_Alchimie_Statistiques < Scene_Base
 
  def start
    create_real_background(16, 16, 16, 64)
    @stats_window = Window_Base.new(80, 64, 340, 280)
    @lvl = $game_party.niv_alchi
    @stats_window.contents.draw_text(0, 0, 300, 24, "*** ALCHIMISTE : NIVEAU " + @lvl.to_s + " ***", 1)
    @stats_window.contents.draw_text(0, 40, 240, 24, "EXP actuelle :")
    @exp = $game_party.exp_alchi
    @stats_window.contents.draw_text(180, 40, 120, 24, @exp.to_s, 2)
    @stats_window.contents.draw_text(0, 72, 240, 24, "Prochain niveau :")
    @next = ($game_party.next_level_alchi - @exp).to_s
    @next = "-" if @lvl == 20
    @stats_window.contents.draw_text(180, 72, 120, 24, @next, 2)
    @stats_window.contents.draw_text(0, 112, 240, 24, "Recettes tentées :")
    @reussi = $game_party.reussi_alchi
    @echoue = $game_party.echoue_alchi
    @total = (@echoue + @reussi).to_s
    @stats_window.contents.draw_text(180, 112, 120, 24, @total, 2)
    @stats_window.contents.draw_text(0, 144, 240, 24, " * Réussies :")
    @stats_window.contents.draw_text(180, 144, 120, 24, @reussi.to_s, 2)
    @stats_window.contents.draw_text(0, 176, 240, 24, " * Echouées :")
    @stats_window.contents.draw_text(180, 176, 120, 24, @echoue.to_s, 2)
    @last = $game_party.last_alchi
    @stats_window.contents.draw_text(0, 216, 240, 24, "Dernière recette :")
    @stats_window.contents.draw_text(180, 216, 120, 24, @last, 2)
  end
 
  def update
    update_menu_background
    @stats_window.update
    if Input.trigger?(Input::B) or Input.trigger?(Input::C)
      Sound.play_cancel
      $scene = Scene_Alchimie.new
    end
  end
 
  def terminate
    @stats_window.dispose
  end
end