##########################################################################################
#
#                                                                              script écrit par : Raizen ZENTRIX
#
#                                                                                            script Réputation
#                                                                                                  Version 2.0
#
#                                                                    Autres infos sur : http://rpgmvx-rz.forumactif.com
#
#
#    Versions précédentes :
#        + version 1.0 (sur RPG Maker VX)
#
##########################################################################################
=begin

Ce script permet de rajouter dans le menu l'option "Réputation", qui contient la réputation
de l'équipe, leurs points de réputations actuelles, ainsi que les autres réputations
accompagnées d'une image pour chaque réput.

Pour le bon fonctionnement du script, suivez pas à pas et ATTENTIVEMENT les
instructions dans le script.

En tout, il y a deux modifications obligatoires à faire.

Pour utiliser le script ce qui veut dire changer la réputation de l'équipe au cours du jeu,
il faut changer les points de réputation, évident, non ?
Pour cela, vous devez appeler un script par event, et y mettre l'une de ces commandes :

$reput_points += M  (Pour augmenter la valeur des points d'un montant de M)

$reput_points -= M    (Pour les diminuer d'un montant de M)

Facile, non ? ^^

Maintenant, passons au choses sérieuses : Les modifications !

Au faîte, j'allais oublier, le script est à placer au dessus de Main ^^'.

=end

#########################################  Le script  ########################################

class Scene_Reputation
 
  # C'est la variable des points de réputation, comme vous voyez elle est égale à la valeur
  # 0, car au début, l'équipe aura 0 point de réputation, mais vous pouvez toujours
  #modifier cette valeur si vous voulez que votre équipe ne commence pas avec 0.
  # N.B :
  # La variable peut ausi être de valeur négative !
  # La valeur de la variable doit être un nombre entier !
  $reput_points = 0
 
  def main
#---------------------------------------------------------------------  A MODIFIER  -------------------------------------------------------------------
    # Ici, vous devez mettre les noms de vos réputations POSITIVES, dans la variable
    # @pos_reputs, les points de réputations requis dans la variable @pos_points,
    # ainsi que le nom des images des réputations dans la variable @pos_images,
    # et enfin, la couleur de la réputation dans la variable @pos_colors.
    # Suivez l'exemple :
 
    @pos_reputs = ["Neutre", "Amical", "Bon", "Noble", "Héroe", "Légende"]
    # ici, on mets les noms des réputations positives entre guillemets, et on les sépare par
    # des virgules.
 
    @pos_points = [0, 200, 500, 1200, 3000, 5000]
    # ici, on mets le nombre de points requis pour avoir chaque réputation, on doit les
    # mettre en ordre, si on prend cet exemple, on a pour la réputation :
    # "Neutre" => 0 points
    # "Amical" => 200 points
    # "Bon" => 500 points
    # "Noble" => 1000 points
    # "Héroe" => 2500 points
    # "Légende" => 5000 poitns
    # ... et ainsi de suite.
 
    @pos_images = [
    "Neutre",
    "Amical",
    "Bon",
    "Noble",
    "Héroe",
    "Légende",
    ]
    # ici, on mets le noms des images de chaque réputation, en ordre, si on prend cet
    # exemple, le nom de l'image de la réputation :
    # "Neutre" => "Neutre"
    # "Amical" => "Amical"
    # "Bon" => "Bon"
    # "Noble" => "Noble"
    # "Héroe" => "Héroe"
    # "Légende" => "Légende"
    # ... et ainsi de suite.
    # N.B :
    # le nom des images ne doit pas contenir l'extension !
    # les images doivent être mise dans le dossier Pictures dans Graphics !
    # le format conseillé des images est de 340x236 !
    # n'oubliez pas les virgules entre les noms des images !
 
    @pos_colors = [
    Color.new(255, 255, 255),
    Color.new(0, 190, 255),
    Color.new(0, 150, 255),
    Color.new(0, 90, 255),
    Color.new(0, 0, 255),
    Color.new(0, 255, 0)
    ]
    # ici, on mets la couleur de chaque réputation en ordre, il faut procéder comme
    # ceci :
    # Color.new(a, b, c)
    # avec :
    # a : chiffre représentant la tendance de la couleur Rouge
    # b : la tendance de la couleur Verte
    # c : et enfin celle de la couleur Bleue
    # si on prend cet exemple, la couleur de la réputation :
    # "Neutre" => Color.new(255, 255, 255)
    # "Amical" => Color.new(0, 190, 255)
    # "Bon" => Color.new(0, 150, 255)
    # ... et ainsi de suite.
    # N.B :
    # n'oubliez pas que vous devez avoir le même nombre de réputations que les noms
    # des couleurs, des images et des points, en d'autre termes, si vous avez 6 réputations
    # (comme c'est le cas), vous devez avoir 6 points, 6 noms d'images et 6 couleurs !

#--------------------------------------------------------------  FIN DE LA 1ERE MODIF  --------------------------------------------------------#
 
#---------------------------------------------------------------------  A MODIFIER  -------------------------------------------------------------------
    # Ici, vous devez mettre les noms de vos réputations NEGATIVES cette fois, dans
    # la variable @neg_reputs, les points de réputations requis dans la variable
    # @neg_points, ainsi que le nom des images des réputations dans la variable
    # @neg_images, et enfin, la couleur de la réputation dans la variable @neg_colors.
    # C'est le même processus à suivre :
 
    @neg_reputs = ["Agressif", "Retord", "Malicieux", "Cruel", "Ténèbreux"]
    # ici, on mets les noms des réputations positives entre guillemets, et on les sépare par
    # des virgules.
 
    @neg_points = [-200, -400, -1000, -2500, -4000]
    # ici, on mets le nombre de points requis pour avoir chaque réputation, on doit les
    # mettre en ordre, si on prend cet exemple, on a pour la réputation :
    # "Agressif" => -200 points
    # "Retord" => -500 points
    # "Malicieux" => -1000 points
    # "Cruel" => -2500 points
    # "Ténèbreux" => -5000 points
    # ... et ainsi de suite.
    # N.B :
    # dans cette section des réputations négatives, les points DOIVENT être de valeur
    # négatives, et c'est une OBLIGATION pour le bon fonctionnement du script !
 
    @neg_images = [
    "Agressif",
    "Retord",
    "Malicieux",
    "Cruel",
    "Ténèbreux",
    ]
    # ici, on mets le noms des images de chaque réputation, en ordre, si on prend cet
    # exemple, le nom de l'image de la réputation :
    # "Agressif" => "Agressif"
    # "Retord" => "Retord"
    # "Malicieux" => "Malicieux"
    # "Cruel" => "Cruel"
    # "Ténèbreux" => "Ténébreux"
    # ... et ainsi de suite.
    # N.B :
    # le nom des images ne doit pas contenir l'extension !
    # les images doivent être mise dans le dossier Pictures dans Graphics !
    # le format conseillé des images est de 340x236 !
    # n'oubliez pas les virgules entre les noms des images !
 
    @neg_colors = [
    Color.new(255,190,0),
    Color.new(255, 150, 0),
    Color.new(255, 90, 0),
    Color.new(255, 0, 0),
    Color.new(140, 140, 140),
    ]
    # ici, on mets la couleur de chaque réputation en ordre, il faut procéder comme
    # ceci :
    # Color.new(a, b, c)
    # avec :
    # a : chiffre représentant la tendance de la couleur Rouge
    # b : la tendance de la couleur Verte
    # c : et enfin celle de la couleur Bleue
    # si on prend cet exemple, la couleur de la réputation :
    # "Agressif" => Color.new(255, 190, 0)
    # "Retord" => Color.new(255, 150, 0)
    # "Malicieux" => Color.new(255, 0, 0)
    # ... et ainsi de suite.
    # N.B :
    # n'oubliez pas que vous devez avoir le même nombre de réputations que les noms
    # des couleurs, des images et des points, en d'autre termes, si vous avez 4 réputations
    # (comme c'est le cas), vous devez avoir 4 points, 4 noms d'images et 4 couleurs !
 
#--------------------------------------------------------------  FIN DE LA 2EME MODIF  --------------------------------------------------------#
 
    # Le texte qu'apparaîtera dans la fenêtre de bienvenue
    texte1 = "Réputation de l'équipe"
 
    # Le texte qu'apparaîtera dans la réputaion actuelle de l'équipe
    texte2 = "Réputation actuelle :"
 
    # Le texte qu'apparaîtera dans les points de réputation actuelles de l'équipe
    texte3 = "Points de réputation :"
 
    # Le texte qu'apparaîtera dans la liste des réputations connues de l'équipe
    texte4 = "Réputations connues :"
   
    @reputs = @pos_reputs.reverse + @neg_reputs
    @colors = @pos_colors.reverse + @neg_colors
    @images = @pos_images.reverse + @neg_images

    for i in 0...@pos_reputs.size
      if $reput_points >= @pos_points[i]
        @reput_actuelle = @pos_reputs[i]
        @color_actuelle = @pos_colors[i]
      end
    end
 
    for i in 0...@neg_reputs.size
      if $reput_points <= @neg_points[i]
        @reput_actuelle = @neg_reputs[i]
        @color_actuelle = @neg_colors[i]
      end
    end
 
    # La fenêtre de bienvenue :
    @welcome_window = Window_Base.new (0, 0, 544, 64)
    @welcome_window.contents.draw_text (4, 0, 544, 32, texte1, 1)
 
    # La fenêtre où apparaîtera la réputation actuelle de l'équipe :
    @reput_actuelle_window = Window_Base.new (200, 64, 344, 56)
    @reput_actuelle_window.contents.draw_text (4, 0, @reput_actuelle_window.width - 40, 28, texte2, 0)
    @reput_actuelle_window.contents.font.color = @color_actuelle
    @reput_actuelle_window.contents.draw_text (4, 0, @reput_actuelle_window.width - 40, 28, @reput_actuelle.to_s, 2)
 
    # La fenêtre où apparaîteront les points de réputation actuelles de l'équipe :
    @points_window = Window_Base.new (200, 120, 344, 56)
    @points_window.contents.draw_text (4, 0, @points_window.width - 40, 28, texte3, 0)
    @points_window.contents.font.color = @color_actuelle
    @points_window.contents.draw_text (4, 0, @points_window.width - 40, 28, $reput_points.to_s, 2)
 
    # La fenêtre qui sera en haut de la liste des réputations connues :
    @head_window = Window_Base.new (0, 64, 200, 56)
    @head_window.contents.draw_text (4, 0, @head_window.width - 40, 28, texte4, 0)
 
    # La fenêtre où apparaîteront les réputations connues de l'équipe :
    @reput_window = Raizen_Reput2_Command.new (200, @reputs, 304)
    @reput_window.y = 120

    for i in 0...@reputs.size
      @reput_window.draw_item (i, @colors[i])
    end
 
    # La fenêtre où apparaîtera les images des réputaions :
    @images_window = Window_Base.new (200, 176, 344, 240)
    @images_window.back_opacity = 0
 
    # Le sprite des images :
    @reput_sprite = Sprite.new
    @reput_sprite.x = @images_window.x + 2
    @reput_sprite.y = @images_window.y + 2
 
    Graphics.transition
 
    loop do
      Graphics.update
      Input.update
      create_sprite
      if $scene != self
        break
      end
    end
 
    Graphics.freeze
 
    @welcome_window.dispose
    @reput_actuelle_window.dispose
    @points_window.dispose
    @head_window.dispose
    @reput_window.dispose
    @images_window.dispose
    @reput_sprite.dispose
 
  end
 
  def create_sprite
    index = @reput_window.index
    @reput_sprite.bitmap = Cache.picture(@images[index])
 
    update
  end
 
  def update
    @welcome_window.update
    @reput_actuelle_window.update
    @points_window.update
    @head_window.update
    @reput_window.update
    @images_window.update
 
    update_command
  end
 
  def update_command
    if Input.trigger?(Input::B)
      Sound.play_cancel
      $scene = Scene_Menu.new(4)
    end
  end
 
end

#==============================================================================
# Création de Raizen_Reput2_Command
#==============================================================================

class Raizen_Reput2_Command < Window_Selectable

  def initialize(width, commands, height, column_max = 1, row_max = 0, spacing = 32)
    if row_max == 0
      row_max = (commands.size + column_max - 1) / column_max
    end
    if (row_max*WLH + 32) >= height
      super(0, 0, width, height, spacing)
    else
      super(0, 0, width, row_max * WLH + 32, spacing)
    end
    @commands = commands
    @item_max = commands.size
    @column_max = column_max
    self.contents.dispose
    self.contents = Bitmap.new(width - 32, @item_max * WLH)
    refresh
    self.index = 0
  end

  def refresh
    self.contents.clear
    for i in 0...@item_max
      draw_item(i, normal_color)
    end
  end

  def draw_item(index, color)
    rect = item_rect(index)
    rect.x += 4
    rect.width -= 8
    self.contents.clear_rect(rect)
    self.contents.font.color = color
    self.contents.draw_text(rect, @commands[index])
  end
 
end

#==============================================================================
# Modification de Scene_Menu
#==============================================================================
class Scene_Menu < Scene_Base

  def create_command_window
    s1 = Vocab::item
    s2 = Vocab::skill
    s3 = Vocab::equip
    s4 = Vocab::status
    s5 = Vocab::save
    s6 = Vocab::game_end
    s7 = "Réputation"  # Ici, le nom qu'apparaîtera dans le menu
    @command_window = Window_Command.new(160, [s1, s2, s3, s4, s7, s5, s6])

    @command_window.index = @menu_index
    if $game_party.members.size == 0   
      @command_window.draw_item(0, false)
      @command_window.draw_item(1, false)
      @command_window.draw_item(2, false)
      @command_window.draw_item(3, false)
    end
    if $game_system.save_disabled     
      @command_window.draw_item(4, false)
    end
  end

  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      # Objet
        $scene = Scene_Item.new
      when 1,2,3  # Compétence, équipment, statut
        start_actor_selection
      when 4      # Réputation
        $scene = Scene_Reputation.new
      when 5      # Sauvegarder
        $scene = Scene_File.new(true, false, false)
      when 6      # Quitter la partie
        $scene = Scene_End.new
      end
    end
  end
 
end

#==============================================================================
# Modification de Scene_File
#==============================================================================
class Scene_File < Scene_Base
 
  def return_scene
    if @from_title
      $scene = Scene_Title.new
    elsif @from_event
      $scene = Scene_Map.new
    else
      $scene = Scene_Menu.new(5)
    end
  end
 
  def write_save_data(file)
    characters = []
    for actor in $game_party.members
      characters.push([actor.character_name, actor.character_index])
    end
    $game_system.save_count += 1
    $game_system.version_id = $data_system.version_id
    @last_bgm = RPG::BGM::last
    @last_bgs = RPG::BGS::last
    Marshal.dump(characters,          file)
    Marshal.dump(Graphics.frame_count, file)
    Marshal.dump(@last_bgm,            file)
    Marshal.dump(@last_bgs,            file)
    Marshal.dump($game_system,        file)
    Marshal.dump($game_message,        file)
    Marshal.dump($game_switches,      file)
    Marshal.dump($game_variables,      file)
    Marshal.dump($game_self_switches,  file)
    Marshal.dump($game_actors,        file)
    Marshal.dump($game_party,          file)
    Marshal.dump($game_troop,          file)
    Marshal.dump($game_map,            file)
    Marshal.dump($game_player,        file)
    Marshal.dump($reput_points, file)
  end
 
  def read_save_data(file)
    characters          = Marshal.load(file)
    Graphics.frame_count = Marshal.load(file)
    @last_bgm            = Marshal.load(file)
    @last_bgs            = Marshal.load(file)
    $game_system        = Marshal.load(file)
    $game_message        = Marshal.load(file)
    $game_switches      = Marshal.load(file)
    $game_variables      = Marshal.load(file)
    $game_self_switches  = Marshal.load(file)
    $game_actors        = Marshal.load(file)
    $game_party          = Marshal.load(file)
    $game_troop          = Marshal.load(file)
    $game_map            = Marshal.load(file)
    $game_player        = Marshal.load(file)
    $reput_points = Marshal.load(file)
    if $game_system.version_id != $data_system.version_id
      $game_map.setup($game_map.map_id)
      $game_player.center($game_player.x, $game_player.y)
    end
  end
 
end


#==============================================================================
# Modification de Scene_End
#==============================================================================
class Scene_End < Scene_Base
 
  def return_scene
    $scene = Scene_Menu.new(6)
  end
 
end

##############################  Fin du script  #######################################

=begin
########################## Breadlord's Quets Script Modifié par Skillo ############################
Ceci est un script pour quête vous permettant d'avoir une large description des quêtes et de multiples tâches
(entend par là plusieurs à truc à faire pour la même quête hein).
Tu met les quêtes sous forme d'evenement c'est à dire sous ce format :

$quests['nom de la quête'] = Quest.new([' ligne de description 1', 'ligne de description 2, ...],
['tâche 1 description', 'tâche 2 description',...])

Dans ce format 'nom de la quête' correspond au nom de la quête,
'ligne de description N' est la N ème ligne de la description de la quête et
'tâche N description' est la description de la N eme tâche

Pour completer une tâche dans un evenement utilisez $quests['nom de la quête'].complete_sub('tâche description'),
et pour échouer une tâche utilisez $quests['nom de la quête'].fail_sub('tâche description').
Si toutes les tâches sont complétées/échouées alors le status de la quête deviendra complétée/échouée.
Pour mettre une quête en complétée utilisez $quests['nom de la quête'].complete_all,
et échouée utilisez $quests['nom de la quête'].fail_all

Pour vérifier si une quête est complétée utilisez $quests['nom de la quête'].complete?,
et pour vérifier si elle est échouée utilisez $quests['nom de la quête'].failed?.
Pour vérifier si une tâche est complétée utilisez $quests['nom de la quête'].sub_complete?('tâche description')
et pour vérifier si elle est échouée utilisez $quests['nom de la quête'].sub_failed?('tâche description')

Pour definir une quete secondaire il suffit de rajouter true  après les taches :
$quests['nom de la quête'] = Quest.new([' ligne de description 1', 'ligne de description 2, ...],
['tâche 1 description', 'tâche 2 description',...], true)

Enfin pour vérifier que la quête existe utilisez $quests['nom de la quête'] != nil
Pour appeler le menu de quête utilisez $scene = Scene_Quest.new
Et pour lancer le menu quête sur un onglet précis il suffit de $scene = Scene_Quest.new(index de l'onglet)
0<= index de l'onglet <= 3



################################################################################
################################################################################
=end
module QUEST_CONFIG
 
  # Ici seront defini les 3 icones correspondant aux tri des quêtes
  # QUEST_ICONS = [icone des quetes en cours, icone des quetes complétées, icone des quete echouées]
  QUEST_ICONS =  [188, 189, 150, 112]
 
  # Ici sera defini l'image apparaissant dans le menu
  # QUEST_PICTURE = "nom de l'image"
  QUEST_PICTURE = "Quest"
 
  # Ici sera defini la hauteur des fenêtre et par consequence la place laisser à l'image
  # QUEST_WINDOWHEIGHT = hauteur
  QUEST_WINDOWHEIGHT =  293  # 293
 
  # Ici sera defini l'image apparaissant lorsqu'une quête est completée
  # QUEST_COMPLETE = "nom de l'image"
  QUEST_COMPLETE = "Complete"
 
  # Ici sera defini l'image apparaissant lorsqu'une quête est échouée
  # QUEST_FAILED = "nom de l'image"
  QUEST_FAILED =  "Failed"
 
  # Ici sera defini le message apparaissant dans la fenetre de description lors d'une quête secondaire
  # QUEST_SECOND = "message"
  QUEST_SECOND = "Quête secondaire"
 
  # Ici seront defini les 3 icones correspondant aux états des quêtes et des tâches principales
  # VALIDATEICONS = [icone des taches en cours, icone des taches complétées, icone des taches echouées]
  VALIDATEICONS =  [96, 101, 99]
 
  # Ici seront defini les 3 icones correspondant aux états des quêtes et des tâches secondaires
  # VALIDATEICONS = [icone des taches en cours, icone des taches complétées, icone des taches echouées]
  VALIDATESECONDICONS =  [98, 100, 103]
 
  #Ici sera defini le nom apparaissant dans le menu de base
  # MENUNAME = nom du menu
  MENUNAME = 'Quêtes'
 
  #Ici sera defini le nom apparaissant dans la description de l'onglet  des quêtes principales
  # QUEST_NAMEPRINCIP = nom
  QUEST_NAMEPRINCIP = "Quêtes Principales"
 
  #Ici sera defini le nom apparaissant dans la description de l'onglet  des quêtes secondaires
  # QUEST_NAMESECOND = nom
  QUEST_NAMESECOND = "Quêtes Secondaires"
 
  #Ici sera defini le nom apparaissant dans la description de l'onglet  des quêtes réussies
  # QUEST_NAMECOMP = nom 
  QUEST_NAMECOMP = "Quêtes Réussies"

  #Ici sera defini le nom apparaissant dans la description de l'onglet  des quêtes échouées
  # QUEST_NAMEFAIL = nom
  QUEST_NAMEFAIL  =  "Quêtes Ratés"
 
  # Ici sera defini à titre indicatif le numero du menu quête dans le menu de base (comptez à partir de 0)
  # cela n'aura aucune influance sur sa position.
  # MENU_NUMBER = umero du menu quête dans le menu de base
  MENU_NUMBER = 4
 
  # Ici sera defini l'interrupteur definissant si un tache échoué fais echoué la quête ou non.
  # FAILSUB_FAILCOMPLETE = true/false
  FAILSUB_FAILCOMPLETE = true
 
end

#==============================================================================
# ** Quest
#------------------------------------------------------------------------------
#  Cette classe permet de definir des quêtes
#  Elle est appelée par $quests
#==============================================================================
class Quest

attr_accessor :desc, :sub, :comp, :sub_text, :pic

  #--------------------------------------------------------------------------
  # * Quête Initialization
  #    desc    : tableau des descriptions
  #    sub      : tableau des tâches
  #    pic  : window width
  #--------------------------------------------------------------------------
  def initialize(desc = [''], sub = [''], second = false)
    @desc = desc
    @sub = {}
    @second = second
    for i in 0..sub.size - 1  # pour chaque tache
      @sub[sub[i]] = 'prog'      #construit une clef du nom de la tache avec la valeur prog
    end
    @comp = 'prog'
    @sub_text = []
    for i in 0..sub.size - 1
      @sub_text.push(sub[i]) # pour chaque tache
    end
  end
 
  #--------------------------------------------------------------------------
  # * Completer une Tâche
  #    sub      :  tâche
  #--------------------------------------------------------------------------
  def second?
  return @second
  end
  #--------------------------------------------------------------------------
  # * Completer une Tâche
  #    sub      :  tâche
  #--------------------------------------------------------------------------
  def complete_sub(sub)
    @sub[sub] = 'comp'
    test_complete
  end
  #--------------------------------------------------------------------------
  # * Tester si la Quête est devenue complete
  #    sub      :  tâche
  #--------------------------------------------------------------------------
  def test_complete
    @a = true
    for i in 0..@sub.keys.size - 1
      if @sub[@sub.keys[i]] == 'comp'
        @a = (@a and true)
      else
        @a =  (@a and false)
      end
    end
    if @a == true
      complete_all
    end
  end
  #--------------------------------------------------------------------------
  # * Echouer une  Tâche
  #    sub      :  tâche
  #--------------------------------------------------------------------------
  def fail_sub(sub)
    if QUEST_CONFIG::FAILSUB_FAILCOMPLETE
      fail_all
    else
      @sub[sub] = 'fail'
    end
  end

 
  #--------------------------------------------------------------------------
  # *Compeleter toutes les Tâches
  #--------------------------------------------------------------------------
  def complete_all
    @comp = 'comp'
    for i in @sub.keys
      @sub[i] = 'comp'
    end
  end

  #--------------------------------------------------------------------------
  # *Echouer à toutes les Tâches
  #--------------------------------------------------------------------------
  def fail_all
    @comp = 'fail'
    for i in @sub.keys
      @sub[i] = 'fail'
    end
  end

  #--------------------------------------------------------------------------
  # *Tester si une  Tâches est complete
  #--------------------------------------------------------------------------
  def sub_complete?(sub)
    return @sub[sub] == 'comp'? true : false
  end

  #--------------------------------------------------------------------------
  # *Tester si une Quête est complete
  #--------------------------------------------------------------------------
  def complete?
    return @comp == 'comp'? true : false
  end

  #--------------------------------------------------------------------------
  # *Tester si une  Tâches est échouée
  #--------------------------------------------------------------------------
  def sub_failed?(sub)
    return @sub[sub] == 'fail'? true : false
  end

  #--------------------------------------------------------------------------
  # *Tester si une Quête est échouée
  #--------------------------------------------------------------------------
  def failed?
    return @comp == 'fail'? true : false
  end
end


#==============================================================================
# ** Window_Quest_Type
#------------------------------------------------------------------------------
#  Cette fenetre affiche les differents états des quêtes.
#==============================================================================
class Window_Quest_Type < Window_Selectable

attr_accessor :active, :index
  #--------------------------------------------------------------------------
  # * Object Initialization
  #--------------------------------------------------------------------------
  def initialize
    super(0,352 - QUEST_CONFIG::QUEST_WINDOWHEIGHT,160,64)
    @column_max = 4
    @index = 0
    @icons =  QUEST_CONFIG::QUEST_ICONS
    @spacing = 14
    refresh
  end

  #--------------------------------------------------------------------------
  # * Refresh
  #--------------------------------------------------------------------------
  def refresh
    @item_max = @icons.size
    create_contents
    for i in 0...@item_max
      rect = item_rect(i)
      rect.x -= 2
      icon = @icons[i]
      draw_icon(icon, rect.x, rect.y)
    end
  end
end

#==============================================================================
# ** Window_Quest_Title
#------------------------------------------------------------------------------
#  Cette fenetre affiche les descriptions des quêtes.
#==============================================================================
class Window_Quest_Title < Window_Base

  #--------------------------------------------------------------------------
  # * Object Initialization
  #--------------------------------------------------------------------------
  def initialize(index = QUEST_CONFIG::MENUNAME)
    super( 160, 352 - QUEST_CONFIG::QUEST_WINDOWHEIGHT, 384, 64)
      @pic_title = Sprite.new
      @pic_title.bitmap = Cache.picture(QUEST_CONFIG::QUEST_PICTURE)
      self.contents.draw_text(0, 0, self.width - 40, WLH, index, 1)
  end
  #--------------------------------------------------------------------------
  # * Dispose
  #--------------------------------------------------------------------------
  def dispose
    super
    @pic_title.dispose
  end
end

#==============================================================================
# ** Window_Quest_Desc
#------------------------------------------------------------------------------
#  Cette fenetre affiche lee contenue des quêtes.
#==============================================================================
class Window_Quest_Desc < Window_Base

  #--------------------------------------------------------------------------
  # * Object Initialization
  #--------------------------------------------------------------------------
  def initialize(index = nil)
    super( 160, 416 - QUEST_CONFIG::QUEST_WINDOWHEIGHT, 384, QUEST_CONFIG::QUEST_WINDOWHEIGHT)
    @status = Sprite.new
    if index != nil
      if $quests[index].complete?
        @status.bitmap = Cache.picture(QUEST_CONFIG::QUEST_COMPLETE)
      elsif $quests[index].failed?
        @status.bitmap = Cache.picture(QUEST_CONFIG::QUEST_FAILED)
      end
      @status.z = 201
      for i in 0..$quests[index].desc.size - 1
        a = $quests[index].desc[i]
        self.contents.draw_text(0, WLH*i, self.width - 40, WLH, a, 1)
      end
      a = $quests[index].sub_text
      for i in 0..a.size - 1
        b = a[i]
        if $quests[index].sub[b] == 'prog'
          if $quests[index].second?
            ic =  QUEST_CONFIG::VALIDATESECONDICONS[0]
          else
            ic =  QUEST_CONFIG::VALIDATEICONS[0]
          end
        elsif $quests[index].sub[b] == 'comp'
          if $quests[index].second?
            ic =  QUEST_CONFIG::VALIDATESECONDICONS[1]
          else
            ic =  QUEST_CONFIG::VALIDATEICONS[1]
          end
        else
          if $quests[index].second?
            ic =  QUEST_CONFIG::VALIDATESECONDICONS[2]
          else
            ic =  QUEST_CONFIG::VALIDATEICONS[2]
          end
        end
        draw_icon(ic, 4, WLH*(i + $quests[index].desc.size + 1))
        self.contents.draw_text(0, WLH*(i + $quests[index].desc.size + 1), self.width - 40, WLH, b, 1)
      end
      if $quests[index].second?
        self.contents.draw_text(0, QUEST_CONFIG::QUEST_WINDOWHEIGHT - 3*WLH, self.width - 40, WLH, QUEST_CONFIG::QUEST_SECOND, 1)
      end
    end
  end
  #--------------------------------------------------------------------------
  # * Dispose
  #--------------------------------------------------------------------------
  def dispose
    super
    @status.dispose
  end
end

#==============================================================================
# ** Window_Quest_Type
#------------------------------------------------------------------------------
#  Cette fenetre affiche lee contenue des quêtes.
#==============================================================================
class Window_Select_Quest < Window_Selectable
 
attr_accessor :c_items

  #--------------------------------------------------------------------------
  # * Object Initialization
  #--------------------------------------------------------------------------
  def initialize(type = 1)
    super(0, 416 - QUEST_CONFIG::QUEST_WINDOWHEIGHT, 160, QUEST_CONFIG::QUEST_WINDOWHEIGHT)
    @type = type
    self.index = 0
    self.active = false
    @items = $quests.keys
    create_contents
    a = @items
    @c_items = []
    for it in 0...@items.size
      if include?(a[it])
        @c_items.push(a[it])
      end
    end
    for it in 0...@c_items.size
      draw_opt(it)
    end
  end
 
  #--------------------------------------------------------------------------
  # * Update
  #--------------------------------------------------------------------------
  def update
    super
    @data = @c_items
    @item_max = @data.size
  end
 
  #--------------------------------------------------------------------------
  # * Include ?
  #  key  : nom d'une quête
  #--------------------------------------------------------------------------
  def include?(key)
    case @type
    when 1
      if !$quests[key].complete? and !$quests[key].failed? and !$quests[key].second?
        return true
      end
    when 2
      unless $quests[key].complete? or $quests[key].failed?
        return $quests[key].second?
      end
    when 3
      return $quests[key].complete?
    when 4
      return $quests[key].failed?
    end
  end

  #--------------------------------------------------------------------------
  # * Draw Opt
  #  itemm  :  quête
  #--------------------------------------------------------------------------
  def draw_opt(itemm)
    a = @c_items
    rect = item_rect(itemm)
    self.contents.clear_rect(rect)
    if $quests[@c_items[itemm]].complete?
      if $quests[@c_items[itemm]].second?
        draw_icon(QUEST_CONFIG::VALIDATESECONDICONS[1],rect.x, rect.y)
      else
        draw_icon(QUEST_CONFIG::VALIDATEICONS[1],rect.x, rect.y)
      end
    elsif $quests[@c_items[itemm]].failed?
      if $quests[@c_items[itemm]].second?
        draw_icon(QUEST_CONFIG::VALIDATESECONDICONS[2],rect.x, rect.y)
      else
        draw_icon(QUEST_CONFIG::VALIDATEICONS[2],rect.x, rect.y)
      end
    else
      if $quests[@c_items[itemm]].second?
        draw_icon(QUEST_CONFIG::VALIDATESECONDICONS[0],rect.x, rect.y)
      else
        draw_icon(QUEST_CONFIG::VALIDATEICONS[0],rect.x , rect.y)
      end
    end
    string = @c_items[itemm]
    rect.width -= 4
    self.contents.draw_text(rect.x, rect.y, rect.width, WLH, string, 2)
  end
end


#==============================================================================
# ** Scene_Quest
#------------------------------------------------------------------------------
#  Cette classe fere le menu de quêtes
#==============================================================================
class Scene_Quest < Scene_Base
 
  #--------------------------------------------------------------------------
  # * Object Initialization
  # 
  #--------------------------------------------------------------------------
  def initialize(index = 0, menu = false)
    @menu = menu
    @index = index
  end
 
  #--------------------------------------------------------------------------
  # * Start processing
  #--------------------------------------------------------------------------
  def start
    super
    create_menu_background
    @type = Window_Quest_Type.new
    @type.visible = true
    @type.active = true
    @type.index = @index
    @quests = Window_Select_Quest.new(@index +1)
    @quests.active = false
    @quests.index = -1
    @desc_window = Window_Quest_Desc.new
    @title = Window_Quest_Title.new
    update_desc
  end
 
  #--------------------------------------------------------------------------
  # * Return to Original Screen
  #--------------------------------------------------------------------------
  def return_scene
    if @menu
      $scene = Scene_Menu.new(QUEST_CONFIG::MENU_NUMBER)
    else
      $scene = Scene_Map.new
    end
  end
 
  #--------------------------------------------------------------------------
  # * Terminate
  #--------------------------------------------------------------------------
  def terminate
    dispose_menu_background
    @type.dispose
    @quests.dispose
    @title.dispose
    @desc_window.dispose
  end

  #--------------------------------------------------------------------------
  # * Update Frame
  #--------------------------------------------------------------------------
  def update
    super
    update_menu_background
    @type.update
    @quests.update
    if @type.active
      update_type_selection
    elsif @quests.active
      update_quests_selection
    else
      update_desc_selection
    end
    if Input.trigger?(Input::A)
      Sound.play_cancel
      return_scene
    end
  end

  #--------------------------------------------------------------------------
  # * Update Type Selection
  #--------------------------------------------------------------------------
  def update_type_selection
    if Input.trigger?(Input::B)
      Sound.play_cancel
      return_scene
    elsif Input.trigger?(Input::C)
      a = @type.index
      Sound.play_cursor
      @type.active = false
      @quests.dispose
      @quests = Window_Select_Quest.new(a + 1)
      @quests.active = true
      @quests.index = 0
    elsif Input.trigger?(Input::LEFT) or  Input.trigger?(Input::RIGHT)
        a = @type.index
        @quests.dispose
        @quests = Window_Select_Quest.new(a + 1)
        @quests.index = -1
        update_desc
    end
  end
 
  #--------------------------------------------------------------------------
  # * Update Quests Decription
  #--------------------------------------------------------------------------
  def update_desc
    case @type.index
    when 0
      @title.dispose
      @title = Window_Quest_Title.new(QUEST_CONFIG::QUEST_NAMEPRINCIP)
    when 1
      @title.dispose
      @title = Window_Quest_Title.new(QUEST_CONFIG::QUEST_NAMESECOND)
    when 2
      @title.dispose
      @title = Window_Quest_Title.new(QUEST_CONFIG::QUEST_NAMECOMP)
    when 3
      @title.dispose
      @title = Window_Quest_Title.new(QUEST_CONFIG::QUEST_NAMEFAIL)
    end
  end
  #--------------------------------------------------------------------------
  # * Update Quests Selection
  #--------------------------------------------------------------------------
  def update_quests_selection
    if Input.trigger?(Input::B)
      Sound.play_cancel
      Sound.play_cursor
      @type.active = true
      @quests.active = false
      @quests.index = -1
      update_desc
      @desc_window.dispose
      @desc_window = Window_Quest_Desc.new
    elsif Input.trigger?(Input::C)
      if @quests.c_items[@quests.index] == nil
        Sound.play_buzzer
      else
        Sound.play_decision
        @desc_window.dispose
        @desc_window = Window_Quest_Desc.new(@quests.c_items[@quests.index])
        @title.dispose
        @title = Window_Quest_Title.new(@quests.c_items[@quests.index])
        @quests.active = false
        @type.active = false
      end
    end
  end
 
  #--------------------------------------------------------------------------
  # * Update Desc Selection
  #--------------------------------------------------------------------------
  def update_desc_selection
    if Input.trigger?(Input::B)
      Sound.play_cancel
      Sound.play_cursor
      @quests.active = true
      update_desc
      @desc_window.dispose
      @desc_window = Window_Quest_Desc.new
    end
  end
end



#==============================================================================
# ** Scene_Title
#------------------------------------------------------------------------------
#  This class performs the title screen processing.
#==============================================================================
class Scene_Title < Scene_Base
 
  alias startupquest command_new_game
  #--------------------------------------------------------------------------
  # * Command: New Game
  #--------------------------------------------------------------------------
  def command_new_game
    startupquest
    $quests = {}
  end
end

#==============================================================================
# ** Scene_File
#------------------------------------------------------------------------------
#  This class performs the save and load screen processing.
#==============================================================================
class Scene_File < Scene_Base
 
  alias savequest write_save_data
  #--------------------------------------------------------------------------
  # * Write Save Data
  #    file : write file object (opened)
  #--------------------------------------------------------------------------
  def write_save_data(file)
    savequest
    Marshal.dump($quests, file)
  end
 
  alias loadquest read_save_data
  #--------------------------------------------------------------------------
  # * Read Save Data
  #    file : file object for reading (opened)
  #--------------------------------------------------------------------------
  def read_save_data(file)
    $quests = Marshal.load(file)
    loadquest
  end
end

#==============================================================================
# ** Quest Script dans le menu par  Skillo
#==============================================================================

#==============================================================================
# ** Scene_Menu
#------------------------------------------------------------------------------
#  This class performs the menu screen processing.
#==============================================================================

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 = QUEST_CONFIG::MENUNAME
    s6 = Vocab::save
    s7 = Vocab::game_end
    @command_window = Window_Command.new(160, [s1, s2, s3, s4, s5, s6, s7])
    @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(5, 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
        $scene = Scene_Quest.new(0, true)
      when 5      # Save
        $scene = Scene_File.new(true, false, false)
      when 6      # End Game
        $scene = Scene_End.new
      end
    end
  end
end

#==============================================================================
# ** Scene_File
#------------------------------------------------------------------------------
#  This class performs the save and load screen processing.
#==============================================================================

class Scene_File < Scene_Base
  #--------------------------------------------------------------------------
  # * Return to Original Screen
  #--------------------------------------------------------------------------
  def return_scene
    if @from_title
      $scene = Scene_Title.new
    elsif @from_event
      $scene = Scene_Map.new
    else
      $scene = Scene_Menu.new(5)
    end
  end
end

#==============================================================================
# ** Scene_End
#------------------------------------------------------------------------------
#  This class performs game end screen processing.
#==============================================================================

class Scene_End < Scene_Base
    #--------------------------------------------------------------------------
  # * Return to Original Screen
  #--------------------------------------------------------------------------
  def return_scene
    $scene = Scene_Menu.new(6)
  end
end

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 = QUEST_CONFIG::MENUNAME
 s6 = "Réputation"
 s7 = Vocab::save
 s8 = Vocab::game_end
 @command_window = Window_Command.new(160, [s1, s2, s3, s4, s5, s6, s7, s8])
 @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(5, 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
 $scene = Scene_Quest.new(0, true)
 when 5
 $scene = Scene_Reputation.new
 when 6 # Save
 $scene = Scene_File.new(true, false, false)
 when 7 # End Game
 $scene = Scene_End.new
 end
 end
 end
end

#==============================================================================
# ** Scene_File
#------------------------------------------------------------------------------
# This class performs the save and load screen processing.
#==============================================================================

class Scene_File < Scene_Base
 #--------------------------------------------------------------------------
 # * Return to Original Screen
 #--------------------------------------------------------------------------
 def return_scene
 if @from_title
 $scene = Scene_Title.new
 elsif @from_event
 $scene = Scene_Map.new
 else
 $scene = Scene_Menu.new(5)
 end
 end
end

#==============================================================================
# ** Scene_End
#------------------------------------------------------------------------------
# This class performs game end screen processing.
#==============================================================================

class Scene_End < Scene_Base
 #--------------------------------------------------------------------------
 # * Return to Original Screen
 #--------------------------------------------------------------------------
 def return_scene
 $scene = Scene_Menu.new(6)
 end
end