#===============================================================
# ● [VX] ◦ Enduits pour lames
#--------------------------------------------------------------
# ◦ Par Blockade, d'une requête
# ◦ https://rpg-maker-vx.bbactif.com/forum.htm
# ◦ Crée le 08/03/2009
# ◦ Version 1.1
# ◦ Remerciment à ASKHA, omegazion
#--------------------------------------------------------------
# > Comment créer un enduit :
# Dans la partie commentaire de l'objet rentrer 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 indiquer l'ID de l'enduit dans ENDUITS = []
# Et voila l'enduit est près !
#===============================================================

#===============================================================
# 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 = [50,51,52,53,54,55,56,57]

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


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