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

Auteur : Tonyryu
Logiciel : RPG Maker VX Ace
Nombre de scripts : 1
Source : https://web.archive.org/web/20190701072732/http://www.tonyryudev.com/joomla3/index.php/menu-mes-developpements/menu-script-rpgmaker/45-vx-ace-gestion-alchimie-simplifiee et https://www.rpgmakervx-fr.com/t12959-gestion-alchimie-simplifiee#155277
Script rajouté avec l'autorisation de l'auteur.

Installation
A placer au-dessus de Main.

Instructions
Pour paramétrer une recette, il suffit de simplement ajouter la liste des ingrédients dans la note d'un objet, en englobant cette liste dans une format reconnaissable par le programme.

Trés souvent, il n'y a rien de noté dans les notes, je vais maintenant, lui définir une recette :
\AL[2I17,1I18]

Il est vrai qu'a première vue, c'est pas très parlant, on va donc décomposer le paramétrage de la recette :
\AL[] : permet de préciser que le contenu est du paramétrage pour alchimie
2I17 : 2 "I"tem ID 17
2I18 : 2 "I"tem ID 18

Si vous souhaitez spécifier plusieurs recettes pour un même objet, il suffit de séparer les différentes recettes par un ;
exemple :
\AL[2I17,1I18;1I7,1I18]
Ce qui équivaut à une recette avec 2I17,1I18, et une recette avec 1I7,1I18

Pour utiliser des ingrédients de type Armes, il faudra utiliser la lettre W, et pour utiliser les armures, la lettre A

L'intégration dans le menu est automatisée depuis la version 1.03, si la constante DANS_LE_MENU vaut true

Pour ouvrir l'alchimie depuis un PNJ, ajouter cette commande script dans l'événement :
1	SceneManager.call(Scene_Alchimie)
La constante TOUT_AFFICHER, permet d'afficher ou non les recettes si l'on contient l'un des ingrédients, les valeurs possibles sont true ou false
    #==============================================================================
    # ■ Systeme de gestion d'alchimie simplifiée
    #------------------------------------------------------------------------------
    #  Ce script a pour but d'ajouter un système d'alchimie très simple d'utilisation
    #
    #  Version  Date          Auteur        Commentaires
    #  1.00      06/09/2012    Tonyryu      Première release
    #  1.01      07/09/2012    Tonyryu      Modification pour prendre en charge le parametrage sur la note et non la description
    #  1.02      07/09/2012    Tonyryu      Changement de position de la fenêtre d'aide
    #  1.03      08/09/2012    Tonyryu      Intégration au menu
    #  1.04      08/09/2012    Tonyryu      Suppression du bug si pas d'objet craftable
    #  1.05      08/09/2012    Tonyryu      Correction du bug non desactivation des objets n'ayant plus assez de composants
    #  1.06      19/09/2012    Tonyryu      Ajout de l'option pour afficher ou non tout la liste même si aucun ingrédients n'est possédé
    #  1.07      23/09/2012    Tonyryu      Ajout de la possibilité de spécifier plusieurs recettes pour un même objet / Ajout d'une constante pour choisir de l'ajouter dans le menu
    #  1.08      12/03/2013    Tonyryu      Correction du bug de non-dégrisage d'une recette disponible suite à un craft d'un de ces ingrédients / sauvegarde postionnement curseur
    #
    # Attention : Ce script est ma propriété en tant que création et il est donc
    # soumis au droit de la propriété intellectuelle.
    # En aucun cas, il ne doit être copié ou publié vers un autre forum sans en
    # avoir reçu mon accord au préalable.
    #
    #==============================================================================
 
    # Constante
    ALCHIMIE = "Alchimie"
    TOUT_AFFICHER = true
    DANS_LE_MENU = true
 
 
    #==============================================================================
    # ** RPG::BaseItem
    #------------------------------------------------------------------------------
    #  class RPG::BaseItem
    #==============================================================================
    class RPG::BaseItem
      def note(pAlchimie = false)
        r_note = @note.clone
        r_alchi = ""
       
        r_note.gsub!(/\\/) { "\e" }
        r_note.gsub!(/\e\e/) { "\\" }
        r_note.gsub!(/\eAL\[(.*)\]/i) do
          r_alchi = $1
          ""
        end
        return (pAlchimie ? r_alchi : r_note)
      end
    end
 
 
    #==============================================================================
    # ** Window_ItemCategory_Al
    #------------------------------------------------------------------------------
    #  This window is for selecting a category of normal items and equipment
    # on the item screen or shop screen.
    #==============================================================================
    class Window_ItemCategory_Al < Window_Command
      #--------------------------------------------------------------------------
      # * Object Initialization
      #--------------------------------------------------------------------------
      def initialize(pY)
        super(0, pY)
      end
     
      #--------------------------------------------------------------------------
      # * Get Window Width
      #--------------------------------------------------------------------------
      def window_width
        return 200
      end
     
      #--------------------------------------------------------------------------
      # * Get Digit Count
      #--------------------------------------------------------------------------
      def col_max
        return 1
      end
 
      #--------------------------------------------------------------------------
      # * Create Command List
      #--------------------------------------------------------------------------
      def make_command_list
        add_command(Vocab::item,    :item)
        add_command(Vocab::weapon,  :weapon)
        add_command(Vocab::armor,    :armor)
        add_command(Vocab::key_item, :key_item)
      end
      #--------------------------------------------------------------------------
      # * Frame Update
      #--------------------------------------------------------------------------
      def update
        super
        @item_window.category = current_symbol if @item_window
      end
      #--------------------------------------------------------------------------
      # * Set Item Window
      #--------------------------------------------------------------------------
      def item_window=(item_window)
        @item_window = item_window
        update
      end
    end
 
 
    #==============================================================================
    # ** Window_ItemList_Al
    #------------------------------------------------------------------------------
    #  This window displays a list of recipe items on the Alchimie screen.
    #==============================================================================
    class Window_ItemList_Al < Window_Selectable
      #--------------------------------------------------------------------------
      # * Object Initialization
      #--------------------------------------------------------------------------
      def initialize(x, y, width, height)
        super
        @category = :none
        @data = []
        @save_index = 0
      end
     
      #--------------------------------------------------------------------------
      # * Set Category
      #--------------------------------------------------------------------------
      def category=(category)
        return if @category == category
        @category = category
        make_item_list
        refresh
        self.oy = 0
      end
      #--------------------------------------------------------------------------
      # * Get Digit Count
      #--------------------------------------------------------------------------
      def col_max
        return 1
      end
      #--------------------------------------------------------------------------
      # * Get Number of Items
      #--------------------------------------------------------------------------
      def item_max
        @data ? @data.size : 0
      end
      #--------------------------------------------------------------------------
      # * Get Item
      #--------------------------------------------------------------------------
      def item
        @data && index >= 0 ? @data[index] : nil
      end
      #--------------------------------------------------------------------------
      # * Get Activation State of Selection Item
      #--------------------------------------------------------------------------
      def current_item_enabled?
        (@data[index] ? @data[index][1] : false)
      end
 
      #--------------------------------------------------------------------------
      # * Create Item List
      #--------------------------------------------------------------------------
      def make_item_list
        @data.clear
        # parcourir la liste des item de la catégories
        case @category
        when :item
          tabItem = $data_items
        when :weapon
          tabItem = $data_weapons
        when :armor
          tabItem = $data_armors
        when :key_item
          tabItem = $data_items
        else
          tabItem = []
        end
       
        tabItem.each do |item|
          if item
            validItem = true
            if @category == :item
              validItem = !item.key_item?
            elsif @category == :key_item
              validItem = item.key_item?
            end
           
            if validItem and item.note(true) != ""
             
 
             
              recipe = item.note(true)
             
              listRecipe = recipe.split(';')
              listRecipe.each do |aListRecipe|
             
              tabRecipe = aListRecipe.split(',')
             
                b_r_item = false
                b_valid = true
                tabRecipeFinish = []
             
                tabRecipe.each do |element|
                  number = 0
                  type = ""
                  id = 0
                  r_item = nil
                  element.gsub(/(.*)I(.*)/) do
                    number = $1.to_i
                    id = $2.to_i
                    r_item = $data_items[id]
                  end
                  element.gsub(/(.*)W(.*)/) do
                    number = $1.to_i
                    id = $2.to_i
                    r_item = $data_weapons[id]
                  end
                  element.gsub(/(.*)A(.*)/) do
                    number = $1.to_i
                    id = $2.to_i
                    r_item = $data_armors[id]
                  end
                 
                  tabRecipeFinish.push([r_item, number])
                 
                  r_number = $game_party.item_number(r_item)
                  b_r_item = true if (r_number > 0 or TOUT_AFFICHER)
                  b_valid = false if r_number < number
                end
               
                if b_r_item
                  @data.push([item.clone, b_valid, tabRecipeFinish.clone])
                end
              end
            end
          end
        end
     
      end
      #--------------------------------------------------------------------------
      # * Restore Previous Selection Position
      #--------------------------------------------------------------------------
      def select_last
        select((@data.size == 0 ? nil : (@data.size > @save_index) ? @save_index : @data.size - 1))
      end
      #--------------------------------------------------------------------------
      # * Draw Item
      #--------------------------------------------------------------------------
      def draw_item(index)
 
        recipe = @data[index]
        if recipe
          rect = item_rect(index)
          rect.width -= 4
          draw_item_name(recipe[0], rect.x, rect.y, recipe[1])
        end
 
      end
 
     
      #--------------------------------------------------------------------------
      # * Set Alchi Window
      #--------------------------------------------------------------------------
      def alchi_window=(alchi_window)
        @alchi_window = alchi_window
        update
      end
 
      #--------------------------------------------------------------------------
      # * Refresh
      #--------------------------------------------------------------------------
      def refresh
        create_contents
        draw_all_items
      end
     
      #--------------------------------------------------------------------------
      # * Frame Update
      #--------------------------------------------------------------------------
      def update
        super
        @alchi_window.set_item(@data[index]) if index >= 0
      end
     
      #--------------------------------------------------------------------------
      # * Update Help Text
      #--------------------------------------------------------------------------
      def update_help
        @help_window.set_item(@data[index][0]) if @data[index]
      end
     
      #--------------------------------------------------------------------------
      # * Desactivate
      #--------------------------------------------------------------------------
      def update_data
        @data.each do |recipe|
          valid = true
          recipe[2].each do |ingredient|
            p_number = $game_party.item_number(ingredient[0])
            valid = false if p_number < ingredient[1]
          end
          recipe[1] = valid
        end
        @save_index = index
        refresh
      end
    end
 
 
    #==============================================================================
    # ** Window_Alchimie
    #------------------------------------------------------------------------------
    #  This window shows items detail and recipe
    #==============================================================================
    class Window_Alchimie < Window_Base
      #--------------------------------------------------------------------------
      # * Object Initialization
      #--------------------------------------------------------------------------
      def initialize(pY)
        super(200, pY, Graphics.width - 200, Graphics.height - pY)
        @item = nil
      end
      #--------------------------------------------------------------------------
      # * Set Item
      #--------------------------------------------------------------------------
      def set_item(pItem)
        if pItem != @item
          @item = pItem
          refresh
        end
      end
 
      #--------------------------------------------------------------------------
      # * Refresh
      #--------------------------------------------------------------------------
      def refresh
        clean(false)
        item = @item[0]
       
        change_color(normal_color)
        y = 10
        x = 0
        draw_param(x, y, 2, item)
        draw_param(x, y + line_height, 3, item)
        draw_param(x, y + (line_height * 2), 4, item)
        x = (contents.width / 2)
        draw_param(x, y, 5, item)
        draw_param(x, y + line_height, 6, item)
        draw_param(x, y + (line_height * 2), 7, item)
       
        y = y + (line_height * 3) + 16
       
        contents.fill_rect(0, y, contents.width, 1, Color.new(255,255,255,255))
       
        y += 16
        x = 30
        @item[2].each do | ingredient |
          i_item = ingredient[0]
          i_number = ingredient[1]
          draw_ingredient(x, y, i_item, i_number)
          y += line_height
        end
 
      end
     
      #--------------------------------------------------------------------------
      # * clean
      #--------------------------------------------------------------------------
      def clean(pForce = true)
        contents.clear
        @item = nil if pForce
      end
     
      #--------------------------------------------------------------------------
      # * Draw Param Equip
      #--------------------------------------------------------------------------
      def draw_param(x, y, param_id, item)
        change_color(system_color)
        draw_text(x, y, 90, line_height, Vocab::param(param_id))
        change_color(normal_color)
       
        if item.is_a?(RPG::Weapon) or item.is_a?(RPG::Armor)
          draw_text(x+ 100, y, 32, line_height, item.params[param_id])
        end
      end
     
      #--------------------------------------------------------------------------
      # * Draw Ingredient
      #--------------------------------------------------------------------------
      def draw_ingredient(x, y, item, number)
        p_number = $game_party.item_number(item)
        draw_icon(item.icon_index, x, y, (p_number >= number))
        change_color(normal_color, (p_number >= number))
        draw_text(x + 24, y, 190, line_height, item.name )
        draw_text(x + 220, y, 100, line_height, "#{p_number}/#{number}" )
      end
     
      #--------------------------------------------------------------------------
      # * Draw Number of Items
      #--------------------------------------------------------------------------
      def draw_item_number(rect, item)
        draw_text(rect, sprintf(":%2d", $game_party.item_number(item)), 2)
      end
    end
 
 
 
    #==============================================================================
    # ** Scene_Alchimie
    #------------------------------------------------------------------------------
    #  This Scene performs alchimie
    #==============================================================================
    class Scene_Alchimie < Scene_MenuBase
      #--------------------------------------------------------------------------
      # * Start Processing
      #--------------------------------------------------------------------------
      def start
        super
        create_help_window
        create_category_window
        create_item_window
        create_alchimie_window
      end
     
      #--------------------------------------------------------------------------
      # * Create Category Window
      #--------------------------------------------------------------------------
      def create_category_window
        wy = @help_window.height
        @category_window = Window_ItemCategory_Al.new(wy)
        @category_window.viewport = @viewport
        @category_window.set_handler(:ok,    method(:on_category_ok))
        @category_window.set_handler(:cancel, method(:return_scene))
      end
 
      #--------------------------------------------------------------------------
      # * Create Item Window
      #--------------------------------------------------------------------------
      def create_item_window
        wy = @category_window.height + @help_window.height
        wh = Graphics.height - wy
        @item_window = Window_ItemList_Al.new(0, wy, 200, wh)
        @item_window.viewport = @viewport
        @item_window.set_handler(:ok,    method(:on_item_ok))
        @item_window.set_handler(:cancel, method(:on_item_cancel))
        @category_window.item_window = @item_window
        @item_window.help_window = @help_window
      end
 
      #--------------------------------------------------------------------------
      # * Create Alchimie Window
      #--------------------------------------------------------------------------
      def create_alchimie_window
        wy = @help_window.height
        @alchimie_window = Window_Alchimie.new(wy)
        @alchimie_window.viewport = @viewport
        @item_window.alchi_window = @alchimie_window
      end
     
      #--------------------------------------------------------------------------
      # * Category [OK]
      #--------------------------------------------------------------------------
      def on_category_ok
        if @item_window.item_max > 0
          @item_window.activate
          @item_window.select_last
        else
          @category_window.activate
        end
      end
     
      #--------------------------------------------------------------------------
      # * Item [OK]
      #--------------------------------------------------------------------------
      def on_item_ok
        recipe = @item_window.item
        $game_party.gain_item(recipe[0], 1)
        valid = true
        recipe[2].each do |ingredient|
          $game_party.gain_item(ingredient[0], -ingredient[1])
        end
        @item_window.update_data
        @alchimie_window.refresh
        on_category_ok
      end
      #--------------------------------------------------------------------------
      # * Item [Cancel]
      #--------------------------------------------------------------------------
      def on_item_cancel
        @item_window.unselect
        @category_window.activate
        @alchimie_window.clean
        @help_window.clear
      end
       
    end
 
    #==============================================================================
    # ** Window_MenuCommand
    #------------------------------------------------------------------------------
    #  This command window appears on the menu screen.
    #==============================================================================
    class Window_MenuCommand < Window_Command
     
      #--------------------------------------------------------------------------
      # * add_main_commands
      #--------------------------------------------------------------------------
      alias al_add_main_commands add_main_commands
      def add_main_commands
        al_add_main_commands
        add_command(ALCHIMIE, :alchimie, main_commands_enabled) if DANS_LE_MENU
      end
    end
 
    #==============================================================================
    # ** Scene_Menu
    #------------------------------------------------------------------------------
    #  This class performs the menu screen processing.
    #==============================================================================
    class Scene_Menu < Scene_MenuBase
 
      #--------------------------------------------------------------------------
      # * create_command_window
      #--------------------------------------------------------------------------
      alias al_create_command_window create_command_window
      def create_command_window
        al_create_command_window
        @command_window.set_handler(:alchimie, method(:command_alchimie)) if DANS_LE_MENU
      end
     
      #--------------------------------------------------------------------------
      # * command_alchimie
      #--------------------------------------------------------------------------
      def command_alchimie
        SceneManager.call(Scene_Alchimie)
      end
    end