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

Auteur : Blockade
Logiciel : RPG Maker VX
Nombre de scripts : 1

Fonctionnalités
- Ajoute un menu d'amélioration des armes
- Ajoute un menu de suppression des objets d'amélioration
- Options de durabilité de l'effet sur les armes
- Autres options de configuration.

Installation
A insérer au-dessus de Main.

Utilisation
Toutes les explications et configurations se trouvent en début de script.
Ce script est compatible avec le script de menu Basic Plus de Moghunter.
#===============================================================
# ● [VX] ◦ Enduits pour lames
#--------------------------------------------------------------
# ◦ Par Blockade, d'une requête
# ◦ http://rpg-maker-vx.bbactif.com/forum.htm
# ◦ Crée le 08/03/2009
# ◦ Version 1.1
# ◦ Remerciements à ASKHA, omegazion
#--------------------------------------------------------------
# > Comment créer un enduit :
# Dans la partie commentaire de l'objet dans la base de données, rentrez ces 3 paramètres :
#
#  Bonus= {Le bonus de que va donner l'enduit}
#  Typebonus= {Sur quelle capacitée il va s'appliquer (1-7) (Voir la table en dessous)}
#  Nbcombat=  {Le nombre de combat que ca va durer}
# Note : Pour Nbcombat, si vous voulez qu'il ne s'use pas, mettez 0.
#----------------------------------------------------------------------------
# Table des bonus :
#       Force  = 1                   Précision= 5
#       Defense = 2               Esquive= 6
#       Intelligence= 3           Critique = 7
#       Agilité= 4
#----------------------------------------------------------------------------
# Ensuite indiquez l'ID de l'enduit dans ENDUITS = []
# Et voila l'enduit est prêt !
#===============================================================
 
#===============================================================
#  Notes de version
#---------------------------------------------------------------
# Version 1.0
# > Script initial
#
# Version 1.1
# > Ajout d'une fenêtre de suppression d'enduits
# > Ajout de la personalisation des fenêtres
# > Ajout d'une option d'enduit qui ne s'use pas 
# > Ajustement des textes, et des fenêtres
#
#===============================================================
 
#===============================================================
#  Enduits :: Début du Module de configuration
#===============================================================
module Enduits
#==Informations Système==
 
# Placer ici l'ID des enduits 
ENDUITS = [21,22,23,24,25,26,27,28] 
 
#==========================
# Incorporation dans le menu ?
# Si vous voulez ne pas mettre dans le menu mais
# dans un PNJ par exemple, il suffit de choisir appeller un script puis
# $scene = Scene_Enduits.new
#==========================
Incorpor_menu = true
 
# Le nom de l'option dans le menu :
Nom_menu = "Enduits"
 
# ================================================
# Si utilisation du menu de moghunter : true
# Sinon false
# /!\ Ne marche que si Incorpor_menu = true
# /!\ Pour que ca marche, le script de Moghunter doit être placé au dessus 
#de ce script /!\
#================================================
Menu_moghunter = false
 
 
#==Fin informations Système==
 
#==Personnalisation affichage des armes==
 
#===Dans l'appliquation des enduits===
#================================================
# Afficher les bonus [Force +3] à coté d'une arme par exemple
# true = Activé
# false = Désactivé
#=================================================
Afficher_bonus = true
 
#================================================
#Utiliser des abrévations, pour les Bonus ?
# true = Activé
# false = Désactivé
# /!\ S'apllique uniquement si Afficher_bonus = true
#=================================================
Abrevation = true
 
#=====================================
# Abrévations dans l'affichage des armes
# /!\ Ne pas modifier la premiére colonne /!\
# Ne pas oublier la , en fin de ligne !!
# /!\ S'apllique uniquement si Abrevation = true
#=====================================
Raccourcis = {
"Force" => "For.",
"Defense" => "Def.",
"Intelligence" => "Int.", 
"Agilité" => "Agi.",
"Précision" => "Pré.", 
"Esquive" => "Esq.",
"Critique" => "Cri."
}
 
#==================================================
# Quand un enduit est appliqué quelle couleur ?
# Pour choisir mettre :
# Color.new(rouge, vert, bleu[alpha]) 
#   > Rouge, Vert, Bleu : Ton de couleur Rouge, Vert, Bleu (0-255)
#   > Alpha : Facultatif, c'est la transparence, par defaut 255 (0-255)
# Si vous voulez que rouge mettez 255 dans rouge et 0 dans les autres par exemple
# Jaune clair : 255,255,64
#==================================================
Couleur = Color.new(255, 255, 64) 
 
#==Fin de Personnalisation affichage des armes==
 
#==Personnalisation des fenêtres de confirmation==
#===Fenêtre de confirmation de la pose d'enduits===
#Taille de la fenêtre
Taille_comfirm = 290
 
# Choix 1
Texte_1_comfirm = "Confirmer la pose de l'enduit"
 
# Choix 2
Texte_2_comfirm = "Annuler"
 
#===Fenêtre de confirmation de la suppression d'enduits===
# Activer la suppression ?
Activer_delete = true
 
# Touche d'appel à la fenêtre
Touche_delete = Input::X
 
#Taille de la fenêtre
Taille_delete = 250
 
# Choix 1
Texte_1_delete = "Supprimer l'enduit"
 
# Choix 2
Texte_2_delete = "Annuler"
 
#===Fenêtre en général===
# En cas d'enduit qui s'epuisse pas, texte à afficher
Texte_enduitinfini = "Durée : Ne s'épuise pas"
 
#==Fin Personnalisation des fenêtres de confirmation==
end
#===============================================================
#  Enduits :: Fin du Module de configuration
#===============================================================
 
 
#==============================================================================
# ** Scene_Enduits
#------------------------------------------------------------------------------
#  La scéne principale qui gére le système d'enduits.
#==============================================================================
class Scene_Enduits < Scene_Base
 #--------------------------------------------------------------------------
  # * Lance la scéne
  #--------------------------------------------------------------------------
  def start
    super
    create_command_window
    create_menu_background
  end
  
  #--------------------------------------------------------------------------
  # * Création des fenêtres
  #--------------------------------------------------------------------------
  def create_command_window
    @armes = $game_party.get_weapons
    @enduits = $game_party.get_enduits
    $enduits_appliques = {} if $enduits_appliques.nil? == true
    @enduit_window = Liste_Enduits.new(0,55,272,250,@enduits)
    @arme_window = Liste_Armes.new (272,55,272,250,@armes)
    @arme_window.active = false
    @help_window_bas = Help_window_bas.new(0,305,544,111)
    @help_window = Window_Help.new
    @arme_window.help_window = [@help_window_bas,@help_window]
    @enduit_window.help_window = [@help_window_bas,@help_window]
    @confirm_window = Window_Command.new(Enduits::Taille_comfirm, [Enduits::Texte_1_comfirm,Enduits::Texte_2_comfirm])
    @delete_window = Window_Command.new(Enduits::Taille_delete, [Enduits::Texte_1_delete,Enduits::Texte_2_delete])
    @confirm_window.x = (544 - @confirm_window.width) / 2
    @confirm_window.y = (416 - @confirm_window.height) / 2
    @delete_window.x = (544 - @confirm_window.width) / 2
    @delete_window.y = (416 - @confirm_window.height) / 2
    @confirm_window.active = false
    @confirm_window.visible = false
    @delete_window.active = false
    @delete_window.visible = false
  end
  
  #--------------------------------------------------------------------------
  # * Update
  #--------------------------------------------------------------------------
  def update
    super
    update_menu_background
     @arme_window.update
     @enduit_window.update
     if @confirm_window.visible == true
     @confirm_window.update 
     update_confirm
   end # Fin condition 1
    if @delete_window.visible == true
      @delete_window.update
      update_delete
    end
    if Input.trigger?(Enduits::Touche_delete) and @arme_window.active and @confirm_window.visible != true and @arme_window.arme_sous_enduit? and Enduits::Activer_delete == true
          Sound.play_decision
      @delete_window.visible = true
      @delete_window.active = true
      @arme_window.active = false
    end
    if Input.trigger?(Input::B)
        Sound.play_cancel
      if @arme_window.active == true
        @arme_window.active = false
        @enduit_window.active = true
        @arme_window.index = 0
        @arme_window.index = -1
      else
        Sound.play_cancel
        $scene = Scene_Map.new
      end# Fin @arme_window.active
    elsif Input.trigger?(Input::C)
      @arme_window.refresh
     if @arme_window.active == false and @confirm_window.visible != true and @enduit_window.enduits? != false
        Sound.play_decision
        @arme_window.active = true
        @enduit_window.active = false
        @arme_window.index = 0
      else
         if @arme_window.arme_sous_enduit? ==  true or @enduit_window.enduits? == false or @arme_window.armes? == false
              Sound.play_buzzer
            else
            @confirm_window.visible = true
            @confirm_window.active = true
            @arme_window.active = false
          end # fin @arme_window.arme_sous_enduit? ==  true
        end# fin if @arme_window.active == false and @confirm_window.visible != true
      end # fin if Input.trigger?(Input::B)
    end# fin méthode
 
#--------------------------------------------------------------------------
# * Update la fenêtre de confirmation
#--------------------------------------------------------------------------
    def update_confirm
        if Input.trigger?(Input::C)
            if @confirm_window.index == 0
              Sound.play_decision
              @id_arme = @arme_window.get_id
              @id_enduit = @enduit_window.get_id
              @bonus = @enduit_window.stats[0]
              @type_bonus = @enduit_window.stats[1]
              @nb_combat = @enduit_window.stats[2]
              $enduits_appliques[@id_arme] =  [@id_enduit,@bonus,@type_bonus,@nb_combat]
              @type_bonus = Enduits::Raccourcis[@type_bonus] if  Enduits::Abrevation == true
              $data_weapons[@id_arme].name = $data_weapons[@id_arme].name + ' [' + @type_bonus + " + " + @bonus.to_s + "]" if Enduits::Afficher_bonus == true
              @confirm_window.visible = false
              @arme_window.active = true
              @result =@enduit_window.consume_enduit
               if @result == true
                @arme_window.active = false
                @enduit_window.active = true
                @arme_window.index = 0
                @arme_window.index = -1
              end
              @arme_window.refresh
               Input.update
            else
              Sound.play_cancel
              @arme_window.active = true
              @confirm_window.visible = false
              @confirm_window.active = false
              @confirm_window.index = 0
                Input.update
        end
      end
      if Input.trigger?(Input::B)
          Sound.play_cancel
          @confirm_window.visible = false
          @confirm_window.active = false
          @arme_window.active = true
          @confirm_window.index = 0
            Input.update
      end
    end
    
#--------------------------------------------------------------------------
# * Update la fenêtre de supression
#--------------------------------------------------------------------------
      def update_delete
         if Input.trigger?(Input::C)
            if @delete_window.index == 0
              Sound.play_decision
              @id_arme = @arme_window.get_id
              enduit_applique = $enduits_appliques[@id_arme]
              enduit_applique[2] = Enduits::Raccourcis[enduit_applique[2]] if  Enduits::Abrevation == true
              bonus = " ["+ enduit_applique[2] + " + " + enduit_applique[1] .to_s + "]"
              $data_weapons[@id_arme].name.slice!(bonus)  if Enduits::Afficher_bonus == true
              $enduits_appliques.delete(@id_arme)
              @delete_window.visible = false
              @arme_window.active = true
              @arme_window.refresh
               Input.update
            else
              Sound.play_cancel
              @arme_window.active = true
              @delete_window.visible = false
              @delete_window.active = false
              @delete_window.index = 0
              Input.update
        end
      end
      if Input.trigger?(Input::B)
          Sound.play_cancel
          @confirm_window.visible = false
          @confirm_window.active = false
          @arme_window.active = true
          @confirm_window.index = 0
            Input.update
      end
    end
    
  #--------------------------------------------------------------------------
  # * Effacer les fenêtres en fin d'utilisation
  #--------------------------------------------------------------------------
  def dispose_command_window
    @arme_window.dispose
    @help_window.dispose
    @help_window_bas.dispose
    @enduit_window.dispose
  end
  
    #--------------------------------------------------------------------------
  # * Misa jour du fond
  #--------------------------------------------------------------------------
  def update_menu_background
    super
    @menuback_sprite.tone.set(0, 0, 0, 0)
  end
  
  #--------------------------------------------------------------------------
  # *Fin de la scene
  #--------------------------------------------------------------------------
  def terminate
    super
    dispose_command_window
    dispose_menu_background
  end
end
 
 
 
#==============================================================================
# **Game_Party
#------------------------------------------------------------------------------
#  Obtenir les armes et les enduits de l'inventaire
#==============================================================================
class Game_Party < Game_Unit
  #--------------------------------------------------------------------------
  # * Armes
  #--------------------------------------------------------------------------
  def get_weapons
    @armes = []
    i = 0
    for item in $game_party.items
     if item.is_a?(RPG::Weapon)
        @armes[i] = item
        i += 1
      end
    end
    return @armes
  end 
  
  #--------------------------------------------------------------------------
  # * Enduits
  #--------------------------------------------------------------------------
  def get_enduits
    @enduits = []
        for item in $game_party.items
          for i in 0...Enduits::ENDUITS.size
            if item.id == Enduits::ENDUITS[i] and item.is_a?(RPG::Item)
              @enduits[i] = item
            end
          end
        end
      return @enduits
end
end
 
#==============================================================================
# **Liste_Armes
#------------------------------------------------------------------------------
#  Liste les armes posédées, et les affiche dans une fenêtre
#==============================================================================
class Liste_Armes < Window_Selectable
  #--------------------------------------------------------------------------
  # * Initialize
  #--------------------------------------------------------------------------
  def initialize (x,y,w,h,armes)
    super(x, y, w, h)
    @column_max = 1
    @spacing = 0
    self.index = -1
    @armes = armes
    refresh
  end
  
  #--------------------------------------------------------------------------
  # * Liste les armes et leur ID
  #--------------------------------------------------------------------------
  def refresh
    @data = []
    @data_id = []
    for x in 0...@armes.size
      @data.push(@armes[x])
      @data_id.push(@armes[x].id)
    end
    if @data == []
      @data = "Pas d'armes disponibles"
      @item_max = 1
    else
      @item_max = @data.size
    end
    create_contents
    for i in 0...@item_max
      draw_item(i)
    end
  end
  
  #--------------------------------------------------------------------------
  # * Affiche l'icone et le nom de l'arme
  #--------------------------------------------------------------------------
  def draw_item(index)
    rect = item_rect(index)
    self.contents.clear_rect(rect)
    item = @data[index]
    if item != nil
      rect.width -= 4
      if $enduits_appliques.include?(@data_id[index]) or @data == "Pas d'armes disponibles"
        couleur =  Enduits::Couleur
      else
        couleur = normal_color
      end
      if @data != "Pas d'armes disponibles"
        draw_item_name(item, rect.x, rect.y,utilisable = true ,couleur)
      else
         draw_aucun_enduit(@data)
      end
    end
  end
  
  def draw_aucun_enduit(text)
    self.contents.clear
      self.contents.font.color = normal_color
      self.contents.font.color.alpha = 182
    self.contents.draw_text(0,0,300,WLH,text) 
  end
 
  #--------------------------------------------------------------------------
  # * Contenu des barres d'aide
  #--------------------------------------------------------------------------
  def update_help
   if @data != "Pas d'armes disponibles"
        @help_window[1].set_text($data_weapons[@data_id[self.index]].description, 1)
        if $enduits_appliques.include?(@data_id[self.index])
          @infos = $enduits_appliques[@data_id[self.index]]
          combat = "combats" if @infos[3] > 1
          combat = "combat" if @infos[3] == 0
         if @infos[3] > 0 
          @help_window[0].print_statuts_enduits("Enduit appliqué.","","Effet : " + @infos[2] + " + " + @infos[1].to_s ,
          "Durée : " + @infos[3].to_s + " " + combat)
        else
          @help_window[0].print_statuts_enduits("Enduit appliqué.","","Effet : " + @infos[2] + " + " + @infos[1].to_s ,
          Enduits::Texte_enduitinfini)
        end
        else
          @help_window[0].print_statuts_enduits("","","","","Aucun enduit appliqué à cet arme.")
        end
   else
  @help_window[1].set_text("Aucune arme disponible dans l'inventaire")
  @help_window[0].print_statuts_enduits("","","","","Impossible d'appliquer un enduit.")
    end
end
  
  #--------------------------------------------------------------------------
  # * Obtenir l'ID des armes choisies.
  #--------------------------------------------------------------------------
  def get_id
    return $data_weapons[@data_id[self.index]].id
  end
  
  #--------------------------------------------------------------------------
  # * Savoir si l'arme est sous enduit
  #--------------------------------------------------------------------------
  def arme_sous_enduit?
      if $enduits_appliques.include?(@data_id[index])
        return true
      else
        return false
      end
    end
    
    #--------------------------------------------------------------------------
  # * Savoir si le joueur poséde des armes disponibles
  #--------------------------------------------------------------------------
  def armes?
      if @data != "Pas d'armes disponibles"
      return true
    else
      return false
    end
  end
end # Fin classe
 
#==============================================================================
# **Liste_Enduits
#------------------------------------------------------------------------------
#  Liste les enduits posédés, et les affiche dans une fenêtre
#==============================================================================
class Liste_Enduits < Window_Selectable
  #--------------------------------------------------------------------------
  # * Initialize
  #--------------------------------------------------------------------------
  def initialize (x,y,w,h,enduits)
    super(x, y, w, h)
    @column_max = 1
    @spacing = 0
    self.index = 0
    @enduits = enduits
    refresh
  end
  
  #--------------------------------------------------------------------------
  # * Liste les enduits
  #--------------------------------------------------------------------------
  def refresh
    @data = []
    @data_id = []
    for x in 0...@enduits.size
      if $game_party.item_number(@enduits[x]) != 0
        @data.push(@enduits[x])
        @data_id.push(@enduits[x].id)
      end
    end
      if @data == []
        @data = "Pas d'enduits disponibles"
        @item_max = 1
      else
       @item_max = @data.size
      end
    create_contents
    for i in 0...@item_max
      draw_item(i)
    end
  end
  
  #--------------------------------------------------------------------------
  # * Affiche l'icone et le nom de l'enduit
  #--------------------------------------------------------------------------
  def draw_item(index)
    rect = item_rect(index)
    self.contents.clear_rect(rect)
    item = @data[index]
    if item != nil
      rect.width -= 4
      if @data != "Pas d'enduits disponibles"
        number = $game_party.item_number(item)
        draw_item_name(item, rect.x, rect.y)
        self.contents.draw_text(rect, sprintf(":%2d", number), 2)
      else
        draw_aucun_enduit(@data)
      end
    end
  end
  
  #--------------------------------------------------------------------------
  # * Afficher "Pas d'enduits disponible", si le joueur ne poséde pas d'enduit
  #--------------------------------------------------------------------------
  def draw_aucun_enduit(text)
      self.contents.clear
      self.contents.font.color = normal_color
      self.contents.font.color.alpha = 182
    self.contents.draw_text(0,0,300,WLH,text) 
  end
  
  #--------------------------------------------------------------------------
  # * Contenu de la barre d'aide
  #-------------------------------------------------------------------------- 
   def update_help
    if @data != "Pas d'enduits disponibles"
      @nom =@data[index].name
      @bonus = @data[index].get_info_enduits[0]
      @type_bonus = @data[index].get_info_enduits[1]
      @nb_combat = @data[index].get_info_enduits[2]
      @help_window[0].set_text(@nom,@bonus,@type_bonus,@nb_combat)
      @help_window[1].set_text("Choisisez un enduit.")
    else
      @help_window[1].set_text("Aucun enduit disponible dans l'inventaire.")
    end
  end
  
  #--------------------------------------------------------------------------
  # * Obtenir l'ID d'un enduit
  #--------------------------------------------------------------------------
  def get_id
        return [@data_id[self.index]]
      end
      
  #--------------------------------------------------------------------------
  # * Obtenir le nombre de combat d'un enduit
  #--------------------------------------------------------------------------
  def stats
      return@data[index].get_info_enduits
    end
    
  #--------------------------------------------------------------------------
  # * Savoir si le joueur poséde un enduit
  #--------------------------------------------------------------------------
  def enduits?
      if @data != "Pas d'enduits disponibles"
      return true
    else
      return false
    end
  end
  
  #--------------------------------------------------------------------------
  # * Enduit -1 si utilisé
  #--------------------------------------------------------------------------
  def consume_enduit
    @enduit_nb = $game_party.item_number(@data[self.index])
    $game_party.lose_item(@data[self.index],1)
    refresh
    if @enduit_nb -1  == 0
      @result = true
    else
      @result = false
    end
      return @result
    end
end#fin classe
 
#==============================================================================
# **Help_window_bas
#------------------------------------------------------------------------------
#  Fenêtre d'aide du bas, affiche les caractéristiques des enduits.
#==============================================================================
class Help_window_bas < Window_Base
  #--------------------------------------------------------------------------
  # * Initialize
  #--------------------------------------------------------------------------
  def initialize (x,y,w,h)
    super (x,y,w,h)
  end
  
  #--------------------------------------------------------------------------
  # * Affiche le texte
  #--------------------------------------------------------------------------
  def set_text(nom,bonus,type_bonus, nb_combat)
    self.contents.clear
    self.contents.draw_text(0,0,400,WLH,nom)
    self.contents.draw_text(0,20,400,WLH,"Effet : " + type_bonus +" + " +  bonus.to_s )
    if nb_combat > 0
      combat = " combats" if nb_combat >1
      combat = " combat" if nb_combat == 1 
      self.contents.draw_text(0,55,400,WLH,"Durée : " + nb_combat.to_s + combat)
    else
      self.contents.draw_text(0,55,400,WLH,Enduits::Texte_enduitinfini)
    end
  end
  
  #--------------------------------------------------------------------------
  # * Affiche l'état des enduits.
  #--------------------------------------------------------------------------
  def print_statuts_enduits(ligne1,ligne2,ligne3,ligne4,milieu="")
    self.contents.clear
    self.contents.draw_text(0,0,400,WLH,ligne1)
    self.contents.draw_text(0,20,400,WLH,ligne2)
    self.contents.draw_text(0,35,400,WLH,ligne3)
    self.contents.draw_text(0,55,400,WLH,ligne4)
    self.contents.draw_text(0,25,400,WLH,milieu)
  end
end
 
#==============================================================================
# **String
#------------------------------------------------------------------------------
#  Classe qui gére les objets de type String.
#==============================================================================
class String
  #--------------------------------------------------------------------------
  # * Découpe la note ligne par ligne
  #--------------------------------------------------------------------------
  def decoupe
    bloc = []
    self.split(/[\r\n]+/).each { |line| bloc.push(line) }
    return bloc
  end
end
 
#==============================================================================
# ***RPG
# **BaseItem
#------------------------------------------------------------------------------
#  Module RPG contient toutes les données définies dans la BBD
#  BaseItem defini les propriétées d'un objet.
#==============================================================================
 
module RPG
  class BaseItem
  #--------------------------------------------------------------------------
  # * Récupére les informations contenue dans la note.
  #--------------------------------------------------------------------------
  def get_info_enduits
      text = @note.decoupe
        for line in text
            if line.include?("Bonus=")
              @bonus = line.delete("Bonus=").to_i
            end
            if line.include?("Typebonus=")
                @type_bonus = line.delete("Typebonus=").to_i
           end
            if line.include?("Nbcombat=")
              @nb_combat = line.delete("Nbcombat=").to_i
            end 
          end # Fin For
           @type_bonus = "Force" if @type_bonus == 1
           @type_bonus = "Defense"  if @type_bonus == 2
           @type_bonus = "Intelligence" if @type_bonus == 3
           @type_bonus = "Agilité" if @type_bonus == 4
           @type_bonus = "Précision" if @type_bonus == 5
           @type_bonus = "Esquive" if @type_bonus == 6
           @type_bonus = "Critique" if @type_bonus == 7
          return @bonus,@type_bonus,@nb_combat
    end # Fin méthode
  end # Fin Classe
end # Fin module
 
#==============================================================================
# ** Scene_Title
#------------------------------------------------------------------------------
#  Gére la fenêtre de l'écran titre.
#==============================================================================
class Scene_Title < Scene_Base
  #--------------------------------------------------------------------------
  # * Efface la liste d'enduits lors d'une nouvelle partie
  #--------------------------------------------------------------------------
def update
    super
    @command_window.update
    if Input.trigger?(Input::C)
      case @command_window.index
      when 0    #New game
        $enduits_appliques.clear if $enduits_appliques.nil? != true
        command_new_game
      when 1    # Continue
        command_continue
      when 2    # Shutdown
        command_shutdown
      end
    end
  end
  #--------------------------------------------------------------------------
  # Ce qui suit à été  réalisé par omegazion
  #--------------------------------------------------------------------------
  # * Alias List
  #--------------------------------------------------------------------------
  alias oz_oecs_main_start start
  alias oz_oecs_load_bt_database load_bt_database
  def load_bt_database
    oz_oecs_load_bt_database
    initialize_oecs
  end
  #--------------------------------------------------------------------------
  # * Start processing
  #--------------------------------------------------------------------------
  def start
    oz_oecs_main_start
    initialize_oecs
  end
  #--------------------------------------------------------------------------
  # * Initialize OECS script
  #--------------------------------------------------------------------------
  def initialize_oecs
    for equipment in ($data_weapons + $data_armors).compact
      equipment.mother_item_id = equipment.id
    end
  end
end
 
#==============================================================================
# ** Window_Base
#------------------------------------------------------------------------------
# Classe qui permet de créer une fenêtre
#==============================================================================
 
class Window_Base < Window
  def draw_item_name(item, x, y, enabled = true,color = normal_color)
    if item != nil
      draw_icon(item.icon_index, x, y, enabled)
      self.contents.font.color = color
      self.contents.font.color.alpha = enabled ? 255 : 128
      self.contents.draw_text(x + 24, y, 172, WLH, item.name)
    end
  end
end
 
 
#==============================================================================
# ** Game_Actor
#------------------------------------------------------------------------------
# Gére les informations des Héros.
#==============================================================================
class Game_Actor < Game_Battler
    #--------------------------------------------------------------------------
  # * Modifier l'attaque
  #--------------------------------------------------------------------------
  def base_atk
    n = actor.parameters[2, @level]
    for item in equips.compact do n += item.atk end
   if $enduits_appliques.nil? == false
     if $enduits_appliques.include?(@weapon_id) 
       bonus_enduit = $enduits_appliques[@weapon_id]
       if bonus_enduit[2] == "Force"
       n += bonus_enduit[1]
     end
   end
   end
    return n
  end
  #--------------------------------------------------------------------------
  # * Modifier la défense
  #--------------------------------------------------------------------------
  def base_def
    n = actor.parameters[3, @level]
    for item in equips.compact do n += item.def end
    if $enduits_appliques.nil? == false
     if $enduits_appliques.include?(@weapon_id) 
       bonus_enduit = $enduits_appliques[@weapon_id]
       if bonus_enduit[2] == "Defense"
       n += bonus_enduit[1]
     end
   end
 end
    return n
  end
  #--------------------------------------------------------------------------
  # * Modifier l'intelligence
  #--------------------------------------------------------------------------
  def base_spi 
    n = actor.parameters[4, @level]
    for item in equips.compact do n += item.spi end
    if $enduits_appliques.nil? == false
     if $enduits_appliques.include?(@weapon_id) 
       bonus_enduit = $enduits_appliques[@weapon_id]
       if bonus_enduit[2] == "Intelligence"
       n += bonus_enduit[1]
     end
   end
 end
    return n
  end
  #--------------------------------------------------------------------------
  # * Modifier l'agilité
  #--------------------------------------------------------------------------
  def base_agi
    n = actor.parameters[5, @level]
    for item in equips.compact do n += item.agi end
    if $enduits_appliques.nil? == false
     if $enduits_appliques.include?(@weapon_id) 
       bonus_enduit = $enduits_appliques[@weapon_id]
       if bonus_enduit[2] == "Agilité"
       n += bonus_enduit[1]
     end
   end
 end
    return n
  end
  
  #--------------------------------------------------------------------------
  # * Get Hit Rate
  #--------------------------------------------------------------------------
  def hit
    if two_swords_style
      n1 = weapons[0] == nil ? 95 : weapons[0].hit
      n2 = weapons[1] == nil ? 95 : weapons[1].hit
      n = [n1, n2].min
    else
      n = weapons[0] == nil ? 95 : weapons[0].hit
    end
     if $enduits_appliques.nil? == false
     if $enduits_appliques.include?(@weapon_id) 
       bonus_enduit = $enduits_appliques[@weapon_id]
       if bonus_enduit[2] == "Précision"
       n += bonus_enduit[1]
     end
   end
 end
    return n
  end
  #--------------------------------------------------------------------------
  # * Get Evasion Rate
  #--------------------------------------------------------------------------
  def eva
    n = 5
    for item in armors.compact do n += item.eva end
           if $enduits_appliques.nil? == false
     if $enduits_appliques.include?(@weapon_id) 
       bonus_enduit = $enduits_appliques[@weapon_id]
       if bonus_enduit[2] == "Esquive"
       n += bonus_enduit[1]
     end
   end
 end
    return n
  end
  #--------------------------------------------------------------------------
  # * Get Critical Ratio
  #--------------------------------------------------------------------------
  def cri
    n = 4
    n += 4 if actor.critical_bonus
    for weapon in weapons.compact
      n += 4 if weapon.critical_bonus
    end
        for item in armors.compact do n += item.eva end
           if $enduits_appliques.nil? == false
     if $enduits_appliques.include?(@weapon_id) 
       bonus_enduit = $enduits_appliques[@weapon_id]
       if bonus_enduit[2] == "Critique"
       n += bonus_enduit[1]
     end
   end
 end
    return n
  end
end
 
#==============================================================================
# ** Scene_Battle
#------------------------------------------------------------------------------
#  Scene qui gére les combats.
#==============================================================================
class Scene_Battle < Scene_Base
  #--------------------------------------------------------------------------
  # * A la fin du combat si l'enduit ne fonctionne plus, l'enlever
  #--------------------------------------------------------------------------
    def battle_end(result)
      if  $enduits_appliques.nil? == false
         for actor in $game_party.members
          if $enduits_appliques.include?(actor.weapon_id)
          enduit_applique = $enduits_appliques[actor.weapon_id]
          enduit_applique[3] -= 1
          if enduit_applique[3] == 0 
            $enduits_appliques.delete(actor.weapon_id)
            enduit_applique[2] = Enduits::Raccourcis[enduit_applique[2]] if  Enduits::Abrevation == true
            bonus = " ["+ enduit_applique[2] + " + " + enduit_applique[1] .to_s + "]"
            $data_weapons[actor.weapon_id].name.slice!(bonus)  if Enduits::Afficher_bonus == true
          end
        end
        end
      end
    if result == 2 and not $game_troop.can_lose
      call_gameover
    else
      $game_party.clear_actions
      $game_party.remove_states_battle
      $game_troop.clear
      if $game_temp.battle_proc != nil
        $game_temp.battle_proc.call(result)
        $game_temp.battle_proc = nil
      end
      unless $BTEST
        $game_temp.map_bgm.play
        $game_temp.map_bgs.play
      end
      $scene = Scene_Map.new
      @message_window.clear
      Graphics.fadeout(30)
    end
    $game_temp.in_battle = false
  end
  
  #--------------------------------------------------------------------------
  # * A la fin du combat gérer le drop
  #--------------------------------------------------------------------------
  
   def display_drop_items
    drop_items = $game_troop.make_drop_items
    for item in drop_items
      if item.is_a?(RPG::Weapon)
        index = Separation.create(item)
        item = $data_weapons[index]
      elsif item.is_a?(RPG::Armor)
        index = Separation.create(item)
        item = $data_armors[index]
      end
      $game_party.gain_item(item, 1)
      text = sprintf(Vocab::ObtainItem, item.name)
      $game_message.texts.push(text)
    end
    wait_for_message
  end
end
 
 
#==============================================================================
# ** Window_Equip
#------------------------------------------------------------------------------
#  This window displays items the actor is currently equipped with on the
# equipment screen.
#==============================================================================
class Window_Equip < Window_Selectable
  #--------------------------------------------------------------------------
  # * Refresh
  #--------------------------------------------------------------------------
 def refresh
    self.contents.clear
    @data = []
    for item in @actor.equips do @data.push(item) end
    @item_max = @data.size
    self.contents.font.color = system_color
    if @actor.two_swords_style
      self.contents.draw_text(4, WLH * 0, 92, WLH, Vocab::weapon1)
      self.contents.draw_text(4, WLH * 1, 92, WLH, Vocab::weapon2)
    else
      self.contents.draw_text(4, WLH * 0, 92, WLH, Vocab::weapon)
      self.contents.draw_text(4, WLH * 1, 92, WLH, Vocab::armor1)
    end
    self.contents.draw_text(4, WLH * 2, 92, WLH, Vocab::armor2)
    self.contents.draw_text(4, WLH * 3, 92, WLH, Vocab::armor3)
    self.contents.draw_text(4, WLH * 4, 92, WLH, Vocab::armor4)
    draw_item_name(@data[0], 92, WLH * 0)
    draw_item_name(@data[1], 92, WLH * 1)
    draw_item_name(@data[2], 92, WLH * 2)
    draw_item_name(@data[3], 92, WLH * 3)
    draw_item_name(@data[4], 92, WLH * 4)
  end
end
 
#==============================================================================
# ** Scene_Menu
#------------------------------------------------------------------------------
#  This class performs the menu screen processing.
#==============================================================================
if Enduits::Incorpor_menu == true 
    class Scene_Menu < Scene_Base
  #--------------------------------------------------------------------------
  # * Create Command Window
  #--------------------------------------------------------------------------
  def create_command_window
    s1 = Vocab::item
    s2 = Vocab::skill
    s3 = Vocab::equip
    s4 = Vocab::status
    s5 = Vocab::save
    s6 = Enduits::Nom_menu
    s7 = Vocab::game_end
    if Enduits::Menu_moghunter == false 
      @command_window = Window_Command.new(160, [s1, s2, s3, s4, s5, s6,s7])
    else
      @command_window = Window_Command.new(160, [s1, s2, s3, s4, s5, s6,s7],column_max = 1, row_max = 6)
    end
    @command_window.index = @menu_index
    if $game_party.members.size == 0          # If number of party members is 0
      @command_window.draw_item(0, false)     # Disable item
      @command_window.draw_item(1, false)     # Disable skill
      @command_window.draw_item(2, false)     # Disable equipment
      @command_window.draw_item(3, false)     # Disable status
    end
    if $game_system.save_disabled             # If save is forbidden
      @command_window.draw_item(4, false)     # Disable save
    end
  end
  #--------------------------------------------------------------------------
  # * Update Command Selection
  #--------------------------------------------------------------------------
  def update_command_selection
    if Input.trigger?(Input::B)
      Sound.play_cancel
      $scene = Scene_Map.new
    elsif Input.trigger?(Input::C)
      if $game_party.members.size == 0 and @command_window.index < 4
        Sound.play_buzzer
        return
      elsif $game_system.save_disabled and @command_window.index == 4
        Sound.play_buzzer
        return
      end
      Sound.play_decision
      case @command_window.index
      when 0      # Item
        $scene = Scene_Item.new
      when 1,2,3  # Skill, equipment, status
        start_actor_selection
      when 4      # Save
        $scene = Scene_File.new(true, false, false)
      when 5
        $scene = Scene_Enduits.new
      when 6      # End Game
        $scene = Scene_End.new
        end
      end
    end
  end # fin class Scene_Menu < Scene_Base
end # fin if Enduits::Incorpor_menu == true 
 
#==============================================================================
# ** Window_Selectable
#------------------------------------------------------------------------------
#  Permet de faire une fenêtre de confirmation
#==============================================================================
  class Window_Command < Window_Selectable
  #-----------------------------------------------------------------------------------------
  # * Redéfinition pour afficher correctement les choix d'en dessous
  #-----------------------------------------------------------------------------------------
  def refresh
    self.contents.clear
    create_contents # A ajouter
    for i in 0...@item_max
      draw_item(i)
    end
  end
end
 
 
#==============================================================================
# ** Separation
#------------------------------------------------------------------------------
#  Module qui permet de separer les armes
#  Réalisé par omegazion
#==============================================================================
module Separation
  #--------------------------------------------------------------------------
  # * The Main Creation of Equipment
  #--------------------------------------------------------------------------
  def self.create(item)
    temp_item = item.dup
    temp_item.id = temp_item.is_a?(RPG::Weapon) ? $data_weapons.size : $data_armors.size
    if item.is_a?(RPG::Weapon)
      index = $data_weapons.size
      $data_weapons.push(temp_item) 
      for i in 1...$data_classes.size
        if $data_classes[i].weapon_set.include?(item.id)
          $data_classes[i].weapon_set.push(temp_item.id)
        end
      end
    else
      index = $data_armors.size
      $data_armors.push(temp_item) 
      for i in 1...$data_classes.size
        if $data_classes[i].armor_set.include?(item.id)
          $data_classes[i].armor_set.push(temp_item.id)
        end
      end
    end
    return temp_item.id
  end
  
  #--------------------------------------------------------------------------
  # * Item Version of the above
  #--------------------------------------------------------------------------
  def self.item_create(item)
    temp_item = item.dup
    temp_item.id = $data_items.size
    $data_items.push(temp_item)
    return temp_item.id
  end
 
end
 
 
#==============================================================================
# ** Game_Interpreter
#------------------------------------------------------------------------------
#  Gére les evenements
#==============================================================================
 
class Game_Interpreter
  #--------------------------------------------------------------------------
  # * Modifie les armes
  #--------------------------------------------------------------------------
  def command_127
    value = operate_value(@params[1], @params[2], @params[3])
    for i in 0...value
      has_prefix, has_suffix = false, false
      index = Separation.create($data_weapons[@params[0]])
      $game_party.gain_item($data_weapons[index], 1, @params[4])
    end
    return true
  end
  #--------------------------------------------------------------------------
  # * Modifie les armures
  #--------------------------------------------------------------------------
  def command_128
    value = operate_value(@params[1], @params[2], @params[3])
    for i in 0...value
      index = Separation.create($data_armors[@params[0]])
      $game_party.gain_item($data_armors[index], 1, @params[4])
    end
    return true
  end
end
 
#==============================================================================
# ** Window_Item
#------------------------------------------------------------------------------
#  Affiche les objets dans l'inventaire
#==============================================================================
  class Window_Item < Window_Selectable
    def draw_item(index)
      rect = item_rect(index)
      self.contents.clear_rect(rect)
      item = @data[index]
      if item != nil
        number = $game_party.item_number(item)
        enabled = enable?(item)
        rect.width -= 4
        draw_item_name(item, rect.x, rect.y, enabled)
        self.contents.draw_text(rect, sprintf(":%2d", number), 2) unless item.is_a?(RPG::Weapon) or item.is_a?(RPG::Armor)
      end
    end
  end
  
#==============================================================================
# ** Scene_File
#------------------------------------------------------------------------------
#  Gére les sauvegardes
#==============================================================================
 
class Scene_File
  #--------------------------------------------------------------------------
  # * Alias List
  #--------------------------------------------------------------------------
  alias oz_oecs_main_write_save_data write_save_data
  alias oz_oecs_main_read_save_data read_save_data
  #--------------------------------------------------------------------------
  # * Write Save Data
  #     file : write file object (opened)
  #--------------------------------------------------------------------------
  def write_save_data(file)
    oz_oecs_main_write_save_data(file)
    Marshal.dump($data_weapons, file)
    Marshal.dump($data_armors,  file)
    Marshal.dump($data_classes, file)
  end
  #--------------------------------------------------------------------------
  # * Read Save Data
  #     file : file object for reading (opened)
  #--------------------------------------------------------------------------
  def read_save_data(file)
    oz_oecs_main_read_save_data(file)
    $data_weapons = Marshal.load(file)
    $data_armors  = Marshal.load(file)
    $data_classes = Marshal.load(file)
  end
end
 
#==============================================================================
# ** Separation::EquipInclude
#------------------------------------------------------------------------------
#  Sauvegarde la nouvelle gestion des équipements
#==============================================================================
 
module Separation::EquipInclude
  attr_accessor :mother_item_id
  alias oecs_main_dup dup unless $@
  def dup
    duplicate = self.oecs_main_dup
    perform_duplication(duplicate)
    return duplicate
  end
  # separated for aliasing
  def perform_duplication(duplicate)
    duplicate.element_set = self.element_set.dup
    duplicate.state_set = self.state_set.dup
  end
end
 
#==============================================================================
# ** RPG
#------------------------------------------------------------------------------
#  Contient toutes les données de la database
#==============================================================================
 
module RPG
  
  #============================================================================
  # ** RPG::Weapon
  #----------------------------------------------------------------------------
  #  Pour les armes
  #============================================================================
  class Weapon
    #------------------------------------------------------------------------
    # * Perform mix-in
    #------------------------------------------------------------------------
    include Separation::EquipInclude
    def mother_item
      return $data_weapons[@mother_item_id]
    end
  end
  
  #============================================================================
  # ** RPG::Armor
  #----------------------------------------------------------------------------
  #  Pour les armures
  #============================================================================
  class Armor
    #------------------------------------------------------------------------
    # * Perform mix-in
    #------------------------------------------------------------------------
    include Separation::EquipInclude
    def mother_item
      return $data_armors[@mother_item_id]
    end
  end
end