[RPG-MAKER.FR] Oniromancie: tout l'univers de RPG Maker en français - Scripts

Comme il n'y a pas de script d'alchimie sur le site, je me suis dit que je proposerais bien le mien.

J'ai bien spécifié "exemple" car bien sûr un menu peut être présenté de plein de manières différentes, et qu'un bon scripteur fera sûrement quelque chose de plus beau ou de plus pratique (ou de plus condensé, c'est sûrement possible).
Autrement dit, ce script s'adresse aux scripteurs débutants ou aux non-scripteurs.

Le script peut être personnalisé :
* nombre de niveaux d'alchimiste
* niveau d'exp à atteindre
* exp max
* nombre de niveaux de recettes (en fonction de la difficulté)
* % de réussite en fonction du niveau de la recette (ou taux optimal dès le début)
* évolution de ce % en fonction du niveau d'alchimiste
* % maximal
* exp donnée pour chaque niveau de recette
* création ou non de catégories avant la sélection de l'objet
* données des recettes à entrer directement dans le script aux lignes dédiées (sous forme de when x ; recette)
* possibilité de connaître certaines recettes ou toutes les recettes dès le début
Dispose aussi d'un menu de statistiques.

Comment appeler le script ?
Je ne l'ai pas inséré directement dans le menu du jeu pour éviter toute forme d'incompatibilité.
$scene = Scene_Alchimie.new
Appelle le menu d'alchimie.

$scene = Scene_Alchimie.new(true)
Appelle le menu, mais ne permet pas d'effectuer la recette (on peut juste la voir).

$game_party.learn_recette(type, id de l'objet)
Apprend la recette qui correspond à l'objet.
L'id peut aussi prendre la forme d'un tableau d'id afin d'apprendre plusieurs recettes de même type d'un coup.

$game_party.forget_recette(type, id de l'objet)
Même principe. Je ne sais pas si c'est vraiment utile mais bon, on ne sait jamais.

Pour fonctionner, le script doit obligatoirement être utilisé depuis Nouvelle Partie. Les anciennes sauvegardes pour des tests antérieures ne fonctionneront pas.

Vous devez également créer une image qui doit s'appeler chaudron.png si vous utilisez l'appellation du script par défaut.

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