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

#-------------------------------------------------------------------------------
# * [ACE] Khas Message System
#-------------------------------------------------------------------------------
# * By Nilo K. (Khas)
# * Version: 1.0
# * Released on: 12.07.2016
#
# * Social Media
# Blog: arcthunder.blogspot.com
# Facebook: facebook.com/khasarc
# Twitter: twitter.com/arcthunder
# Youtube: youtube.com/c/khasarc
#
# * Khas Scripts @ RPG Maker Web forums (official support!)
# forums.rpgmakerweb.com/index.php?/forum/132-khas-scripts
#
#-------------------------------------------------------------------------------
# * Terms of Use
#-------------------------------------------------------------------------------
# When using KHAS MESSAGE SYSTEM (the script), you agree with the following terms:
# 1. If you purchased a license to one of my scripts, credit is not required. 
#    Otherwise, you must give credit to Khas (if you want, a link to my blog is 
#    always appreciated);
# 2. You can use the script for free in both non-commercial and commercial 
#    projects;
# 4. You can edit the script for using in your own project. However, you are 
#    not allowed to share/distribute any modified version;
# 5. If you want to share a Khas script, don’t post the direct download link,
#    redirect the user to my blog instead;
# 6. The script can not be ported to any RPG Maker version than VX Ace.
#
#-------------------------------------------------------------------------------
# * Instructions
#-------------------------------------------------------------------------------
# This script changes the original message system design and adds some new
# commands that can be used when displaying messages. Below you will find a
# list of these commands.
#
# Due to the unique design of this script, it's  recommended to think carefully
# about the windowskin that you will use (it's used for menus and choices).
#
# The Khas Message System is plug'n'play, you will need to import to your 
# project only the voice SE files of the actors.
#
#-------------------------------------------------------------------------------
# * Commands
#-------------------------------------------------------------------------------
# EXISTING COMMANDS
# \v[x] Variable X (int)
# \n[x] Actor X name (int)
# \p[x] Party member X name (int)
# \i[x] Draw icon X (int)
# \g    Currency unit
# \{    Increase text size
# \}    Decrease text size
# \$    Open money window
# \.    Pause (1/4 second)
# \|    Pause (1 second)
# \!    Wait for button
# \>    Instantly display (line)
# \<    Cancel above
# \^    Do not wait for next page
# \\    Backslash
# 
# NEW COMMANDS
# \c[color] Change text color (can be an hex color like #ffffff or
#           a color declared on the configuration part. Examples:
#           \c[#00ff00]
#           \c[green]
#
# \a[actor] Change the actor who's speaking. The actor must be declared
#           on the configuration part. Examples:
#           \a[Alice]
#           \c[Ernest]
#
# \s[time]  Shake the screen/balloon by the given time (in frames).
#           Example:
#           \s[20]
#
# \e[x]     Place the balloon over the event X.
#           Example:
#           \e[12]
#
# \p        Place the balloon over the player.
#
# \f        Make the balloon float (useful for a narrator).
# 
# \t[se]    Change the typing sound to the given sound effect.
#           Example: 
#           \t[female]
#
# \x[se]    Play the given sound effect.
#           Example: 
#           \x[Cat]
#
#-------------------------------------------------------------------------------
# * Message Core (configuration)
#-------------------------------------------------------------------------------
 
module Message_Core
  
  # ACTORS
  # Declare your actors here, using the following format:
  # "Actor Name" => ["color", "voice"]
  # Actor Name: the actor name to be used with \a[Actor Name]
  # color: the color name declared below
  # voice: the voice file inside Audio/SE
  Actors = {
    "Eric" => ["blue", "male"],
    "Natalie" => ["pink", "female"],
    "Terence" => ["yellow", "male"],
    "Ernest" => ["darkorange", "male"],
    "Ryoma" => ["teal", "male"],
    "Brenda" => ["gray", "female"],
    "Rick" => ["green", "male"],
    "Alice" => ["purple", "female"],
    "Isabelle" => ["purple", "female"],
    "Noah" => ["darkred", "male"],
    "Old Man" => ["gray", "male"],
    "Old Lady" => ["gray", "male"],
    "Monster" => ["darkred", "male"],
    "Boy" => ["blue", "male"],
    "Girl" => ["pink", "female"],
    "Lady" => ["purple", "female"],
    "Man" => ["green", "male"],
  }
  
  # COLORS
  # Declare your colors here, using the following format:
  # "colorname" => Color.new(R, G, B),
  # The colorname can be used with \c[colorname]
  Colors = {
    "white" => Color.new(255, 255, 255),
    "black" => Color.new(0, 0, 0),
    "orange" => Color.new(255, 144, 9),
    
    "blue" => Color.new(111, 147, 191),
    "pink" => Color.new(189, 74, 99),
    "yellow" => Color.new(222, 164, 86),
    "darkorange" => Color.new(171, 86, 36),
    "teal" => Color.new(39, 89, 97),
    "darkred" => Color.new(171, 61, 86),
    "purple" => Color.new(121, 83, 145),
    "green" => Color.new(92, 154, 75),
    "gray" => Color.new(135, 156, 176),
  }
  
  # MESSAGE BALLOON CONFIGURATION
  # Background color
  Background = Color.new(0,0,0,180)
  
  # Outline color
  Outline = Color.new(255,255,255,120)
  
  # Minimum width
  Minimum_Width = 80
  
  # Font properties
  Font_Name = "Arial"
  Font_Size = 18
  Font_Bold = true
  Font_Italic = false
  Font_Outline = false
  
  # SE VOLUME
  # Volume used to play voices
  SE_Volume = 80
  
  # PAUSE CYCLE
  # Number of frames to blink the cursor
  Pause_Cycle = 30
  
  # Change these only if you're having trouble with your font
  Standard_Padding = 4
  New_Line_X = 4 + Standard_Padding 
  New_Page_Y = 3
  
end
 
#-------------------------------------------------------------------------------
# * Default Font
#-------------------------------------------------------------------------------
 
Font.default_name = [Message_Core::Font_Name]
Font.default_size = Message_Core::Font_Size
Font.default_bold = Message_Core::Font_Bold
Font.default_outline = Message_Core::Font_Outline
Font.default_italic = Message_Core::Font_Italic
 
#-------------------------------------------------------------------------------
# * Sprite Message
#-------------------------------------------------------------------------------
 
class Sprite_Message < Sprite
  
  include Message_Core
  
  # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
  # * Initialize (Executed once)
  # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
  
  def initialize
    super(nil)
    initialize_sprite
    initialize_pause
    create_all_windows
    clear_instance_variables
  end
  
  def initialize_sprite
    self.bitmap = Bitmap.new(1,1)
    self.opacity = 0
    self.visible = false
    self.z = 200
  end
  
  def initialize_pause
    @pause_sprite = Sprite.new
    @pause_sprite.bitmap = Bitmap.new(3,3)
    @pause_sprite.bitmap.fill_rect(0,0,3,3,Colors["white"])
    @pause_sprite.visible = false
    @pause_sprite.z = self.z + 1
  end
  
  def create_all_windows
    @gold_window = Window_Gold.new
    @gold_window.x = Graphics.width - @gold_window.width
    @gold_window.y = 0
    @gold_window.openness = 0
    @choice_window = Window_ChoiceList.new(self)
    @number_window = Window_NumberInput.new(self)
    @item_window = Window_KeyItem.new(self)
  end
  
  def clear_instance_variables
    @fiber = nil
    @opening = false
    @closing = false
    @pause = false
    clear_flags
  end
  
  
  # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
  # * Dispose (Executed once)
  # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
  
  def dispose
    dispose_all_windows
    dispose_pause
    dispose_bitmap
    super
  end
  
  def dispose_all_windows
    @gold_window.dispose
    @choice_window.dispose
    @number_window.dispose
    @item_window.dispose
  end
  
  def dispose_bitmap
    self.bitmap.dispose if self.bitmap
  end
  
  def dispose_pause
    @pause_sprite.bitmap.dispose
    @pause_sprite.dispose
  end
  
  
  # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
  # * Update 
  # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
  
  def update
    update_effects
    update_all_windows
    update_fiber
  end
  
  def update_effects
    update_open if @opening
    update_close if @closing
    update_pause if @pause
    update_shake if @shake > 0
  end
  
  def update_all_windows
    @gold_window.update
    @choice_window.update
    @number_window.update
    @item_window.update
  end
  
  def update_fiber
    if @fiber
      @fiber.resume
    elsif $game_message.busy? && !$game_message.scroll_mode
      @fiber = Fiber.new { fiber_main }
      @fiber.resume
    else
      $game_message.visible = false
    end
  end
  
  def update_open
    self.opacity += 32
    @opening = (self.opacity < 255)
  end
  
  def update_close
    self.opacity -= 32
    @closing = (self.opacity > 0)
  end
  
  def update_pause
    if @pause_timer > 0
      @pause_timer -= 1
    else
      @pause_sprite.visible = !@pause_sprite.visible
      @pause_timer = Pause_Cycle
    end
  end
  
  def update_shake
    if @shake > 1
      self.ox = rand(17) - 8
      self.oy = rand(17) - 8
      @shake -= 1
    else
      stop_shake
    end
  end
  
  
  # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
  # * Effect Control 
  # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
  
  def open_and_wait
    @opening = true
    Fiber.yield while @opening
  end
  
  def close_and_wait
    @closing = true
    Fiber.yield until all_close?
  end
  
  def show_pause
    @pause_sprite.visible = true
    @pause = true
    @pause_timer = Pause_Cycle
  end
  
  def hide_pause
    @pause_sprite.visible = false
    @pause = false
  end
  
  def shake(duration)
    @shake = duration
  end
  
  def stop_shake
    self.ox = 0
    self.oy = 0
    @shake = 0
  end
  
  
  # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
  # * Main Processing 
  # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
  
  def fiber_main
    $game_message.visible = true
    self.visible = true
    loop do
      process_all_text if $game_message.has_text?
      process_input
      $game_message.clear
      @gold_window.close
      Fiber.yield
      break unless text_continue?
    end
    close_and_wait
    clear_balloon
    self.visible = false
    $game_message.visible = false
    @fiber = nil
  end
  
  
  # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
  # * Drawing processes
  # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
  
  def draw_balloon
    # Reset stuff for new balloon
    reset_font_settings
    reset_character_actor
    
    # Process text
    text = convert_escape_characters($game_message.all_text)
    scan_special_commands(text)
    text = remove_escape_characters(text)
    
    # Should the balloon float?
    @float = true if @character.nil?
    
    # Check if the balloon will have a namebox
    @namebox_yplus = (@actor ? text_size(@actor).height : 0)
    @voice = (@actor ? Actors[@actor][1] : nil)
    
    # Check if the balloon will have a detail
    @detail_yplus = (@float ? 0 : 10)
    
    # Calculate text dimensions
    tw = fitting_width(text)
    th = fitting_height(text) + @namebox_yplus + @detail_yplus
    
    # Check if the balloon needs to be inverted
    if invert_balloon?(th)
      @inverted = true
      @margin_top = @detail_yplus
      @margin_bottom = @namebox_yplus
    else
      @inverted = false
      @margin_top = @namebox_yplus
      @margin_bottom = @detail_yplus
    end
    
    # Calculate balloon dimensions
    balloon = Rect.new
    balloon.x = 0
    balloon.y = @margin_top
    balloon.width = tw > Minimum_Width ? tw : Minimum_Width
    balloon.height = th - @margin_top - @margin_bottom
    
    # Create a new bitmap
    self.bitmap.dispose if self.bitmap
    self.bitmap = Bitmap.new(balloon.width, th)
    reset_font_settings
    
    # Draw the balloon
    self.bitmap.fill_rect(balloon.x, balloon.y, balloon.width, balloon.height, Outline)
    self.bitmap.fill_rect(balloon.x+1, balloon.y+1, balloon.width-2, balloon.height-2, Background)
    
    # Draw the namebox
    draw_namebox(@inverted ? (th - @namebox_yplus - 2) : 0) if @actor
  end
  
  def clear_balloon
    self.bitmap.clear
  end
  
  def draw_namebox(y)
    rect = text_size(@actor)
    color = Colors[Actors[@actor][0]]
    color.alpha = Background.alpha
    self.bitmap.fill_rect(4,y,rect.width+10,rect.height+2,Outline)
    self.bitmap.fill_rect(5,y+1,rect.width+8,rect.height,color)
    self.bitmap.draw_text(9,y+1,rect.width,rect.height,@actor)
  end
  
  def draw_detail(x, y, reverse, upside_down)
    dx = (reverse ? 1 : 0)
    dy = (upside_down ? -1 : 1)
    x -= 12 if reverse
    for i in 12.downto(2)
      fill_line(x, y, i)
      x += dx
      y += dy
    end
  end
  
  def fill_rect(x, y, sx, sy)
    self.bitmap.fill_rect(x, y, sx, sy, Outline)
    self.bitmap.fill_rect(x+1, y+1, sx-2, sy-2, Background)
  end
  
  def fill_line(x, y, sx)
    self.bitmap.fill_rect(x, y, sx, 1, Outline)
    self.bitmap.fill_rect(x+1, y, sx-2, 1, Background)
  end
  
  
  # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
  # * Size/Position processing
  # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
  
  def move_balloon
    if @float
      x = (Graphics.width - width)/2
      y = Graphics.height - height - self.bitmap.font.size
    else
      # Get the actual character and its height
      bitmap = Cache.character(@character.character_name)
      sign = @character.character_name[/^[\!\$]./]
      if sign && sign.include?('$')
        cw = bitmap.width / 6
        ch = bitmap.height / 4
      else
        cw = bitmap.width / 24
        ch = bitmap.height / 8
      end
      
      # Calc initial position
      x = @character.screen_x - width / 2
      y = @character.screen_y - height - ch
 
      # Check if the ballon is out of the screen
      x = 2 if x < 2
      x = Graphics.width - width - 2 if (x + width) > (Graphics.width - 2)
      y = @character.screen_y if y < 0
      
      # Draw the detail
      reverse = @character.direction < 5
      sx = @character.screen_x - x + (reverse ? -cw : cw)
      if sx < 0
        reverse = !reverse
        sx = @character.screen_x - x + (reverse ? -cw : cw)
      elsif sx > self.bitmap.width
        reverse = !reverse
        sx = @character.screen_x - x + (reverse ? -cw : cw)
      end
      sy = (@inverted ? @margin_top : (self.bitmap.height - @margin_bottom - 1))
      draw_detail(sx, sy, reverse, @inverted)
    end
    
    # Set the position
    self.x = x
    self.y = y
    
    # Set the pause sprite position
    @pause_sprite.x = self.x + self.width - 6
    @pause_sprite.y = self.y + self.height - @margin_bottom - 6
  end
  
  def invert_balloon?(h)
    return false if @float
    bitmap = Cache.character(@character.character_name)
    sign = @character.character_name[/^[\!\$]./]
    char_height = bitmap.height / (sign && sign.include?('$') ? 4 : 8)
    @character.screen_y - h - char_height < 0
  end
  
  def width
    self.bitmap ? self.bitmap.width : 1
  end
  
  def height
    self.bitmap ? self.bitmap.height : 1
  end
  
  def text_width(text)
    result = 0
    text.each_line do |line|
      lw = text_size(line).width
      result = lw if lw > result
    end
    result
  end
  
  def text_height(text)
    result = 0
    text.each_line do |line|
      result += line_height(line)
    end
    result
  end
  
  def line_height(text)
    result = self.bitmap.font.size
    last_font_size = self.bitmap.font.size
    text.slice(/^.*$/).scan(/\e[\{\}]/).each do |esc|
      make_font_bigger  if esc == "\e{"
      make_font_smaller if esc == "\e}"
      result = [result, self.bitmap.font.size].max
    end
    self.bitmap.font.size = last_font_size
    result
  end
  
  def fitting_height(text)
    text_height(text) + Standard_Padding * 2
  end
  
  def fitting_width(text)
    text_width(text) + Standard_Padding * 2
  end
  
  
  # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
  # * Text processing
  # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
  
  def process_all_text
    text = convert_escape_characters($game_message.all_text)
    pos = {}
    new_page(text, pos)
    until text.empty?
      Fiber.yield if @skip_frame
      @skip_frame = !@skip_frame
      process_character(text.slice!(0, 1), text, pos)
    end
  end
  
  def new_page(text, pos)
    draw_balloon
    move_balloon
    open_and_wait if self.opacity < 255
    pos[:x] = New_Line_X
    pos[:y] = New_Page_Y + @margin_top
    pos[:new_x] = New_Line_X
    pos[:height] = line_height(text)
    clear_flags
  end
  
  def clear_flags
    @show_fast = false
    @pause_skip = false
    @skip_frame = false
    @sound = true
    @shake = 0
  end
  
  def text_continue?
    $game_message.has_text?
  end
  
  def update_show_fast
    @show_fast = true if Input.trigger?(:C)
  end
  
  def wait_for_one_character
    update_show_fast
    Fiber.yield unless @show_fast
  end
  
  def need_new_page?(text, pos)
    pos[:y] + pos[:height] > self.bitmap.height && !text.empty?
  end
  
  def process_new_page(text, pos)
    text.slice!(/^\n/)
    input_pause
    new_page(text, pos)
  end
  
  def process_draw_icon(icon_index, pos)
    bitmap = Cache.system("Iconset")
    rect = Rect.new(icon_index % 16 * 24, icon_index / 16 * 24, 24, 24)
    self.bitmap.blt(pos[:x], pos[:y], bitmap, rect)
    pos[:x] += 24
    wait_for_one_character
  end
  
  def process_escape_character(code, text, pos)
    case code.upcase
    when '$'
      @gold_window.open
    when '.'
      wait(15)
    when '|'
      wait(60)
    when '!'
      input_pause
    when '>'
      @show_fast = true
    when '<'
      @show_fast = false
    when '^'
      @pause_skip = true
    when 'C'
      change_color(text.slice!(/^\[#?\w+\]/)[/#?\w+/])
    when 'I'
      process_draw_icon(text.slice!(/^\[\d+\]/)[/\d+/].to_i, pos)
    when '{'
      make_font_bigger
    when '}'
      make_font_smaller
    when 'A'
      text.slice!(/^\[[\w\s]+\]/)
    when 'S'
      shake(text.slice!(/^\[\d+\]/)[/\d+/].to_i)
    when 'E'
      text.slice!(/^\[\d+\]/)
    when 'T'
      @voice = text.slice!(/^\[\w*\]/)[/\w*/]
      @voice = nil unless @voice.size > 0
    when 'X'
      Audio.se_play("Audio/se/#{text.slice!(/^\[\w+\]/)[/\w+/]}", SE_Volume)
    end
  end
  
  def convert_escape_characters(text)
    result = text.to_s.clone
    result.gsub!(/\\/)            { "\e" }
    result.gsub!(/\e\e/)          { "\\" }
    result.gsub!(/\eV\[(\d+)\]/i) { $game_variables[$1.to_i] }
    result.gsub!(/\eV\[(\d+)\]/i) { $game_variables[$1.to_i] }
    result.gsub!(/\eN\[(\d+)\]/i) { actor_name($1.to_i) }
    result.gsub!(/\eP\[(\d+)\]/i) { party_member_name($1.to_i) }
    result.gsub!(/\eG/i)          { Vocab::currency_unit }
    result
  end
  
  def remove_escape_characters(text)
    result = text.to_s.clone
    result.gsub!(/\ec\[#?\w+\]/i,"")
    result.gsub!(/\es\[\d+\]/i,"")
    result.gsub!(/\ee\[\d+\]/i,"")
    result.gsub!(/\ea\[[\w\s]+\]/i,"")
    result.gsub!(/\et\[\w*\]/i,"")
    result.gsub!(/\ex\[\w+\]/i,"")
    result.gsub!(/\ep/i, "")
    result.gsub!(/\ef/i, "")
    result.gsub!(/\e\|/, "")
    result.gsub!(/\e\./, "")
    result.gsub!(/\e\</, "")
    result.gsub!(/\e\>/, "")
    result.gsub!(/\e\^/, "")
    result
  end
  
  def scan_special_commands(text)
    if text =~ /\ep/i
      @character = $game_player
    end
    
    if text =~ /\ef/i
      @float = true
    end
    
    if text =~ /\ea\[([\w\s]+)\]/i
      @actor = $1 if Actors[$1]
    end
    
    if text =~ /\ee\[(\d+)\]/i
      @character = $game_map.events[$1.to_i] if $game_map.events[$1.to_i]
    end
    
  end
  
  def text_size(str)
    self.bitmap.text_size(str)
  end
  
  
  
  def process_character(c, text, pos)
    case c
    when "\n"   # New line
      process_new_line(text, pos)
    when "\f"   # New page
      process_new_page(text, pos)
    when "\e"   # Control character
      process_escape_character(obtain_escape_code(text), text, pos)
    else        # Normal character
      process_normal_character(c, pos)
    end
  end
  
  def process_normal_character(c, pos)
    char_width = text_size(c).width
    self.bitmap.draw_text(pos[:x], pos[:y], char_width * 2, pos[:height], c)
    pos[:x] += char_width
    Audio.se_play("Audio/se/#{@voice}") if @sound && c != " " && @voice
    @sound = !@sound
    
    wait_for_one_character
  end
 
  
  def process_new_line(text, pos)
    pos[:x] = pos[:new_x]
    pos[:y] += pos[:height]
    pos[:height] = line_height(text)
    if need_new_page?(text, pos)
      input_pause
      new_page(text, pos)
    end
  end
  
  def obtain_escape_code(text)
    text.slice!(/^[\$\.\|\^!><\{\}\\]|^[A-Z]/i)
  end
  
  
  # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
  # * Font 
  # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
  
  def reset_font_settings
    change_color("white")
    self.bitmap.font.size = Font.default_size
    self.bitmap.font.bold = Font.default_bold
    self.bitmap.font.italic = Font.default_italic
  end
  
  def change_color(code)
    if Colors[code]
      self.bitmap.font.color.set(Colors[code])
    elsif code =~ /#(..)(..)(..)/
      self.bitmap.font.color.set(Color.new($1.hex, $2.hex, $3.hex))
    end
  end
  
  def make_font_bigger
    self.bitmap.font.size += 8 if self.bitmap.font.size <= 64
  end
  
  def make_font_smaller
    self.bitmap.font.size -= 8 if self.bitmap.font.size >= 16
  end
  
  
  # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
  # * Input processing
  # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
  
  def process_input
    if $game_message.choice?
      input_choice
    elsif $game_message.num_input?
      input_number
    elsif $game_message.item_choice?
      input_item
    else
      input_pause unless @pause_skip
    end
  end
  
  def input_pause
    show_pause
    wait(10)
    Fiber.yield until Input.trigger?(:B) || Input.trigger?(:C)
    Input.update
    hide_pause
  end
  
  def input_choice
    @choice_window.start
    Fiber.yield while @choice_window.active
  end
  
  def input_number
    @number_window.start
    Fiber.yield while @number_window.active
  end
  
  def input_item
    @item_window.start
    Fiber.yield while @item_window.active
  end
  
  
  # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
  # * Other processing
  # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
  
  def close?
    (self.opacity == 0)
  end
  
  def all_close?
    close? && @choice_window.close? && @number_window.close? && @item_window.close?
  end
  
  def wait(duration)
    duration.times { Fiber.yield }
  end
  
  def reset_character_actor
    @float = false
    @actor = nil
    @character = nil
    if $game_map.interpreter.event_id && $game_map.events[$game_map.interpreter.event_id]
      @character = $game_map.events[$game_map.interpreter.event_id]
    end
  end
  
end
 
#-------------------------------------------------------------------------------
# * Scene Map
#-------------------------------------------------------------------------------
 
class Scene_Map < Scene_Base
  
  def create_message_window
    @message_window = Sprite_Message.new
  end
  
  def update_all_windows
    @message_window.update
    super
  end
  
  def dispose_all_windows
    @message_window.dispose
    super
  end
  
end
 
#-------------------------------------------------------------------------------
# * End
#-------------------------------------------------------------------------------

Salut.
J'ai pris le script de corbac83100 et j'ai corrigé les fautes d'orthographes.

Le voici le voilà :

#==============================================================================
#    Quest Journal [VXA]
#    Version: 1.0.3
#    Author: modern algebra (rmrk.net)
#    Date: 24 September 2012
#    Support: http://rmrk.net/index.php/topic,45127.0.html
#++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
# La description:
#
# Ce script fournit une interface graphique pour montrer les progrès de la quête. Il
# Est axée sur les objectifs, ce qui signifie que vous choisissez lors de révéler les objectifs et
# Vous pouvez le configurer de sorte qu'ils apparaissent comme terminée ou a échoué. Cela dit, cette
# Script ne construit pas des quêtes pour vous; il est seulement une scène supplémentaire pour
# Les montrer. En tant que tel, vous avez besoin à l'événement toutes les quêtes vous et
# Progrès de la quête de mise à jour via l'appel de script. Par conséquent, faites attention à
# Les instructions ici et dans les régions éditables sur les lignes 232 et 612.
# +++++++++++++++++++++++++++++++++++++++++++++++++ +++++++++++++++++++++++++++++
# Instructions:
#
# Collez ce script dans son propre ou les fentes, au-dessus et au-dessous principale
# Matériaux. Si vous utilisez la fonctionnalité d'accès au menu, vous devez mettre tout
# autres scripts de menu ci-dessus celui-ci.
#
# Tous de la configuration se fait dans le module Quête données. Bien qu'il ne soit pas
# Nécessaire, il est recommandé de séparer le module de configuration
# Du reste du script en coupant et collant dans sa propre fente
# Script Editor (comme vous le verrez si vous avez la démo). La raison pour
# Ceci est que, si et quand ce script est mis à jour, vous pouvez préserver la
# Section de configuration et seulement remplacer les autres parties du script. Si
# Que vous souhaitez faire, vous devez couper tout de la première ligne vers le bas pour
# L'extrémité finale du module. Les premières lignes du script de corps devrait être
# Les égaux bar juste au-dessus # ** Game_Quest. Encore une fois, il est à vous si
# Tu le fais.
#
# Vous pouvez aller à EDITABLE REGION A à la ligne 232 pour configurer la valeur par défaut
# paramètres du script. Tous ces éléments vont bien fonctionner sans modification,
# Bien sûr, mais même si vous ne voulez pas configurer maintenant, vous devez familiariser
#-Vous avec tous les paramètres afin que vous puissiez tirer le meilleur parti de votre
# Script. J'ai inclus des tonnes de paramètres de sorte que vous pouvez faire la quête
# Journal unique pour votre jeu, même jusqu'à l'ordre dans lequel chaque section
# De la fenêtre d'information est tirée. Une brève description de chaque réglage est
# Inclus soit à droite ou directement au-dessus de chaque constante.
#
# EDITABLE REGION B est le vrai coeur du script mais - ceci est où
# Vous remplissez tous les détails pour les quêtes. Lisez les instructions à
# Ligne 612 très attentivement!
#
# Vous pouvez activer et accéder à une quête avec ce code dans l'événement Script
# Commande:
#
# Quest (quest_id)
# Quest_id: l'ID d'entier de la quête que vous voulez accéder
#
# De là, vous pouvez accéder ou modifier les données pertinentes stockées dans la quête,
# Comme nom, description, objectifs, etc ... Exemple:
# Quête (1) .name = "Rest in Pieces"
#
# Plus pertinente, en ce qui concerne le contrôle de l'état d'avancement des quêtes les
# codes suivants peuvent être utilisés dans une commande d'événement Script. Les arguments sont
# La même chose pour chaque commande donc je n'expliquer une fois. Elles sont toutes
# Assez explicite et en utilisant l'un d'eux va activer la quête
# (Sauf si vous utilisez le MANUEL Révéler la mise à la ligne 267).
#
# Reveal_objective (quest_id, objective_id_1, ..., objective_id_n)
# Quest_id: l'ID d'entier de la quête que vous souhaitez accéder.
# Objective_id_1, ..., objective_id_n: une liste des ID de la
# objectifs que vous souhaitez opérer. Il peut être aussi peu qu'une ou comme
# Autant que chacun d'entre eux.
# Montrera les objectifs énumérés dans les informations de la Quête
#
# Conceal_objective (quest_id, objective_id_1, ..., objective_id_n)
# Cachera les objectifs énumérés dans les informations de la Quête
#
# Complete_objective (quest_id, objective_id_1, ..., objective_id_n)
# Change la couleur des objectifs énumérés à la couleur terminée.
# La quête est terminée une fois que tous les objectifs principaux sont.
#
# Uncomplete_objective (quest_id, objective_id_1, ..., objective_id_n)
# Change l'état des objectifs complets énumérés retour à actif
#
# Fail_objective (quest_id, objective_id_1, ..., objective_id_n)
# Change la couleur des objectifs énumérés à la couleur a échoué.
# La quête a échoué une fois un objectif premier est.
#
# Unfail_objective (quest_id, objective_id_1, ..., objective_id_n)
# Change l'état des objectifs énumérés échoué vers actif
#
# Change_reward_status (quest_id, valeur)
# Valeur: vrai ou faux. Si exclus, par défaut à true.
# Totalement facultatif, mais ceci est juste un interrupteur personnel que vous pouvez
# Tour quand la récompense est donnée. Vous pouvez alors faire une condition
# Afin de ne pas récompenser les joueurs plus d'une fois. (Voir la ligne 180)
#
# EXEMPLES:
# Reveal_objective (1, 0)
# Ce serait révéler le premier objectif de la quête avec ID 1
# Complete_objective (6, 2, 3)
# Ceci compléterait les troisième et quatrième objectifs de la quête avec ID 6
# Change_reward_status (8)
# Ce serait mettre le commutateur de récompense à vrai pour la recherche avec l'ID 8.
#
# Une autre nouveauté est la possibilité de définir des récompenses qui apparaîtra dans le
# Menu (voir EDITABLE REGION B). En plus de cela, vous pouvez utiliser ce qui suit
# Code pour distribuer automatiquement les récompenses spécifiées pour une quête si le
# Quête est terminée et aucune récompense n'a encore été donné:
#
# distribute_quest_rewards (quest_id)
# Quest_id: l'ID de la quête dont les récompenses que vous voulez distribuer
#
# Bien sûr, il ne peut distribuer les récompenses matérielles (objets, armes,
# blindages, or, ou exp). Il ne distribuera pas les récompenses que vous spécifiez par chaîne.
# À cette fin cependant, vous pouvez également utiliser ce code dans une branche conditionnelle et
# Elle sera satisfaite que si elle distribue les récompenses. Ainsi, si vous
# Voulait ajouter quelques récompenses spéciales ou faire des choses comme cela, vous pouvez simplement mettre
# Que dans la branche pour quand il est vrai. Cette fonctionnalité est pas vraiment
# Recommandé, car je pense qu'il est préférable de le faire par les événements.
#
# D'autres codes pour la commande d'événement Script qui peut être utile sont:
#
# Reset_quest (quest_id)
# Quest_id: l'ID d'entier de la quête que vous souhaitez accéder.
# Cette ré-initialiser la recherche, ce qui signifie tous les progrès de quête pour
# Date sera perdu
#
# Delete_quest (quest_id)
# Désactive la quête et réinitialise
#
# Conceal_quest (quest_id)
# Désactive la quête afin de ne pas apparaître dans la scène, mais les progrès
# Est enregistré
#
# Reveal_quest (quest_id)
# Active ou réactive la quête. Cette commande est nécessaire si
# MANUAL_REVEAL à la ligne 284 est vrai ou il a déjà été
# Caché. Sinon, il suffit simplement d'opérer sur la quête
#
# Change_quest_access (symbole:)
#: Symbole doit être l'une des six options (inclure le colon!):
#: Disable - empêche l'accès à la scène de la quête (gris dans le menu)
#: Enable - permet d'accéder à la scène de quête
#: Disable_menu - cela supprime l'option de recherche dans le menu
#: Enable_menu - ce qui ajoute l'option de recherche au menu
#: Disable_map - ce qui empêche l'accès par la clé de la carte
#: Enable_map - ce qui permet un accès par clé de la carte
#
# Change_quest_background( «bg_filename», bg_opacity, bg_blend_type)
# Bg_filename: le nom du fichier de l'image pour l'arrière-plan
# Le dossier Images
# Bg_opacity: l'opacité du graphique de fond. Si
# Exclus, la valeur par défaut à la valeur du paramètre à la ligne 434.
# Bg_blend_type: le type de l'image de fond de mélange. Si
# Exclus, la valeur par défaut à la valeur du paramètre à la ligne 437.
#
# change_quest_windows ( "windowskin_filename", le ton, l'opacité)
# Windowskin_filename: le nom de la bannière de la fenêtre dans la
# dossier Graphics System 
# Opacité: l'opacité des fenêtres. Si exclus,
# La valeur par défaut à la valeur du paramètre à la ligne 423.
# Blend_type: le blend_type des fenêtres. Si exclus,
# La valeur par défaut à la valeur du paramètre à la ligne 426.
#
# En outre, il y a quelques codes qui peuvent être utilisés dans la commande d'un script
# Branchement conditionnel. Je note ici que tous ces éléments sont en option. Vous pourriez
# interrupteur utilisation et les contrôles variables et les progrès de la quête du moniteur uniquement par
# événements. Cependant, ces commandes font un peu plus facile et ils sont:
#
# Quest_revealed? (Quest_id)
# Quest_id: l'ID d'entier de la quête que vous souhaitez accéder.
# Ceci est satisfaite si la quête a été activé.
#
# Quest_complete? (Quest_id)
# Ceci est satisfaite si tous les objectifs principaux de la recherche sont complets
#
# Quest_failed? (Quest_id)
# Ceci est satisfait si tout premier objectif de la quête a échoué
#
# Quest_rewarded? (Quest_id)
# Ceci est satisfait si vous avez modifié le statut de récompense pour vrai.
#
# Objective_revealed ? (Quest_id, objective_id_1 ... objective_id_n)
# Objective_id_1, ..., objective_id_n: une liste des ID de la
# objectifs que vous souhaitez opérer. Il peut être aussi peu qu'une ou comme
# Autant que chacun d'entre eux.
# Ceci est satisfait si les objectifs énumérés ont été révélés
#
# Objective_active ? (Quest_id, objective_id_1 ... objective_id_n)
# Ceci est satisfaite si tous les objectifs énumérés sont révélés et
# Ni complètes, ni échoué.
#
# Objective_complete? (Quest_id, objective_id_1 ... objective_id_n)
# Ceci est satisfaite si tous les objectifs énumérés ont été achevés
#
# Objective_failed ? (Quest_id, objective_id_1 ... objective_id_n)
# Ceci est satisfaite si tous les objectifs énumérés ont été omis
#
# Si vous voulez appeler la scène Quête d'un événement, vous utilisez ce qui suit
# Code dans un script d'appel:
#
# call_quest_journal
# Call_quest_journal (quest_id)
# Quest_id: ID de la quête que vous voulez ouvrir la scène sur
#
# Si vous ne spécifiez pas de quest_id (ligne 198), alors il sera tout simplement ouvrir la
# Scène comme il le ferait normalement. Si vous spécifiez un quest_id (ligne 199), alors il
# Ouvrira la scène sur cette quête aussi longtemps qu'il a été révélé et il est
# Normalement accessible via le menu de quête.
#
# Enfin, le chemin par défaut de ce script fonctionne est que les quêtes automatiquement
# Complète ou échouer en fonction de l'état des principaux objectifs. Cependant, vous
# Peut le mettre pour qu'il n'y ait pas d'objectifs premiers, dans ce cas, vous ne pouvez
# Complète, échouent, ou (re) activer une quête manuellement à travers le code suivant
# Dans un appel de script:
#
# Manually_complete_quest (quest_id)
# Quest_id: ID de la quête que vous souhaitez manuellement complète
# Manually_fail_quest (quest_id)
# Quest_id: ID de la quête que vous voulez à l'échec manuellement
# Manually_activate_quest (quest_id)
# Quest_id: ID de la quête que vous voulez activer manuellement
# ==============================================================================
 
$imported ||= {}
$imported[:"MA_QuestJournal_1.0"] = true
$imported[:"MA_QuestJournal_1.0.1"] = true
 
#==============================================================================
# *** QuestData
#++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
#  Ce module contient toutes les données de configuration pour le journal de quête
#==============================================================================
 
module QuestData
  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
  #  BEGIN éditable Région A
  #||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
  #  ACCÈS MENU - Si cela est vrai, vous pouvez accéder au journal de quête à travers une commande 
  # dans le menu. Si elle est fausse, il n'y aura pas une telle commande.
  MENU_ACCESS = true
  #  INDEX MENU - D'ACCES MENU est vrai, ce qui détermine où il apparaît
  MENU_INDEX = 4
  #  ACCESS MAP - Si cela est vrai, cela vous permet d'accéder au journal de quête par 
  # appuyant sur une touche sur la carte.
  MAP_ACCESS = true
  #  MAP_BUTTON - Si MAP_ACCESS est vrai, ce qui détermine quel bouton appelle la
  # Quête Journal
  MAP_BUTTON = :Q
  # OPEN_TO_LAST_REVEALED_QUEST - Si cela est vrai, alors la première fois que vous ouvrez le Journal 
  # quête après avoir révélé une nouvelle quête, il sera ouvert à la nouvelle quête.
  OPEN_TO_LAST_REVEALED_QUEST = true
  #  OPEN_TO_LAST_CHANGED_QUEST - Si cela est vrai , alors le Journal Quest ouvrir
  # La dernière quête dont le statut objectif a changé .
  OPEN_TO_LAST_CHANGED_QUEST = false
  # FENÊTRE WIDTH - La largeur, en pixels, de la fenêtre de liste
  LIST_WINDOW_WIDTH = 192
  # TYPES  DONNÉES DE BASE - Cela vous permet de configurer d'autres types de données. Juste 
  # incluent un signal d'identification dans le tableau. Ensuite, vous devez donner 
  # chaque signal une icône (dans le hachage ICONS à la ligne 322) et un texte de signal (dans 
  # le réseau de VOCAB à la ligne 333, mais il peut être une chaîne vide). Ensuite, vous 
  # pouvez définir les données lui-même lors de la configuration des quêtes en ajoutant simplement un: 
  # q [symbole] = "" 
  # ligne à la quête. Vous aurez également besoin d'inclure le type de données quelque part dans 
  # la disposition des données à la ligne 306. Comme exemple de cela, j'ai inclus: client 
  # et: emplacement par défaut. Vous pouvez CTRL + F pour rien dans cette section avec 
  # un de ces symboles (hors :) et vous y besoin d'ajouter quelque chose 
  # pour tous les nouveaux types de données que vous ajoutez.
  BASIC_DATA_TYPES = [:client, :location]
  # DONNÉES DE BASE LARGEUR - Ceci détermine combien d'espace, en pixels, est donné à 
  # tout type de données de base que vous définissez dans la fenêtre de données.
  BASIC_DATA_WIDTH = 240
  # ACTIVITÉ CONCURRENT - Si cela est vrai, alors quand dans la scène Quête Journal, vous pouvez passer 
  # catégories ou faire défiler la liste des quêtes en même temps. Si 
  # false, vous devez d'abord sélectionner une catégorie avant de pouvoir commencer 
  # faire défiler la liste de quête.
  CONCURRENT_ACTIVITY = true
  # HIDE CATEGORIE CURSOR - Si cela est vrai, alors la fenêtre Catégorie aura pas un 
  # curseur et au lieu simplement mettre en évidence la catégorie sélectionnée.
  # Ceci est mieux quand ACTIVITÉ CONCURRENT est vrai.
  HIDE_CATEGORY_CURSOR = true
  # SHOW_QUEST_ICONS - Si cela est vrai, alors l'icône que vous choisissez pour chaque quête
  # Être affiché à gauche de son nom dans la fenêtre Liste des quêtes
  SHOW_QUEST_ICONS = true
  # MANUEL Reveal - Si false, quêtes sera révélé au moment où vous 
  # premier révéler, complet, ou ne l'objectif. Si cela est vrai, vous 
  # besoin de révéler spécifiquement chaque quête via un appel de script distinct: 
  # révèle la quête (quête id)
  MANUAL_REVEAL = false
  # DATA LAYOUT - Ce contrôle la façon dont la fenêtre de quête expose toutes 
  # les données pertinentes. Si vous définissez l'une des entrées comme un tableau, alors toute 
  # des commandes, il sera établi en même y. A l'exception de: ligne, 
  # aucune des commandes sera établie si la quête est pas réglé pour avoir que 
  # données particulières. Les symboles sont: 
  #: Ligne - Dessine une ligne horizontale à travers la fenêtre. 
  #: Nom - Dessine le nom de la quête 
  #: niveau - Dessine le niveau de la quête 
  #: bannière - Dessine la bannière pour la quête 
  #: client - Dessine le client défini dans la quête (données de base) 
  #: emplacement - Dessine l'emplacement défini dans la quête (données de base) 
  #: Description - Tirages de la quête Description de 
  #: objectifs - Dessine tous les objectifs de la quête qui ont été révélées 
  #: récompenses - Dessine ce que les récompenses ont été mis en 
  # 
  # Vous aurez aussi besoin d'ajouter un entrée pour toute nouvelle BASIC_DATA que vous placez dans 
  # TYPES dE DONNÉES dE BASE à la ligne 264. 
  # 
  # Rappelez-vous de placer une virgule après chaque entrée. A noter également que ce n'est que la mise en page par défaut 
  #. Vous pouvez définir une mise en page différente pour toute quête, et quand 
  # visualiser cette quête, il sera la mise en page personnalisée qui est montré.
  DATA_LAYOUT = [
    [:line, :name, :level],
    :banner,
    :client,
    :location,
    :description,
    :objectives,
    [:line, :rewards],
    :line,
  ] # <= Ne touchez pas.
   # ICONS - C'est l'endroit où vous avez installé plusieurs des icônes utilisées dans le script. le
   # But de chacun est indiqué à côté de lui. En outre, si vous faites une coutume
   # catégories, vous devez leur donner une icône en plaçant une ligne comme
   # autres. Donc, si la nouvelle catégorie personnalisée est: la romance alors vous aurait besoin de
   # Défini comme ceci:
   # Roman: 107,
  ICONS = {
    all:         226, # L'icône de la catégorie Toutes les Quêtes
    active:      236, # L'icône de la catégorie Quêtes active
    complete:    238, # L'icône de la catégorie complète Quêtes
    failed:      227, # L'icône de la catégorie Quêtes Échec
    client:      121, # L'icône de données client. Si aucune voulait, mis à 0
    location:    231, # L'icône de données de localisation. Si aucune voulait, mis à 0
    reward_gold: 262, # L'icône pour les récompenses d'or. Si aucune voulait, mis à 0
    reward_exp:  117, # L'icône de récompenses exp. Si aucune voulait, mis à 0
  } # <= Ne touchez pas.
   # VOCABULAIRE - Cela vous permet de choisir quelques-uns des mots utilisés dans la scène de quête
  VOCAB = {
    # Étiquette de menu: Le nom de la commande dans le menu si ACCESS MENU est vrai
    menu_label:       "Quêtes",
    # étiquette de scène : L'étiquette en haut de la scène. Si elle est vide, pas de fenêtre
    scene_label:      "Journal de Quêtes",
    # Description: Le titre pour identifier la description
    description:      "Description",
    # objectifs: Le titre pour identifier les objectifs
    objectives:       "Objectifs",
    # balle objectif: La balle qui apparaît à la gauche de chaque 
    # objectif. Si% d est inclus, il affiche l'ID d'objectifs.
    objective_bullet: "?",
    # récompenses: Le titre pour identifier les récompenses.
    rewards:          "Récompenses",
    # récompenser montant: Pour objets de récompense, ceci est le texte pour montrer la quantité. 
    # Il devrait inclure% d pour montrer la quantité.
    reward_amount:    "x%d",
    # récompenser l'or: texte pour identifier les récompenses d'or
    reward_gold:      "Rubis",
    # récompense exp: texte pour identifier les récompenses exp
    reward_exp:       "",
    # niveau: Si LEVEL_ICON est 0, ceci est le texte qui précède le niveau
    level:            "Rang: ",
    # Situation: L'étiquette de texte pour l'emplacement de quête
    location:         "",
    # Lieu: L'étiquette de texte pour le client de quête
    client:           "",
  } # <= Ne touchez pas. 
  # CATEGORIES - Ce tableau vous permet de définir les catégories sont disponibles 
  # dans la scène de Quest. Les catégories par défaut sont: tous,: actif,: complet, 
  # et: a échoué, et leurs noms sont explicites. Vous pouvez ajouter des 
  # catégories, mais notez que vous devez vous assurer que chaque nouvelle 
  # catégorie a une icône située dans le hachage ICONS, ainsi qu'un jeu d'étiquettes dans le hachage 
  # CATEGORIE VOCAB (si vous utilisez MONTRER CATÉGORIE LABEL). Il est également conseillé 
  # pour lui donner un type de tri, sauf si vous êtes bien avec elle étant triés par ID 
  #, comme cela est par défaut.
  CATEGORIES = [:all, :active, :complete, :failed]
  #  MONTRER CATEGORIE LABEL - Cela vous permet de choisir d'afficher ou non le nom 
  # de la catégorie sélectionnée. Si cela est vrai, il choisira le nom sur 
  # de la table de hachage CATEGORIE VOCAB.
  SHOW_CATEGORY_LABEL = true
  #  CATEGORIE LABEL_IN_SAME_WINDOW - Si SHOW_CATEGORY_LABEL est vrai, alors ce 
  # Options vous permet de choisir si l'étiquette est affichée dans la même fenêtre que 
  # les icônes de catégorie ou dans une fenêtre séparée ci-dessous. true = même fenêtre.
  CATEGORY_LABEL_IN_SAME_WINDOW = true
  #  CATEGORIE VOCABULAIRE - Si SHOW_CATEGORY_LABEL est vrai, ce hachage vous permet de définir la 
  # étiquette pour chaque catégorie. Pour toutes les catégories personnalisées que vous créez, vous 
  # besoin d'ajouter une ligne pour chaque ci-dessous et dans le même format: #: category => "label", 
  # Ne pas oublier d'ajouter la virgule à la fin de chaque ligne.
  CATEGORY_VOCAB = {
    :all =>      "Toutes les quêtes",      # The label for the :all category
    :active =>   "Quêtes actives",   # The label for the :active category
    :complete => "Quêtes complétés", # The label for the :complete category
    :failed =>   "Quêtes échouées",   # The label for the :failed category
  } # <= Ne touchez pas. 
  # SORT TYPE - Ce hachage vous permet de choisir comment chaque catégorie est triée. 
  # Pour chaque catégorie, par défaut ou personnalisé, vous pouvez définir une autre méthode de tri 
  # Il y a sept options à choisir: 
  #: id - Les quêtes sont triées de la plus faible à ID le plus élevé 
  #: alphabet - Les quêtes sont triés par ordre alphabétique 
  # : niveau - les quêtes sont triés du plus bas au plus haut niveau 
  #: révèlent - les quêtes sont triées de la plus récemment révélé sur. 
  # Chaque fois qu'une nouvelle quête est révélée, il sera au sommet. 
  #: Changement - Les quêtes sont classifiées de celui dont le statut le plus récent 
  # changé sur. Ainsi, chaque fois qu'un objectif est modifié, cette quête 
  # sera jeté vers le haut. 
  #: Toutes - Les quêtes sont triés du plus récemment terminé sur. 
  # Chaque fois qu'une quête est terminée, il sera jeté vers le haut. 
  #: Échec - Les quêtes sont triés du plus récemment échoué sur. 
  # Chaque fois qu'une quête échoue, il sera jeté vers le haut.
  #
  # De plus, vous pouvez mettre _r à la fin de l'une des options de tri et 
  # allez inverser l'ordre. Ainsi, par exemple, si la méthode de tri pour une catégorie 
  # est: alphabet r, les quêtes s'affichera de Z-A 
  #: échoué - Les quêtes sont triées de la plus récemment échoué sur. 
  # Chaque fois qu'une quête échoue, il sera jeté vers le haut.
  SORT_TYPE = {
    :all =>      :id,       # Sort type for the All Quests category
    :active =>   :change,   # Sort type for the Active Quests category
    :complete => :complete, # Sort type for the Complete Quests category
    :failed =>   :failed,   # Sort type for the Failed Quests category
  } # <= Ne touchez pas. 
  # WINDOW PEAU - La peau de fenêtre pour chaque fenêtre dans la scène Quest. Il doit 
  # se référer à un graphique dans le dossier système de Graphics. Si elle est définie sur false, 
  # il utilisera tout ce qui est windowskin par défaut. Si vous utilisez un script qui 
  # permet au joueur de choisir le windowskin, false est la valeur recommandée.
  WINDOWSKIN = false
  #  WINDOW TO - La tonalité de chaque fenêtre. Il doit être un tableau sous la forme: TONE 
  # WINDOW = [rouge, vert, bleu, gris] 
  # gris peut être exclue, mais les trois autres doivent être présents. Si vous définissez cette 
  # valeur à false, les fenêtres ont tout ce ton est par défaut.
  WINDOW_TONE = false
  # WINDOW OPACITY - L'opacité des fenêtres de la scène Quest. Si la valeur 
  # false, il utilisera l'opacité par défaut pour les fenêtres.
  WINDOW_OPACITY = false
  # BG_PICTURE - Ceci est une chaîne faisant référence à une image dans le dossier Image
  # Graphics. Si réglé sur "", alors il n'y aura pas d'image. Dans le cas contraire, il
  # Affiche l'image sélectionnée sous les fenêtres mais au-dessus de la carte en
  # La scène Quest.
  BG_PICTURE = ""
  # BG OPACITY - Cela vous permet de définir l'opacité de l'image de fond, 
  # si vous avez sélectionné.
  BG_OPACITY = 255
  # BG_BLEND_TYPE - Cela vous permet de définir le type de l'arrière-plan de mélange
  # Photo, si vous avez sélectionné.
  BG_BLEND_TYPE = 0
  # DESCRIPTION_IN_BOX - Ceci est une option graphique, et il vous permet de
  # Choisir si la description doit être affiché dans une boîte.
  DESCRIPTION_IN_BOX = true
  #  LEVEL_ICON - This sets how levels are shown. If set to an integer, then it
  # will draw the same icon numerous times up to the level of the quest. Ie. If
  # the level's quest is 1, then the icon will only be drawn once, but if the
  # level's quest is 4, it will be drawn 4 times. LEVEL_ICONS_SPACE determines
  # the space between them. If you set LEVEL_ICON to 0, however, then it will
  # instead draw a signal for the level, corresponding to that index in the
  # LEVEL_SIGNALS array. If the LEVEL_SIGNALS array is empty, then it will just
  # draw the integer for the level. Finally, LEVEL_ICON can also be an array of
  # integers, in which case the level will be represented only by the icon set
  # which corresponds to it in the array.
  LEVEL_ICON = 125
  # NIVEAU ICÔNES SPACE - Si ICON LEVEL est un entier, cela est la quantité de 
  # espace entre chaque fois que l'icône est dessinée.
  LEVEL_ICONS_SPACE = 16
  #  SIGNAUX DE NIVEAU - Si LEVEL_ICON est 0, ce qui vous permet de définir quelle chaîne 
  # devrait être le signal pour chaque niveau. Si ce tableau est vide, alors il sera juste 
  # tirer l'entier de niveau. C'est à dire. si la quête est de niveau 4, il attirera 4.
  LEVEL_SIGNALS = ["F", "E", "D", "C", "B", "A", "S"]
  #  COLOURS - Cela vous permet de modifier la couleur des différents aspects de la scène 
  # quête. Chacun peut être défini dans l'une des trois façons: 
  #: symbole - Si vous utilisez un symbole, la couleur sera le résultat de l'appel 
  # la méthode du même nom. Par exemple, si vous définissez quelque chose à 
  #: system_color, il définir la couleur du résultat de la méthode de la couleur 
  # système Windows Base. 
  # Entier - Si vous réglez la couleur à un nombre entier, il prendra sa 
  # couleur dans la palette de windowskin, tout comme l'utilisation \ c [x] dans les messages. 
  # Array - Vous pouvez également définir les valeurs de rgba directement avec un tableau dans le format 
  #: [rouge, vert, bleu, alpha]. alpha peut être exclue, mais vous devez 
  # avoir des valeurs pour le rouge, le vert et le bleu.
  COLOURS = {
    # Actif: Ceci définit la couleur pour les quêtes actives dans la liste et le nom
    # De la quête active lorsque apparaît dans la fenêtre de données.
    active:           :normal_color,
    # Complète: Ceci définit la couleur pour les quêtes dans la liste et le
    # Nom de la quête terminée lorsque apparaît dans la fenêtre de données.
    complete:         3,
    # A échoué: Ceci définit la couleur pour les quêtes échoué dans la liste et le nom
    # De la quête a échoué lorsque affiché dans la fenêtre de données.
    failed:           10,
    # Ligne: Ceci définit la couleur des lignes ou des boîtes dessinée dans la scène de quête
    line:             :system_color,
    # Ligne ombre: Ceci définit la couleur de l'ombre pour les lignes ou les boîtes dessinée 
    # dans la scène de quête
    line_shadow: [0, 0, 0, 128],
    # Label scène: Ceci définit la couleur de l'étiquette de la scène, se montre
    scene_label:      :system_color,
    # Catégorie label: Ceci définit la couleur pour la catégorie étiquette, si montré
    category_label:   :normal_color,
    #le signal de niveau : Ceci définit la couleur pour le signal de niveau, si montré
    level_signal:     :normal_color,
    # objective_bullet: Ceci définit la couleur pour les objectifs; si mis à
    #: Maqj_objective_color, il reflétera l'état d'achèvement du
    # Objectif, mais vous pouvez le changer à autre si vous préférez quelque chose
    objective_bullet: :maqj_objective_color,
    # Montant de la récompense: La couleur de la quantité de l'article, lorsqu'elle est présentée
    reward_amount:    :normal_color,
    # rubrique: La couleur de toutes les rubriques dans le script, comme "Description"
    heading:          :system_color,
    # étiquette de base: Pour les données de base, comme client, la couleur de l'étiquette
    basic_label:      :system_color,
    # valeur de base: Pour les données de base, comme client, la couleur de la valeur
    basic_value:      :normal_color,
  } # <= Ne touchez pas. 
   # RUBRIQUE ALIGN - Cela définit l'alignement pour les aspects énumérés. 0 est à gauche; 
   # 1 est Centre; 2 est droit
  HEADING_ALIGN = {
    description: 0, # Alignement de la tête Description
    objectives:  0, # Alignement de la rubrique Objectifs
    rewards:     1, # Alignement de la rubrique Récompenses
    level:       2  # Alignement en montrant le niveau
  } # <= Do not touch.
  #````````````````````````````````````````````````````````````````````````````
  #    Aspects Font 
  # 
  # Toutes les options suivantes (noms de police, la TAILLES, FONTBOLDS et 
  # POLICES italiques) vous permettent de modifier les polices utilisées pour divers aspects de la 
  # scène. Le seul qui y est mentionnée par défaut est :, normale qui est la 
  # police utilisée par défaut pour toute la scène. Cependant, vous pouvez modifier les polices 
  # pour presque tous les aspects - tout ce que vous devez faire est d'ajouter une ligne comme ceci:
  #
  #    description: valeur,
  #
  # Et cela va changer cet aspect de la police lors de l'élaboration de la description. le
  # symboles suivants sont disponibles pour le changement:
  #
  #   normal:         La police par défaut utilisée pour chaque partie de la scène
  #   list:           La police utilisée dans la fenêtre Liste
  #   scene_label:    Tla police utilisée lors de l'élaboration du label Scène, si montré
  #   category_label: The font used when drawing the Category Label, if shown
  #   heading:        The font used when drawing any headings, like "Description"
  #   name:           The font used when drawing the quest name in data window
  #   description:    The font used when drawing the Description
  #   objectives:     The font used when drawing the objectives
  #   rewards:        The font used when drawing the rewards
  #   client:         The font used when drawing the client
  #   location:       The font used when drawing the location
  #
  # Pour l'un d'eux, vous devez définir une valeur. Qu'est-ce que la valeur peut être dépend
  # Sur lequel la police aspect que vous modifiez et est décrit ci-dessous, mais pour tout
  # De les mettre à la fausse signifie qu'il sera tout simplement utiliser la valeur par défaut
  #
  # For any that you add, remember that you must put a comma after the value.
  #````````````````````````````````````````````````````````````````````````````
  #  FONTNAMES - Here you can change the font used for any of the various
  # options. It can take any of the following types of values:
  #     false    - The default font will be used
  #     "String" - The font with the name "String" will be used.
  #     [Array]  - The array must be in the form: ["String1", "String2", ...]
  #               The font used will be the first one in the array that the
  #               player has installed.
  #
  #  EXAMPLES:
  #
  #    normal:      false,
  #     La police utilisée pour les aspects non altérées de la scène est l'étiquette 
  # scène de police par défaut: "algérien", 
  # La police utilisée pour le label de Scène sera algérienne. 
  # Description: [ "Cambria", "Times New Roman"], 
  # La police utilisée lors de l'élaboration de la description sera Cambria si le joueur 
  # a installé Cambria. Si le joueur n'a pas de Cambria 
  # installé, la police utilisée sera Times New Roman
  FONTNAMES = {
    normal: false, # normal: the default font name
  } # <= Do not touch.
  #  FONTSIZES - Here you can change the size of the font. There are two types
  # of values you can set:
  #    false   - The default fontsize will be used
  #    Integer - The fontsize will be equal to the value of the Integer.
  #  
  # For everything but the label windows, this shouldn't exceed 24, since that
  # is the line_height. However, for scene_label: and category_label:, the size
  # of the window will be adjusted to whatever size you set the font.
  FONTSIZES = {
    normal:         false, # normal: default font size
    scene_label:    28,    # scene_label: fontsize for the Scene Label window
    category_label: 24,    # category_label: fontsize for Category Label window
  } # <= Do not touch.
  #  FONTBOLDS - Here you can set whether the font will be bolded. You can set
  # it to either false, in which case it will not be bolded, or true, in which
  # case it will be bolded.
  FONTBOLDS = {
    scene_label:  true, # scene_label: whether font is bold for Scene Label
    heading:      true, # heading: whether font is bold for the headings
    level_signal: true, # level_signal: whether font is bold for level
  } # <= Do not touch.
  #  FONTITALICS - Here you can set whether the font will be italicized. You
  # can set it to either false, in which case it will not be italicized, or
  # true, in which case it will be italicized.
  FONTITALICS = {
  }
  #||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
  #  END Editable Region A
  #//////////////////////////////////////////////////////////////////////////
  CATEGORIES = [:all] if !CATEGORIES || CATEGORIES.empty?
  VOCAB.default = ""
  ICONS.default = 0
  CATEGORY_VOCAB.default = ""
  SORT_TYPE.default = :id
  COLOURS.default = :normal_color
  HEADING_ALIGN.default = 0
  FONTNAMES.default = false
  FONTSIZES.default = false
  FONTBOLDS.default = false
  FONTITALICS.default = false
  #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  # * Setup Quest
  #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  def self.setup_quest(quest_id)
    q = { objectives: [] }
    case quest_id
    #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
    #  BEGIN Editable Region B
    #||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
    #   Configuration Quest
    #
    # Ceci est l'endroit où vous configurez les données pour toutes les quêtes dans le jeu. Tandis que
    # Il peut sembler compliqué, je vous invite à faire attention et, une fois que vous obtenez
    # Le coup de lui, je suis sûr qu'il va rapidement devenir une seconde nature.
    #
    # Chaque quête unique devrait être mis en place dans le format suivant, mais la note
    # Que si vous n'êtes pas tout ce paramètre pour un aspect particulier, vous pouvez
    # Supprimer cette ligne. Quoi qu'il en soit, voici ce que chaque quête devrait ressembler, avec
    # Les valeurs sur la gauche étant les valeurs par défaut si vous ne les définissez pas:
    #
    #  when quest_id
    #   q[:name]              = "??????"
    #   q[:icon_index]        = 0
    #   q[:level]             = 0
    #   q[:description]       = ""
    #   q[:banner]            = ""
    #   q[:banner_hue]        = 0
    #   q[:objectives][0]     = ""
    #   q[:objectives][1]     = ""
    #   q[:objectives][2]     = ""
    #   q[:objectives][n]     = ""
    #   q[:prime_objectives]  = [0, 1, 2, n]
    #   q[:custom_categories] = []
    #   q[:client]            = ""
    #   q[:location]          = ""
    #   q[:rewards]           = []
    #   q[:common_event_id]   = 0
    #   q[:layout]            = false
    #
    #  Pour chaque ligne, à l'exception des objectifs, il est seulement la valeur
    # Le droit du signe égal que vous aurez besoin de changer. Maintenant je vais
    # Expliquer chaque ligne:
    #
    # when quest_id
    #    quest_id - est un entier de votre choix, ce qui est la façon dont vous
    # Référence une quête afin de faire avancer et de faire autre chose. Il
    # Doit être unique pour chaque quête; si vous utilisez 1 pour la première quête,
    # Vous ne pouvez pas utiliser 1 pour toute autre quête.
    #
    #   q[:name]              = ""
    #     "" - Cette ligne définit le nom de la quête qui montre dans la quête
    # Liste.
    #  
    #   q[:icon_index]        = 0
    #     0  - Cette ligne définit l'icône à utiliser pour cette quête. Il montrera 
    # à la gauche du nom de l'invité dans la Liste des quêtes.
    #
    #   q[:level]             = 0
    #     0  - Cette ligne définit le niveau de la quête. Si 0 , aucun niveau sera
    # Montré . Voir les options de niveau de lignes 441-458 pour plus de détails .
    #  
    #   q[:description]       = ""
    #    "" - Cette ligne définit la description de la quête. Vous pouvez utiliser un message
    # codes dans cette chaîne , mais si vous utilisez " " alors vous devez utiliser
    # \\ Pour identifier les codes et pas seulement \ . C'est à dire. Il est \\ v [x] , pas \ v [x]
    #
    #   q[:objectives][0]     = ""
    #   q[:objectives][1]     = ""
    #   q[:objectives][2]     = ""
    #   q[:objectives][n]     = ""
    #  Les objectifs sont légèrement différents. Remarqué que, après q [objectifs] sur 
    # chaque ligne il y a un nombre entier entre crochets: 
    # [n] - Ceci est l'ID de l'objectif, et n doit être un entier. No 
    # quête peut avoir plus d'un objectif avec le même ID. Ceci est 
    # comment vous identifier quel objectif vous voulez révéler, complète ou 
    # échouez. Cela dit, vous pouvez faire autant d'objectifs que vous voulez, comme 
    # longtemps que vous leur donnez tous les ID distincts. Les ID doivent être en 
    # séquence aussi, donc il ne devrait pas être un q [objectifs] [5] si 
    # il n'y a pas q [objectifs] [4]. 
    # "" - Ceci est le texte de l'objectif. Vous pouvez utiliser des codes de message dans 
    # cette chaîne, mais si vous utilisez "" alors vous aurez besoin d'utiliser 
    # \\ pour identifier les codes et pas seulement \. Ie: Il est \\ v [x], pas \ v [x] #
    #   q[:prime_objectives]  = [0, 1, 2, n]
    #     [0, 1, 2, n] - Ce tableau détermine quels objectifs doivent être
     # Achevé pour que la quête soit complète. En d'autres termes,
     # Tous les objectifs avec les ID de ce tableau doivent être
     # Complet pour la quête pour être complète. Si l'un d'eux est
     # A échoué, la quête sera échoué. Si vous supprimez cette ligne
     # Tout à fait, tous les objectifs sont premiers. Si vous réglez cette option sur [],
     # Puis la quête ne sera jamais automatiquement terminée ou a échoué et
     # Vous devez utiliser les options manuelles décrites aux lignes 208-219.
    #
    #   q[:custom_categories] = []
    #     [] - Cela vous permet de définir un éventail de catégories personnalisées pour cette 
    # quête, ce qui signifie que cette quête sera affiché dans chacune de ces 
    # catégories si vous l'ajoutez au tableau CATÉGORIES à la ligne 370. 
    # Notez que chaque catégorie que vous faites doit être identifié par un unique, 
    #: symbole, et vous devez configurer tous les détails des catégories pour ce 
    #: symbole.
    #
    #   q[:banner]            = ""
    #     "" - Cette ligne définit la bannière à utiliser pour une quête. Il doit être
    # Nom de l'image dans le dossier Images de Graphics.
    #
    #   q[:banner_hue]        = 0
    #     0 - La teinte de la bannière graphique, si elle est utilisée
    #
    #   q[:client]            = ""
    #     "" - Cette ligne définit le nom du client pour cette quête. (donnee de base)
    #
    #   q[:location]          = ""
    #     "" - Cette ligne définit l'emplacement de la quête. (donnee de base)
    #
    #   q[:rewards]           = []
    #    [] - Dans ce tableau, vous pouvez identifier notamment les récompenses qui seront
    # arriver. Chaque récompense devrait être dans son propre réseau et peut être l'un des
    # le suivant:
    #          [:item, ID, n],
    #          [:weapon, ID, n],
    #          [:armor, ID, n],
    #          [:gold, n],
    #          [:exp, n],
    #       où ID est l'ID de l'élément, l'arme ou l'armure que vous voulez 
    # distribué et n est la quantité de l'élément, arme, armure, or, 
    # ou de l'expérience que vous voulez distribué. En outre, vous pouvez également définir 
    # texte à apparaître dans le format de récompenses, mais qui ne serait pas 
    # distribué automatiquement. Vous auriez besoin de spécifier ce type de texte 
    # récompense dans le format suivant: 
    # [: string, icon_index, "string", "vocab"], 
    # où l'index de l'icône est l'icône pour être montré, "string" est ce que vous 
    # apparaîtrait comme la quantité, et "vocab" est ce qui apparaîtra comme une étiquette 
    # entre l'icône et le montant.
    #      
    #
    #   q[:common_event_id]   = 0
    #     0  - Cela vous permet d'appeler immédiatement l'événement commun identifiés
    # Et automatiquement une fois la quête terminée. Il est en général
    # Pas recommandé, comme pour la plupart des quêtes que vous devriez le contrôlez
    # Assez pour ne pas avoir besoin de cette fonctionnalité.
    #
    #   q[:layout]            = false
    #     false - La valeur par défaut pour ce qui est faux , et quand il est fausse, le
    # Mise en page pour la quête sera héritée de la valeur par défaut que vous définissez à
    # 302. Cependant, vous pouvez également donner la quête de sa propre mise en page - la
    # Le format serait le même que celui défini pour la valeur par défaut à la ligne 307 .
    #  
    # Template:
    #
    #  Lorsque vous effectuez une nouvelle quête , je recommande que vous copiez et collez le
    # Suivant modèle, la suppression selon les lignes que vous ne voulez pas modifier .
    # Naturellement, vous devez retirer le # ~ . Vous pouvez le faire en mettant en évidence
    # La chose entière et en appuyant sur CTRL + Q :
# ~ when 2 # < = RAPPEL: La Quête ID DOIT être unique
#~       q[:name]              = "??????"
#~       q[:icon_index]        = 0
#~       q[:level]             = 0
#~       q[:description]       = ""
#~       # RAPPEL: Vous pouvez faire autant d'objectifs que vous le souhaitez, mais chacun doit
# ~      # Ont un identifiant (ID) unique.
#~       q[:objectives][0]     = ""
#~       q[:objectives][1]     = ""
#~       q[:objectives][2]     = ""
#~       q[:prime_objectives]  = [0, 1, 2]
#~       q[:custom_categories] = []
#~       q[:banner]            = ""
#~       q[:banner_hue]        = 0
#~       q[:client]            = ""
#~       q[:location]          = ""
#~       q[:rewards]           = []
#~       q[:common_event_id]   = 0
    when 1 # Quest 1 - SAMPLE QUEST
      q[:name]              = "Nouveau"
      q[:level]             = 1
      q[:icon_index]        = 7
      q[:description]       = "Va chez le barman pour en savoir plus."
      q[:objectives][0]     = "Rentrer au bar."
      q[:objectives][1]     = "Lui parler."
      q[:objectives][2]     = "Acheter 1 carrote."
      q[:objectives][3]     = "Parler à la personne au cheveux blanc."
      q[:prime_objectives]  = [1, 2]
      q[:custom_categories] = []
      q[:banner]            = ""
      q[:banner_hue]        = 0
      q[:client]            = "Barman"
      q[:location]          = "Bar"
      q[:common_event_id]   = 0
      q[:rewards]           = [
        [:item, 1, 3],
        [:gold, 500],
      ]
      q[:layout]            = false
    #||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
    #  END Editable Region B
    #//////////////////////////////////////////////////////////////////////
    end
    q
  end
end
 
#==============================================================================
# *** DataManager
#++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
#  Summary of Changes:
#    aliased method - self.extract_save_contents
#==============================================================================
 
class << DataManager
  #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  # * Extract Save Contents
  #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  alias maqj_extractsavecons_2kw5 extract_save_contents
  def extract_save_contents(*args, &block)
    maqj_extractsavecons_2kw5(*args, &block) # Call Original Method
    if $game_party.quests.nil?
      $game_party.init_maqj_data
      $game_system.init_maqj_data
    end
  end
end
 
#==============================================================================
# ** MAQJ_SortedArray
#++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
#  This module mixes in to an array to maintain the sorted order when inserting
#==============================================================================
 
module MAQJ_SortedArray
  #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  # * Insert to Array
  #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  def maqj_insert_sort(el, &block)
    index = bsearch_index(el, 0, size, &block)
    index ? insert(index, el) : push(el)
  end
  #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  # * Retrieve Index from Binary Search
  #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  def bsearch_index(el, b = 0, e = size, &block)
    return bsearch_index(el, b, e) { |a,b| a <=> b } if block.nil?
    return b if b == e # Return the discovered insertion index
    return if b > e
    m = (b + e) / 2    # Get Middle
    block.call(el, self[m]) > 0 ? b = m + 1 : e = m 
    bsearch_index(el, b, e, &block) 
  end
end
 
#==============================================================================
# ** Game_Quest
#++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
#  This class holds all instance data for a quest
#==============================================================================
 
class Game_Quest
  #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  # * Public Instance Variables
  #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  attr_reader   :id                  # Unique identifier for this quest
  attr_reader   :name                # The name to be shown for the quest
  attr_reader   :level               # The level of difficulty of the quest
  attr_reader   :objectives          # An array of objective strings
  attr_reader   :prime_objectives    # An array of crucial objective IDs
  attr_reader   :revealed_objectives # An array of revealed objective IDs
  attr_reader   :complete_objectives # An array of completed objective IDs
  attr_reader   :failed_objectives   # An array of failed objective IDs
  attr_reader   :custom_categories   # An array of category symbols
  attr_accessor :icon_index          # Icon associated with this quest
  attr_accessor :common_event_id     # ID of common event to call upon complete
  attr_accessor :description         # The description for the quest
  attr_accessor :banner              # Picture shown to represent the quest
  attr_accessor :banner_hue          # The hue of the banner
  attr_accessor :layout              # The layout of this quest in scene
  attr_accessor :rewards             # An array of rewards to show
  attr_accessor :reward_given        # Boolean tracking if quest was rewarded
  attr_accessor :concealed           # Whether or not the quest is visible
  attr_accessor :manual_status       # Quest status if not using prime objectives
  QuestData::BASIC_DATA_TYPES.each { |data_type| attr_accessor(data_type) }
  #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  # * Object Initialization
  #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  def initialize(quest_id)
    @id = quest_id
    @concealed = default_value_for(:concealed)
    @reward_given = default_value_for(:reward_given)
    reset
  end
  #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  # * Reset
  #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  def reset
    data = QuestData.setup_quest(@id)
    data_symbol_array.each { |meth| instance_variable_set(:"@#{meth}", 
      data[meth] ? data[meth] : default_value_for(meth)) }
    @revealed_objectives = [].send(:extend, MAQJ_SortedArray)
    @complete_objectives = [].send(:extend, MAQJ_SortedArray)
    @failed_objectives =   [].send(:extend, MAQJ_SortedArray)
    @manual_status = default_value_for(:manual_status)
  end
  #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  # * Data Symbol Array
  #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  def data_symbol_array
    [:name, :level, :objectives, :prime_objectives, :custom_categories, 
      :icon_index, :description, :banner, :banner_hue, :common_event_id, 
      :layout, :rewards] + QuestData::BASIC_DATA_TYPES
  end
  #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  # * Default Value
  #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  def default_value_for(method)
    case method
    when :name then "??????"
    when :description, :banner then ""
    when :level, :banner_hue, :icon_index, :common_event_id then 0
    when :objectives, :rewards, :custom_categories then []
    when :prime_objectives then Array.new(objectives.size) { |x| x }
    when :concealed then QuestData::MANUAL_REVEAL
    when :manual_status then :active
    when :layout, :reward_given then false
    else ""
    end
  end
  #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  # * Reveal/Conceal Objective
  #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  def reveal_objective(*obj)
    valid_obj = obj.select {|x| x < objectives.size && !@revealed_objectives.include?(x) }
    valid_obj.each {|i| @revealed_objectives.maqj_insert_sort(i) }
    quest_status_changed unless valid_obj.empty?
  end
  def conceal_objective(*obj)
    quest_status_changed unless (obj & @revealed_objectives).empty?
    obj.each { |obj_id| @revealed_objectives.delete(obj_id) }
  end
  #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  # * Complete/Uncomplete Objective
  #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  def complete_objective(*obj)
    valid_obj = obj.select {|x| x < objectives.size && !@complete_objectives.include?(x) }
    reveal_objective(*valid_obj)
    unfail_objective(*valid_obj)
    was_complete = status?(:complete)
    valid_obj.each {|i| @complete_objectives.maqj_insert_sort(i) }
    quest_status_changed unless valid_obj.empty?
    # If just completed
    if status?(:complete) && !was_complete
      $game_temp.reserve_common_event(common_event_id)
      $game_party.quests.add_to_sort_array(:complete, @id)
    end
  end
  def uncomplete_objective(*obj)
    quest_status_changed unless (obj & @complete_objectives).empty?
    obj.each { |obj_id| @complete_objectives.delete(obj_id) }
  end
  #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  # * Fail/Unfail Objective
  #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  def fail_objective(*obj)
    valid_obj = obj.select {|x| x < objectives.size && !@failed_objectives.include?(x) }
    reveal_objective(*valid_obj)
    uncomplete_objective(*valid_obj)
    was_failed = status?(:failed)
    valid_obj.each {|i| @failed_objectives.maqj_insert_sort(i) }
    quest_status_changed unless valid_obj.empty?
    $game_party.quests.add_to_sort_array(:failed, @id) if status?(:failed) && !was_failed
  end
  def unfail_objective(*obj)
    quest_status_changed unless (obj & @failed_objectives).empty?
    obj.each { |obj_id| @failed_objectives.delete(obj_id) }
  end
  #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  # * Updates when the quest status has been changed
  #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  def quest_status_changed
    $game_party.quests.add_to_sort_array(:change, @id) 
    $game_system.last_quest_id = @id if QuestData::OPEN_TO_LAST_CHANGED_QUEST
  end
  #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  # * Objective Status?
  #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  def objective_status?(status_check, *obj)
    return false if obj.empty?
    case status_check
    when :failed   then !(obj & @failed_objectives).empty?
    when :complete then obj.size == (obj & @complete_objectives).size
    when :revealed then obj.size == (obj & @revealed_objectives).size
    when :active then objective_status?(:revealed, *obj) && 
      !objective_status?(:complete, *obj) && !objective_status?(:failed, *obj)
    end
  end
  #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  # * Status?
  #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  def status?(status_check)
    case status_check
    when :failed  
      @prime_objectives.empty? ? @manual_status == :failed : 
        !(@failed_objectives & @prime_objectives).empty?
    when :complete
      @prime_objectives.empty? ? @manual_status == :complete : !status?(:failed) && 
        ((@prime_objectives & @complete_objectives) == @prime_objectives)
    when :active then !concealed && !status?(:complete) && !status?(:failed)
    when :reward then @reward_given
    end
  end
  #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  # * Set Name
  #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  def name=(new_name)
    @name = new_name
    $game_party.quests.add_to_sort_array(:alphabet, @id) if $game_party && 
      $game_party.quests
  end
  #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  # * Set Level
  #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  def level=(new_lvl)
    @level = new_lvl
    $game_party.quests.add_to_sort_array(:level, @id) if $game_party && 
      $game_party.quests
  end
end
 
#==============================================================================
# ** Game_Quests 
#++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
#  This is a wrapper for an array holding Game_Quest objects
#==============================================================================
 
class Game_Quests
  #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  # * Object Initialization
  #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  def initialize
    @data = {}
    @sort_arrays = {
      reveal: [], change: [], complete: [], failed: [],
      id:       [].send(:extend, MAQJ_SortedArray),
      alphabet: [].send(:extend, MAQJ_SortedArray),
      level:    [].send(:extend, MAQJ_SortedArray)
    }
  end
  #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  # * Get Quest
  #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  def [](quest_id)
    reset_quest(quest_id) if !@data[quest_id]
    @data[quest_id]
  end
  #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  # * Set Quest <- Not sure when this would ever be useful.
  #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  def []=(quest_id, value)
    @data[quest_id] = value
  end
  #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  # * List
  #    list_type : the type of list to return
  #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  def list(list_type = :all, sort_type = $game_system.quest_sort_type[list_type])
    sort_type_s = sort_type.to_s
    reverse = !(sort_type_s.sub!(/_r$/, "")).nil?
    sort_type = sort_type_s.to_sym
    list = @sort_arrays[sort_type].select { |quest_id| include?(quest_id, list_type) }
    list.reverse! if reverse
    list.collect { |quest_id| @data[quest_id] }
  end
  #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  # * Include?
  #    determines whether to include a particular quest depending on list type
  #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  def include?(quest_id, list_type = :all)
    return false if !revealed?(quest_id)
    case list_type
    when :all then true
    when :complete, :failed, :active then @data[quest_id].status?(list_type)
    else
      @data[quest_id].custom_categories.include?(list_type)
    end
  end
  #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  # * Revealed? 
  #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  def revealed?(quest_id)
    (!@data[quest_id].nil? && !@data[quest_id].concealed)
  end
  #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  # * Setup Quest
  #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  def setup_quest(quest_id)
    return if @data[quest_id]
    @data[quest_id] = Game_Quest.new(quest_id)
    # Open to this quest next time the QJ is opened
    $game_system.last_quest_id = quest_id if QuestData::OPEN_TO_LAST_REVEALED_QUEST
    # Save sorting order in separate arrays to avoid re-sorting every time
    @sort_arrays.keys.each { |sym| add_to_sort_array(sym, quest_id) }
  end
  #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  # * Delete Quest
  #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  def delete_quest(quest_id)
    @data.delete(quest_id)
    @sort_arrays.values.each { |ary| ary.delete(quest_id) }
  end
  #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  # * Reset Quest
  #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  def reset_quest(quest_id)
    delete_quest(quest_id)
    setup_quest(quest_id)
  end
  #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  # * Add to Sorted Array
  #    sort_type : array to alter
  #    quest_id  : ID of the quest to add.
  #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  def add_to_sort_array(sort_type, quest_id)
    @sort_arrays[sort_type].delete(quest_id) # Make sure always unique
    case sort_type
    when :reveal, :change, :complete, :failed
      @sort_arrays[sort_type].unshift(quest_id)
    when :id
      @sort_arrays[sort_type].maqj_insert_sort(quest_id)
    when :alphabet 
      @sort_arrays[sort_type].maqj_insert_sort(quest_id) { |a, b| @data[a].name.downcase <=> @data[b].name.downcase }
    when :level
      @sort_arrays[sort_type].maqj_insert_sort(quest_id) { |a, b| @data[a].level <=> self[b].level }
    end
  end
  #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  # * Find Location
  #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  def find_location(quest_id, cat = nil)
    if revealed?(quest_id)
      categories = $game_system.quest_categories.dup
      # If cat specified, check in that category first.
      if cat && categories.include?(cat)
        categories.delete(cat)
        categories.unshift(cat)
      end
      for category in categories # Check all categories
        index = list(category).index(@data[quest_id])
        return category, index if index != nil
      end
    end
    return nil, nil
  end
  #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  # * Clear
  #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  def clear
    @data.clear
  end
end
 
#==============================================================================
# ** Game System
#++++++++++++++++++++++++++++++++++++++++++++++++++++++