#==============================================================================
# ** TDS Lufia Rise of the Sinistrals CMS
# Version: 1.2
#------------------------------------------------------------------------------
# This script allows for the creation of objects trough a menu using other
# objects and alchemic methods as the base for their creation.
#==============================================================================
# WARNING:
#
# Do not release, distribute or change my work without my expressed written
# consent, doing so violates the terms of use of this work.
#
# * Not Knowing English or understanding these terms will not excuse you in any
#   way from the consequenses.
#
# * This applies to all of my work whether they have thiss notice or not.
#
# Contact Email: Sephirothtds@hotmail.com
#==============================================================================
# This is a system replication in no way meant to be used or distributed in any
# game or for any profit monetary or other.
#==============================================================================

#==============================================================================
# ** Window_Base
#------------------------------------------------------------------------------
#  This is a superclass of all windows in the game.
#==============================================================================

class Window_Base < Window
  #--------------------------------------------------------------------------
  # * Constants
  #--------------------------------------------------------------------------
  WLH = 24                  # Window Line Height
  #--------------------------------------------------------------------------
  # * Draw HP
  #     actor  : actor
  #     x      : draw spot x-coordinate
  #     y      : draw spot y-coordinate
  #     width  : Width
  #     no_bar : drawing bar flag
  #--------------------------------------------------------------------------
  def draw_actor_hp(actor, x, y, width = 120, no_bar = false)
    if no_bar == false
      draw_actor_hp_gauge(actor, x, y, width)
    end
    self.contents.font.color = system_color
    self.contents.draw_text(x, y, 30, WLH, Vocab::hp_a)
    self.contents.font.color = hp_color(actor)
    last_font_size = self.contents.font.size
    xr = x + width
    if width < 120
      self.contents.draw_text(xr - 44, y, 44, WLH, actor.hp, 2)
    else
      self.contents.draw_text(xr - 99, y, 44, WLH, actor.hp, 2)
      self.contents.font.color = normal_color
      self.contents.draw_text(xr - 55, y, 11, WLH, "/", 2)
      self.contents.draw_text(xr - 44, y, 44, WLH, actor.maxhp, 2)
    end
  end
  #--------------------------------------------------------------------------
  # * Draw MP
  #     actor  : actor
  #     x      : draw spot x-coordinate
  #     y      : draw spot y-coordinate
  #     width  : Width
  #     no_bar : drawing bar flag
  #--------------------------------------------------------------------------
  def draw_actor_mp(actor, x, y, width = 120, no_bar = false)
    if no_bar == false
      draw_actor_mp_gauge(actor, x, y, width)
    end
    self.contents.font.color = power_up_color
    self.contents.draw_text(x, y, 30, WLH, Vocab::mp_a)
    self.contents.font.color = mp_color(actor)
    last_font_size = self.contents.font.size
    xr = x + width
    if width < 120
      self.contents.draw_text(xr - 44, y, 44, WLH, actor.mp, 2)
    else
      self.contents.draw_text(xr - 99, y, 44, WLH, actor.mp, 2)
      self.contents.font.color = normal_color
      self.contents.draw_text(xr - 55, y, 11, WLH, "/", 2)
      self.contents.draw_text(xr - 44, y, 44, WLH, actor.maxmp, 2)
    end
  end
end


#==============================================================================
# ** Window_Selectable
#------------------------------------------------------------------------------
#  This window contains cursor movement and scroll functions.
#==============================================================================

class Window_Selectable < Window_Base
  #--------------------------------------------------------------------------
  # * Public Instance Variables
  #--------------------------------------------------------------------------
  attr_reader   :item_max                 # item count
  attr_reader   :column_max               # digit count
  attr_reader   :index                    # cursor position
  attr_reader   :help_window              # help window
  # Custom cursor values
  attr_accessor   :use_custom_cursor      # Custom cursor flag
  attr_accessor   :cursor_visible         # Cursor visibility flag
  attr_accessor   :cursor_offsets         # Cursor offsets values
  attr_accessor   :wait_cursor_offsets    # Cursor offsets values
  #--------------------------------------------------------------------------
  # * Object Initialization
  #     x           : window X coordinate
  #     y           : window Y coordinate
  #     width       : window width
  #     height      :   window height
  #     spacing     : width of empty space when items are arranged horizontally
  #--------------------------------------------------------------------------
  def initialize(x, y, width, height, spacing = 32)
    @item_max = 1
    @column_max = 1
    @index = -1
    @spacing = spacing
    # Cursor variables
    @use_custom_cursor = false #true
    @cursor_offsets = [0, 0]
    @wait_cursor_offsets = [0, 0]
    @cursor_visible = nil
    super(x, y, width, height)
     create_custom_cursor
  end
  #--------------------------------------------------------------------------
  # * Dispose
  #--------------------------------------------------------------------------
  def dispose
    self.contents.dispose
    @sprite.bitmap.dispose
    @sprite.dispose
    super
  end
  #--------------------------------------------------------------------------
  # * Create Custom Cursor
  #--------------------------------------------------------------------------
  def create_custom_cursor
    @sprite = Sprite.new
    @sprite.bitmap = Cache.system("Cursor")
    @sprite.src_rect.width = @sprite.bitmap.width / 6
    @sprite.x = self.x + 16
    @sprite.y = self.y + 16 + 4
    @sprite.visible = @use_custom_cursor
    @sprite.z = 9999
    update_cursor_graphic
  end
  #--------------------------------------------------------------------------
  # * Frame Update
  #--------------------------------------------------------------------------
  def update
    super
    if cursor_movable?
      last_index = @index
      if Input.repeat?(Input::DOWN)
        cursor_down(Input.trigger?(Input::DOWN))
      end
      if Input.repeat?(Input::UP)
        cursor_up(Input.trigger?(Input::UP))
      end
      if Input.repeat?(Input::RIGHT)
        cursor_right(Input.trigger?(Input::RIGHT))
      end
      if Input.repeat?(Input::LEFT)
        cursor_left(Input.trigger?(Input::LEFT))
      end
      if Input.repeat?(Input::R)
        cursor_pagedown
      end
      if Input.repeat?(Input::L)
        cursor_pageup
      end
      if @index != last_index
        Sound.play_cursor
      end
    end
    update_cursor
    call_update_help
    if @use_custom_cursor == true
      update_cursor_graphic
    end
  end

  #--------------------------------------------------------------------------
  # * Change cursor visibility
  #    value : true or false visibility
  #--------------------------------------------------------------------------
  def change_cursor_visibility(value)
     @sprite.visible = value
  end
  #--------------------------------------------------------------------------
  # * Update Cursor Graphic
  #--------------------------------------------------------------------------
  def update_cursor_graphic
    @sprite.visible = @use_custom_cursor if @cursor_visible == nil
    @sprite.visible = @cursor_visible if @cursor_visible != nil

    if @use_custom_cursor == true
      if self.visible == false or @index < 0
        @sprite.opacity = 0
       elsif self.visible == true or @index >= 0
        @sprite.opacity = 255
      end

     if self.active
       @sprite.bitmap = Cache.system("Cursor")
       @sprite.src_rect.width = @sprite.bitmap.width / 6
     else
       @sprite.bitmap = Cache.system("Wait Cursor")
       @sprite.src_rect.width = @sprite.bitmap.width / 7
     end

     if self.active
      dx = self.x + self.cursor_rect.x + 16 + @cursor_offsets[0]
      dy = self.y + self.cursor_rect.y + self.cursor_rect.height / 2 + 3 + @cursor_offsets[1]
    else
      dx = self.x + self.cursor_rect.x + 16 + @wait_cursor_offsets[0]
      dy = self.y + self.cursor_rect.y + self.cursor_rect.height / 2 + 3 + @wait_cursor_offsets[1]
    end
      @sprite.x = dx
      @sprite.y = dy
      update_cursor_animation
     end
   end
  #--------------------------------------------------------------------------
  # * Update Cursor Animation
  #--------------------------------------------------------------------------
  def update_cursor_animation
    @duration = -1 if @duration == nil
     if self.active
       @duration += 1
       @duration %= 8
      if @duration == 8 -1
        @sprite.src_rect.x += 24
        @sprite.src_rect.x %= 6 * 24
      end
    else
       @duration += 1
       @duration %= 8
      if @duration == 8 - 1
        @sprite.src_rect.x -= 24
        @sprite.src_rect.x %= 7 * 24
      end
    end
  end
  #--------------------------------------------------------------------------
  # * Dispose
  #--------------------------------------------------------------------------
  def dispose
    self.contents.dispose
    @sprite.dispose if @sprite != nil
    super
  end
  #--------------------------------------------------------------------------
  # * Update cursor
  #--------------------------------------------------------------------------
  def update_cursor
    if @index < 0                   # If the cursor position is less than 0
      self.cursor_rect.empty        # Empty cursor
    else                            # If the cursor position is 0 or more
      row = @index / @column_max    # Get current row
      if row < top_row              # If before the currently displayed
        self.top_row = row          # Scroll up
      end
      if row > bottom_row           # If after the currently displayed
        self.bottom_row = row       # Scroll down
      end
      rect = item_rect(@index)      # Get rectangle of selected item
      rect.y -= self.oy             # Match rectangle to scroll position
      self.cursor_rect = rect       # Refresh cursor rectangle
    end
  end
  #--------------------------------------------------------------------------
  # * Call help window update method
  #--------------------------------------------------------------------------
  def call_update_help
    if self.active and @help_window != nil
       update_help
    end
  end
  #--------------------------------------------------------------------------
  # * Update help window (contents are defined by the subclasses)
  #--------------------------------------------------------------------------
  def update_help
  end
end


#==============================================================================
# ** Window_Command
#------------------------------------------------------------------------------
#  This window deals with general command choices.
#==============================================================================

class TDS_Window_Command < Window_Selectable
  #--------------------------------------------------------------------------
  # * Public Instance Variables
  #--------------------------------------------------------------------------
  attr_reader   :commands                 # command
  #--------------------------------------------------------------------------
  # * Object Initialization
  #     width      : window width
  #     commands   : command string array
  #     column_max : digit count (if 2 or more, horizontal selection)
  #     row_max    : row count (0: match command count)
  #     spacing    : blank space when items are arrange horizontally
  #--------------------------------------------------------------------------
  def initialize(width, commands, column_max = 1, row_max = 0, spacing = 32)
    if row_max == 0
      row_max = (commands.size + column_max - 1) / column_max
    end
    super(0, 0, width, row_max * WLH + 32, spacing)
    self.windowskin = Cache.system("TDS-Lufia Window")
    self.back_opacity = 255
    @use_custom_cursor = true
    @cursor_offsets = [-4, 0]
    @commands = commands
    @item_max = commands.size
    @column_max = column_max
    refresh
    self.index = 0
  end
  #--------------------------------------------------------------------------
  # * Refresh
  #--------------------------------------------------------------------------
  def refresh
    self.contents.clear
    for i in 0...@item_max
      draw_item(i)
    end
  end
  #--------------------------------------------------------------------------
  # * Return_Command_Name
  #--------------------------------------------------------------------------
  def return_command_name(index)
    return @commands[index]
  end
  #--------------------------------------------------------------------------
  # * Draw Item
  #     index   : item number
  #     enabled : enabled flag. When false, draw semi-transparently.
  #--------------------------------------------------------------------------
  def draw_item(index, enabled = true)
    rect = item_rect(index)
    rect.x += 26
    rect.width -= 8
    self.contents.clear_rect(rect)
    self.contents.font.color = normal_color
    self.contents.font.color.alpha = enabled ? 255 : 128
    self.contents.draw_text(rect, @commands[index])
  end
end


#============== ================================================================
# ** TDS Lufia Menu
#------------------------------------------------------------------------------
#  This class performs the menu screen processing.
#==============================================================================

class Scene_Menu < Scene_Base
  #--------------------------------------------------------------------------
  # * Object Initialization
  #     menu_index : command cursor's initial position
  #--------------------------------------------------------------------------
  def initialize(menu_index = 0)
    @menu_index = menu_index
    # Flag variables
    @viewing_spell_information_window = false
    @viewing_item_information_window = false
    @viewing_scenario_information_window = false
  end
  #--------------------------------------------------------------------------
  # * Start processing
  #--------------------------------------------------------------------------
  def start
    super
    # Create Menu Back Sprite
    @menuback_sprite = Sprite.new
    @menuback_sprite.bitmap = Cache.system("Lufia Menu Back")
    # Create Scene Header
    @scene_header = Window_Base.new(20, 198, 140, 56)
    @scene_header.windowskin = Cache.system("TDS-Lufia Window")
    @scene_header.back_opacity = 255
    @scene_header.contents = Bitmap.new(140-32,56-32)
    @scene_header.contents.font.color = @scene_header.text_color(0)
    @scene_header.contents.draw_text(0,0,140-32, 24, "ITEM",1)
    @scene_header.visible = false
    # Create Dummy Help Window
    @dummy_help_window = Window_Base.new(20, 305, 505, 101)
    @dummy_help_window.windowskin = Cache.system("TDS-Lufia Window")
    @dummy_help_window.contents = Bitmap.new(505-32,56-32)
    @dummy_help_window.contents.font.color =  @dummy_help_window.text_color(0)
    @dummy_help_window.contents.draw_text(0, 0 , 505-32, 24, "HELP",1)
    @dummy_help_window.back_opacity = 255
    @dummy_help_window.visible = false
    # Create Help Window Header
    @scene_help_header = Window_Base.new(20, 254, 505, 56)
    @scene_help_header.windowskin = Cache.system("TDS-Lufia Window")
    @scene_help_header.back_opacity = 255
    @scene_help_header.contents = Bitmap.new(505-32,56-32)
    @scene_help_header.contents.font.color = @scene_help_header.text_color(0)
    @scene_help_header.contents.draw_text(0, 0 , 505-32, 24, "Item name",1)
    @scene_help_header.visible = false
    # Create Scenario header
    @scenario_header = Window_Base.new(20, 198, 300, 56)
    @scenario_header.windowskin = Cache.system("TDS-Lufia Window")
    @scenario_header.back_opacity = 255
    @scenario_header.contents = Bitmap.new(300-32,56-32)
    @scenario_header.contents.font.color = @scene_header.text_color(0)
    @scenario_header.contents.draw_text(0,0,300-32, 24, "SCENARIO ITEMS",1)
    @scenario_header.visible = false
    # Create command windows
    create_command_window
    # Create Gold Window
    @gold_time_window = Window_Gold_Time.new(265, 326)
    # Create Main Status Window
    @status_window = Window_MenuStatus.new(0, 0)
    @status_window.active = false
    # Activate main status window normal mode
    @status_window.change_mode(0, true)
    # Create Item Window
    @item_window = TDS_Lufia_Window_Item.new(20, 254, 505, 152)
    @item_window.index = 0
    @item_window.active = false
    @item_window.visible = false
    # Create Skill Window
    @skill_window = TDS_Lufia_Window_Skill.new(20, 254, 505, 152, $game_party.members[0])
    @skill_window.active = false
    @skill_window.visible = false
    # Flag variables
    @viewing_item_information_window = false
    @viewing_spell_information_window = false
    @viewing_scenario_information_window = false
    # Update flag values
    @update_item_processing = false
    @update_spell_processing = false
    @update_scenario_mode_processing = false
  end
  #--------------------------------------------------------------------------
  # * Create Command Window
  #--------------------------------------------------------------------------
  def create_command_window
    # Create Command Window
    @command_window = TDS_Window_Command.new(390, ["ITEM", "STATUS", "SPELL",
    "EQUIP", "SCENARIO", "SAVE", "END"], 2)
    # Set command window x position
    @command_window.x = 135
    # Set command window y position
    @command_window.y = 198
    # Set command window index
    @command_window.index = @menu_index
    # If game party size is 0
    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 saving disable
    if $game_system.save_disabled             # If save is forbidden
      @command_window.draw_item(5, false)     # Disable save
    end
    # Create Item Command Window
    @item_command_window = TDS_Window_Command.new(365, ["USE", "ALL", "DROP"],3)
    # Set item command window x
    @item_command_window.x = 160
    # Set item command window y
    @item_command_window.y = 198
    # Set item command visibility
    @item_command_window.visible = false
    # Set item command window active to false
    @item_command_window.active = false
    # Create Spell Command Window
    @spell_command_window = TDS_Window_Command.new(365, ["USE", "ALL"],2)
    # Set spell command window x
    @spell_command_window.x = 160
    # Set spell command window y
    @spell_command_window.y = 198
    # Set spell command window visible to false
    @spell_command_window.visible = false
    # Set Spell command window active to false
    @spell_command_window.active = false
  end
  #--------------------------------------------------------------------------
  # * Frame Update
  #--------------------------------------------------------------------------
  def update
    super
    # Update command windows
    @command_window.update
    @spell_command_window.update
    @item_command_window.update
    # Update windows
    @gold_time_window.update
    @status_window.update
    @item_window.update
    @skill_window.update
    # If command window active
    if @command_window.active
      update_command_selection
    end

    # If status window is active and it's on normal mode
    if @status_window.active and @status_window.normal_mode
      # Update main menu actor selection
      update_main_actor_selection
    end
    # If item processing flag is true update item methods
    if @update_item_processing
      # Update Item Choosing if Item window is active or viewing item information
      if @item_window.active == true or @viewing_item_information_window
        update_item_choosing
      end
      # Update Item Command Arrange Choosing if Item Command window is active
      if @item_command_window.active
        update_item_command_choosing
      end
      # If status window is active and it's on item mode
      if @status_window.active and @status_window.item_mode
        update_item_target_choosing
      end
    end
    # If skill prcoessing flag is true update skill methods
    if @update_spell_processing
      # Update skill arrange choosing if spell command window is active
      if @spell_command_window.active
        update_skill_command_choosing
      end
      # Update skill choosing if skill window is active or viewing skill information
      if @skill_window.active or @viewing_spell_information_window
        update_skill_choosing
      end
      # If status window is active and it's on skill mode
      if @status_window.active and @status_window.skill_mode
        update_skill_target_choosing
      end
    end

   # If scenario processing flag is true update Scenario methods
   if @update_scenario_mode_processing
     # Update sceneario item viewing pro
     update_scenario_item_choosing
   end
  end
  #--------------------------------------------------------------------------
  # * Update Command Selection
  #--------------------------------------------------------------------------
  def update_command_selection
    if Input.trigger?(Input::B)
      Sound.play_cancel
      $scene = Scene_Map.new
      return
    end
    # If Input trigger Confirm
    if Input.trigger?(Input::C)
      case @command_window.return_command_name(@command_window.index)
      when "ITEM"
        # Play desicion sound
        Sound.play_decision
        # Start item scene processing
        start_item_scene
        # Update input
        Input.update
        return
      when "STATUS"
        start_main_actor_selection
      when "SPELL"
        start_main_actor_selection
      when "EQUIP"
        start_main_actor_selection
      when "SCENARIO"
        # Play desicion sound
        Sound.play_decision
        # Start scenario scene processing
        start_scenario_mode
        return
      when "SAVE"
        if $game_system.save_disabled
          Sound.play_buzzer
          return
        end
        # Play desicion sound
        Sound.play_decision
        $scene = Scene_File.new(true, false, false)
       return
      when "END"
        # Play desicion sound
        Sound.play_decision
        $scene = Scene_End.new
       return
      end
    end
  end
  #--------------------------------------------------------------------------
  # * Start Main Actor Selection
  #--------------------------------------------------------------------------
  def start_main_actor_selection
    if $game_party.members.size == 0
      Sound.play_buzzer
      return
    end
    # Play desicion sound
    Sound.play_decision
    # Deactivate command window
    @command_window.active = false
    # Activate status window and make cursor visible
    @status_window.active = true
    @status_window.index = 0
    # Input update
    Input.update
    return
  end
  #--------------------------------------------------------------------------
  # * End Main Actor Selection
  #--------------------------------------------------------------------------
  def end_main_actor_selection
    # Deactivate status window and make cursor invisible
    @status_window.active = false
    @status_window.index = -1
    # Activate command window
    @command_window.active = true
    return
  end
  #--------------------------------------------------------------------------
  # * Update Actor Selection
  #--------------------------------------------------------------------------
  def update_main_actor_selection
    # If input trigger is cancel
    if Input.trigger?(Input::B)
      # Play cancel sound
      Sound.play_cancel
      # End main actor selection
      end_main_actor_selection
      return
    end
    # If input trigger confirm
    if Input.trigger?(Input::C)
      # Play desicion sound
      Sound.play_decision
      case @command_window.return_command_name(@command_window.index)
       when "STATUS"
         # Change scene to Scene Status
         $scene = Scene_Status.new(@status_window.index)
         return
       when "SPELL"
         # Start skill methods
         start_skill_scene
       when "EQUIP"
         # Change scene to Scene Equip
         $scene = Scene_Equip.new(@status_window.index)
         return
       end
     end
   end


#==============================================================================
# ** Item Methods
#------------------------------------------------------------------------------
#  These methods performs the item screen processing.
#==============================================================================

  #--------------------------------------------------------------------------
  # * Start Item Scene
  #--------------------------------------------------------------------------
  def start_item_scene
    # Start updating item processing
    @update_item_processing = true
    # Set intial value for item for information
    @item = nil
    # Activate main status window normal mode
    @status_window.change_mode(1, true)
    # Deactivate status window
    @status_window.active = false
    # Set Old Index initial value
    @old_item_command_index = 0
    # Change item status window visibility
    @command_window.visible = false
    @command_window.active = false
    # Changing visibily of gold window
    @gold_time_window.visible = false
    # Change scene header text color, text and visibility
    @scene_header.contents.font.color = @scene_header.text_color(0)
    @scene_header.contents.clear
    @scene_header.contents.draw_text(0,0,140-32,56-32, "ITEM",1)
    @scene_header.visible = true
    # Activate the item command window
    @item_command_window.visible = true
    @item_command_window.index = 0
    # Determining item index and activity
    if @item_window.item_max == 0
      @item_window.index = -1
      @item_window.active = false
      @item_command_window.active = true
    else
      @item_window.index = 0
      @item_window.active = true
      @item_command_window.active = false
    end
    # Changing command window visibility
    @item_window.visible = true
  end
  #--------------------------------------------------------------------------
  # * End Item Scene
  #--------------------------------------------------------------------------
  def end_item_scene
    # Set value for item for information
    @item = nil
    # Activate main status window normal mode
    @status_window.change_mode(0, true)
    # Set Old Index value
    @old_item_command_index = 0
    # Changing item window visibility and active
    @item_command_window.visible = false
    @item_window.active = false
    # Changing command window visibility and active
    @item_window.visible = false
    @item_window.active = false
    # Change scene header visibility
    @scene_header.contents.clear
    @scene_header.visible = false
    # Activating command window
    @command_window.visible = true
    @command_window.active = true
    # Changing visibily of gold window
    @gold_time_window.visible = true
    # Deactivate status window and change index
    @status_window.active = false
    @status_window.index = -1
    # Change viewing item information flag to false
    @viewing_item_information_window = false
    # End item processing
    @update_item_processing = false
    # Update Input
    Input.update
    return
  end
  #--------------------------------------------------------------------------
  # * Update Item Command Choosing
  #--------------------------------------------------------------------------
  def update_item_command_choosing
    # If old index is not equal to item command window idex
    if @old_item_command_index != @item_command_window.index
      # Update window display mode
      update_item_window_display_mode
    end
    # If Input Trigger Cancel
    if Input.trigger?(Input::B)
      # Play cancel sound
      Sound.play_cancel
      # End item processing
      end_item_scene
      # Update Input
      Input.update
      return
    end
    # If Input trigger Confirm
    if Input.trigger?(Input::C)
      # If item window item max is 0
      if @item_window.item_max == 0
        # Play buzzer sound
        Sound.play_buzzer
        # Activate item command window
        @item_command_window.active = true
        # Deactivate item window
        @item_window.active = false
        # Update input
        Input.update
        return
      end
      # PLay desicion sound
      Sound.play_decision
      # Deactivate the command window
      @item_command_window.active = false
      # Activate the item window
      @item_window.active = true
      return
    end
  end
  #--------------------------------------------------------------------------
  # * Update Item Choosing
  #--------------------------------------------------------------------------
  def update_item_choosing
    # If Input Trigger Cancel
    if Input.trigger?(Input::B)
      # Play cancel sound
      Sound.play_cancel
      # If viewing item information flag is true
      if @viewing_item_information_window == true
        # View item information
        view_item_information(@item_window.item)
        return
      end
      # Deactivate the item window
      @item_window.active = false
      # Set old index value to the item window index value
      @old_item_window_index = @item_window.index
      # Activate the command window
      @item_command_window.active = true
      # If item quantity is 0
      if $game_party.item_number(@item) == 0
        # Refresh item window
        @item_window.refresh
      end
      # Update Input
      Input.update
      return
    end
    # If Input trigger Confirm not viewing item information
    if Input.trigger?(Input::C) and @viewing_item_information_window == false
      # Item command window index
      case @item_command_window.index
      when 0, 1 # Use or all items
        use_item
      when 2 # Drop
        drop_item
      end
    end
    # If Input Trigger CTRL
    if Input.trigger?(Input::CTRL)
      # PLay desicion sound
      Sound.play_decision
      # View item information
      view_item_information(@item_window.item)
      return
    end
  end
  #--------------------------------------------------------------------------
  # * Update Item Target Choosing
  #--------------------------------------------------------------------------
  def update_item_target_choosing
    # If Input Trigger Cancel
    if Input.trigger?(Input::B)
      # Play cancel sound
      Sound.play_cancel
      # Deactivate status window
      @status_window.active = false
      # Change status window index making it invisible
      @status_window.index = -1
      # Activate the command window
      @item_window.active = true
      # If item quantity is 0
      if $game_party.item_number(@item) == 0
        # Refresh item window
        @item_window.refresh
        # Activate item command window
        @item_command_window.active = true
        # Deactivate item window
        @item_window.active = false
      end
      # Set value for item for information
      @item = nil
      return
    end
    # If Input trigger Confirm
    if Input.trigger?(Input::C)
      if $game_party.item_can_use?(@item) == false
        Sound.play_buzzer
      else
        determine_item_target
        end
      return
    end
  end
  #--------------------------------------------------------------------------
  # * Update Item Window Display Mode
  #--------------------------------------------------------------------------
  def update_item_window_display_mode
    case @item_command_window.index
    when 0
      # Change item window mode to true and to display only use items
      @item_window.only_items_mode(true)
      # Change item window mode to false and to display all items
      @item_window.all_items_mode(false)
      # Change item window mode to drop items to false
      @item_window.drop_items_mode(false)
      # Refresh item window
      @item_window.refresh
      # Change cursor index to 0
      @item_window.index = 0
    when 1, 2
      # Set old mode value for refresh
      old_mode_value = @item_window.all_mode
      # Change item window mode to false and to display only use items
      @item_window.only_items_mode(false)
      # Change item window mode to true and to display all items
      @item_window.all_items_mode(true)
      # Set item window index to 0 if the items in the window are more
      if old_mode_value == false
        # Refresh item window
        @item_window.refresh
        # Change cursor index to 0
        @item_window.index = 0
      end
    end
    # Set old command index to be the same as the
    @old_item_command_index = @item_command_window.index
  end
  #--------------------------------------------------------------------------
  # * Use Item
  #--------------------------------------------------------------------------
  def use_item
    # Set item variable information
    @item = @item_window.item
    return Sound.play_buzzer if $game_party.item_can_use?(@item) == false
    # PLay desicion sound
    Sound.play_decision
    # Deactivate the item window
    @item_window.active = false
    # Activate status window
    @status_window.active = true
    # Change status window index making it visible depending on the item scope
    if @item.scope == 8 and $game_party.members.size > 1
      @status_window.index = 100
     else
      @status_window.index = 0
     end
     # Update input
     Input.update
    return
  end
  #--------------------------------------------------------------------------
  # * Drop Item
  #--------------------------------------------------------------------------
  def drop_item
    #  If Item window Item max is 0
    if @item_window.item_max == 0
      # Activate item command window
      @item_command_window.active = true
      # Deactivate item window
      @item_window.active = false
    else
      # Set old item index
      old_index = @item_window.index
      # Play equip sound
      Sound.play_equip
      # Drop item
      @item_window.drop_item(@item_window.item)
      # Refresh item window
      @item_window.refresh
      # Set old index to the item window index if it's not 0
      old_index %= @item_window.item_max if @item_window.item_max != 0
      # Set item window index to old index
      @item_window.index = old_index
      # If item window item max is not 0
      if @item_window.item_max == 0
        # Play cancel sound
        Sound.play_cancel
        # Activate item command window
        @item_command_window.active = true
      end
      # Update input
      Input.update
      return
    end
  end
  #--------------------------------------------------------------------------
  # * Confirm Item Target
  #    If there is no effect (such as using a potion on an incapacitated
  #    character), play a buzzer SE.
  #--------------------------------------------------------------------------
  def determine_item_target
    # Item used is set to false
    used = false
    # if item is for all
    if @item.for_all?
      for target in $game_party.members
        target.item_effect(target, @item)
        used = true unless target.skipped
      end
    else
      $game_party.last_target_index = @status_window.index
      target = $game_party.members[@status_window.index]
      target.item_effect(target, @item)
      used = true unless target.skipped
    end
    # If use is true
    if used
      # Use item
      use_item_nontarget
    else
      # Play buzzer sound
      Sound.play_buzzer
    end
  end
  #--------------------------------------------------------------------------
  # * Use Item (apply effects to non-ally targets)
  #--------------------------------------------------------------------------
  def use_item_nontarget
    # Play item use sound
    Sound.play_use_item
    # Consume item
    $game_party.consume_item(@item)
    # Draw used item
    @item_window.draw_item(@item_window.index)
    # Refresh status window
    @status_window.refresh
    # If the party is all dead
    if $game_party.all_dead?
      # Change to scene game over
      $scene = Scene_Gameover.new
    # If item common event ID is more than 0
    elsif @item.common_event_id > 0
      $game_temp.common_event_id = @item.common_event_id
      $scene = Scene_Map.new
    end
  end
  #--------------------------------------------------------------------------
  # * View Item Information
  #    item : item from which to read data from
  #--------------------------------------------------------------------------
  def view_item_information(item)
    # If viewing item information flag is false
    if @viewing_item_information_window == false
      item_info = item
      # Change item window visibility and active
      @item_window.visible = false
      @item_window.active = false
      # Change scene help header visibility, add text and change text color
      @scene_help_header.visible = true
      @scene_help_header.contents.font.color = @scene_help_header.text_color(0)
      @scene_help_header.contents.clear
      @scene_help_header.contents.draw_text(0, 0 , 505-32, 24, item_info.name,1)
      # Change dummy help window visibility, add text and color
      @dummy_help_window.visible = true
      @dummy_help_window.contents.font.color =  @dummy_help_window.text_color(0)
      @dummy_help_window.contents.clear
      @dummy_help_window.contents.font.size = 22
      @dummy_help_window.contents.draw_text(0, -24, 505-32, 100-32,  item_info.description.capitalize)
      # Change viewing item information flag to true
      @viewing_item_information_window = true
    else
      # Change item window visibility and active
      @item_window.visible = true
      @item_window.active = true
      # Change help header window visibilty and clear text
      @scene_help_header.visible = false
      @scene_help_header.contents.clear
      # Change dummy help window visibily and clear text
      @dummy_help_window.visible = false
      @dummy_help_window.contents.clear
      # Change viewing item information flag to false
      @viewing_item_information_window = false
     return
    end
  end


#==============================================================================
# ** Skill Methods
#------------------------------------------------------------------------------
#  These methods performs the Spell screen processing.
#==============================================================================


  #--------------------------------------------------------------------------
  # * Start Skill Scene
  #--------------------------------------------------------------------------
  def start_skill_scene
    # Start updating spell processing
    @update_spell_processing = true
    # Set initial value for skill information
    @skill = nil
    # Activate main status window spell mode
    @status_window.change_mode(2, true)
    # Set old index initia value
    @old_spell_value_command_index = 0
    # Change command window visibility and active
    @command_window.visible = false
    @command_window.active = false
    # Deactivate status window
    @status_window.active = false
    # Change spell command window visibility and active
    @spell_command_window.visible = true
    @spell_command_window.active = true
    # Change spell command window to 0
    @spell_command_window.index = 0
    # Change skill window mode to show only usable skills
    @skill_window.only_use_skill_mode(true)
    # Change scene header text, color, visibility and add text
    @scene_header.contents.font.color = @scene_header.text_color(0)
    @scene_header.contents.clear
    @scene_header.contents.draw_text(0,0,140-32,56-32, "SPELL",1)
    @scene_header.visible = true
    # Changing visibily of gold window
    @gold_time_window.visible = false
    # Refresh window contents
    @skill_window.refresh($game_party.members[@status_window.index])
    # Change skill window visibility
    @skill_window.visible = true
    # Change skill window index to 0
    @skill_window.index = 0
    # Input update
    Input.update
    return
  end
  #--------------------------------------------------------------------------
  # * End Skill Scene
  #--------------------------------------------------------------------------
  def end_skill_scene
    # End updating spell processing
    @update_spell_processing = false
    # Set value for skill information
    @skill = nil
    # Activate main status window normal mode
    @status_window.change_mode(0, true)
    # Set old index initia value
    @old_spell_value_command_index = 0
    # Deactivate status window and change index
    @status_window.active = false
    @status_window.index = -1
    # Change skill window visibility
    @skill_window.visible = false
    # Change spell command window visibility and active
    @spell_command_window.visible = false
    @spell_command_window.active = false
    # Change spell command window to 0
    @spell_command_window.index = 0
    # Change scene header visibility
    @scene_header.contents.clear
    @scene_header.visible = false
    # Change command window visibility and active
    @command_window.visible = true
    @command_window.active = true
    # Changing visibily of gold window
    @gold_time_window.visible = true
    # Update Input
    Input.update
    return
  end
  #--------------------------------------------------------------------------
  # * Update Skill Command Choosing
  #--------------------------------------------------------------------------
  def update_skill_command_choosing
    # If old index is not equal to item command window idex
    if @old_spell_value_command_index != @spell_command_window.index
      # Update window display mode
      update_skill_window_display_mode
    end
    # If Input Trigger Cancel
    if Input.trigger?(Input::B)
      # Play cancel sound
      Sound.play_cancel
      # End spell processing
      end_skill_scene
      # Update Input
      Input.update
      return
    end
    # If not viewing spell information window
    if @viewing_spell_information_window == false
      # If Input trigger R
      if Input.trigger?(Input::R)
        # Play cursor sound
        Sound.play_cursor
        # Next actor
        next_spell_actor
      # If Input trigger L
      elsif Input.trigger?(Input::L)
        # Play cursor sound
        Sound.play_cursor
        # Previous actor
        prev_spell_actor
      end
    end
    # If Input trigger Confirm
    if Input.trigger?(Input::C)
      # If item window item max is 0
      if @skill_window.item_max == 0
        # Play buzzer sound
        Sound.play_buzzer
        # Activate spell command window
        @spell_command_window.active = true
        # Deactivate skill window
        @skill_window.active = false
        # Update input
        Input.update
        return
      end
      # Change skill window index to 0 if skill window index is more than skill window item max
      @skill_window.index = 0 if @skill_window.index > @skill_window.item_max
      # PLay desicion sound
      Sound.play_decision
      # Deactivate the command window
      @spell_command_window.active = false
      # Activate the skill window
      @skill_window.active = true
      # Update input
      Input.update
      return
    end
  end
  #--------------------------------------------------------------------------
  # * Update Skill Choosing
  #--------------------------------------------------------------------------
  def update_skill_choosing
    # If Input Trigger Cancel
    if Input.trigger?(Input::B)
      # Play cancel sound
      Sound.play_cancel

      if @viewing_spell_information_window == true
        # View skill information
        view_skill_information(@skill_window.skill)
        return
      end
      # Deactivate the skill window
      @skill_window.active = false
      # Activate spell command window
      @spell_command_window.active = true
      # Update Input
      Input.update
      return
    end
    # If not viewing spell information window
    if @viewing_spell_information_window == false
      # If Input trigger R
      if Input.trigger?(Input::R)
        # Play cursor sound
        Sound.play_cursor
        # Next actor
        next_spell_actor
      # If Input trigger L
      elsif Input.trigger?(Input::L)
        # Play cursor sound
        Sound.play_cursor
        # Previous actor
        prev_spell_actor
      end
    end
    # If Input trigger Confirm and not viewing skill information
    if Input.trigger?(Input::C) and @viewing_spell_information_window == false
      # Use skill
      use_skill
      # Update Input
      Input.update
      return
    end


    # If Input Trigger CTRL
    if Input.trigger?(Input::CTRL)
      # PLay desicion sound
      Sound.play_decision
      # View skill information
      view_skill_information(@skill_window.skill)
      return
    end
  end
  #--------------------------------------------------------------------------
  # * Update Skill Target Choosing
  #--------------------------------------------------------------------------
  def update_skill_target_choosing
    # If Input Trigger Cancel
    if Input.trigger?(Input::B)
      # Play cancel sound
      Sound.play_cancel
      # Deactivate status window
      @status_window.active = false
      # Change status window index to the return index
      @status_window.index = @return_status_index
      # Activate the skill window
      @skill_window.active = true
      # Set value for skill information
      @skill = nil
      # Update input
      Input.update
      return
    end
    # If input trigger confirm
    if Input.trigger?(Input::C)
      # If actor can use skill
      if @skill_window.actor.skill_can_use?(@skill)
        # Determine if skill further usable
        determine_skill
      else
        # Play buzzer sound
        Sound.play_buzzer
      end
    end
  end
  #--------------------------------------------------------------------------
  # * Update Skill Window Display Mode
  #--------------------------------------------------------------------------
  def update_skill_window_display_mode
    case @spell_command_window.index
    when 0
      # Change skill window mode to show only usable skills
      @skill_window.only_use_skill_mode(true)
      # Change display of all skills mode to false
      @skill_window.all_skill_display_mode(false)
    when 1
      # Change display of only usable skills to false
      @skill_window.only_use_skill_mode(false)
      # Change skill window mode to show all skills
      @skill_window.all_skill_display_mode(true)
    end
    # Change old spell index value to spell window command index
    @old_spell_value_command_index = @spell_command_window.index
    # Refresh command window
    @skill_window.refresh(@skill_window.actor)
    # Change skill window index to 0 if skill window index is more than skill window item max
    @skill_window.index = 0 if @skill_window.index > @skill_window.item_max
    return
  end
  #--------------------------------------------------------------------------
  # * Next Spell Actor
  #--------------------------------------------------------------------------
  def next_spell_actor
    @actor_index = @status_window.index if @actor_index == nil
    @actor_index += 1
    @actor_index %= $game_party.members.size
    @status_window.index = @actor_index
    @skill_window.index = 0 if @skill_window.item_max != 0
    @skill_window.refresh($game_party.members[@actor_index])
    return @skill_window.active = false, @spell_command_window.active = true if @skill_window.actor.dead?
    return @skill_window.active = false, @spell_command_window.active = true if @skill_window.item_max == 0
  end
  #--------------------------------------------------------------------------
  # * Prev Spell Actor
  #--------------------------------------------------------------------------
  def prev_spell_actor
    @actor_index = @status_window.index if @actor_index == nil
    @actor_index += $game_party.members.size - 1
    @actor_index %= $game_party.members.size
    @status_window.index = @actor_index
    @skill_window.index = 0 if @skill_window.item_max != 0
    @skill_window.refresh($game_party.members[@actor_index])
    return @skill_window.active = false, @spell_command_window.active = true if @skill_window.actor.dead?
    return @skill_window.active = false, @spell_command_window.active = true if @skill_window.item_max == 0
  end
  #--------------------------------------------------------------------------
  # * Use Skill
  #--------------------------------------------------------------------------
  def use_skill
    # Set skill variable value to the currently used skill
    @skill = @skill_window.skill
    # If actor can use the skill
    if @skill_window.actor.skill_can_use?(@skill)
      # Play desicion sound
      Sound.play_decision
      # Change skill window active to false
      @skill_window.active = false
      # Set return status index to the current status index
      @return_status_index = @status_window.index
      # Change status window active to true
      @status_window.active = true
      # If skill scope covers all characters and there are more tnan 1 party members
      if @skill.scope == 8 and $game_party.members.size > 1
        # Make cursor select eveveryone
        @status_window.index = 100
      else
        # Change status window index to 1
        @status_window.index = 0
       end
     else
      # Play buzzer sound
      Sound.play_buzzer
    end
  end
  #--------------------------------------------------------------------------
  # * Confirm Target
  #    If there is no effect (such as using a potion on an incapacitated
  #    character), play a buzzer SE.
  #--------------------------------------------------------------------------
  def determine_skill
    # Set used value to false
    used = false
    # If skill is for all
    if @skill.for_all?
      for target in $game_party.members
        target.skill_effect(@skill_window.actor, @skill)
        used = true unless target.skipped
      end
    elsif @skill.for_user?
      target = $game_party.members[@status_window.index]
      target.skill_effect(target, @skill)
      used = true unless target.skipped
    else
      $game_party.last_target_index = @status_window.index
      target = $game_party.members[@status_window.index]
      target.skill_effect(target, @skill)
      used = true unless target.skipped
    end
    # If used is true
    if used
      use_skill_nontarget
    else
      # Play buzzer sound
      Sound.play_buzzer
    end
  end
  #--------------------------------------------------------------------------
  # * Use Skill (apply effects to non-ally targets)
  #--------------------------------------------------------------------------
  def use_skill_nontarget
    # Play use skill sound
    Sound.play_use_skill
    # Detract MP equal to the skill MP cost
    @skill_window.actor.mp -= @skill_window.actor.calc_mp_cost(@skill)
    # Refresh status window
    @status_window.refresh
    # Refresh skill window
    @skill_window.refresh(@skill_window.actor)
    # If the whole party is dead
    if $game_party.all_dead?
      $scene = Scene_Gameover.new
    elsif @skill.common_event_id > 0
      $game_temp.common_event_id = @skill.common_event_id
      $scene = Scene_Map.new
    end
  end
  #--------------------------------------------------------------------------
  # * View Skill Information
  #    skill : skill from which to read data from
  #--------------------------------------------------------------------------
  def view_skill_information(skill)
    # If viewing spell information flag is false
    if @viewing_spell_information_window == false
      skill_info = skill
      # Change skill window visibility and active
      @skill_window.visible = false
      @skill_window.active = false
      # Change scene help header visibility, add text and change text color
      @scene_help_header.visible = true
      @scene_help_header.contents.font.color = @scene_help_header.text_color(0)
      @scene_help_header.contents.clear
      @scene_help_header.contents.draw_text(0, 0 , 505-32, 24, skill_info.name,1)
      # Change dummy help window visibility, add text and color
      @dummy_help_window.visible = true
      @dummy_help_window.contents.font.color =  @dummy_help_window.text_color(0)
      @dummy_help_window.contents.clear
      @dummy_help_window.contents.font.size = 22
      @dummy_help_window.contents.draw_text(0, -24, 505-32, 100-32,  skill_info.description.capitalize)
      # Change viewing spell information flag to true
      @viewing_spell_information_window = true
    else
      # Change skill window visibility and active
      @skill_window.visible = true
      @skill_window.active = true
      # Change help header window visibilty and clear text
      @scene_help_header.visible = false
      @scene_help_header.contents.clear
      # Change dummy help window visibily and clear text
      @dummy_help_window.visible = false
      @dummy_help_window.contents.clear
      # Change viewing spell information flag to false
      @viewing_spell_information_window = false
     return
    end
  end

#==============================================================================
# ** Scenario Methods
#------------------------------------------------------------------------------
#  These methods performs the scenario screen processing.
#==============================================================================

  #--------------------------------------------------------------------------
  # * Start Scenario Mode
  #--------------------------------------------------------------------------
  def start_scenario_mode
    # Start updating scenario processing
    @update_scenario_mode_processing = true
    # Change command window visibility
    @command_window.visible = false
    @command_window.active = false
    # Deactivate status window
    @status_window.active = false
    # Changing visibily of gold window
    @gold_time_window.visible = false
    # Change sceneraio header visibility to true
    @scenario_header.visible = true
    # Determining item index and activity
    if @item_window.item_max == 0
      @item_window.index = -1
      @item_window.active = false
    else
      @item_window.index = 0
      @item_window.active = true
    end
    # Change item window mode to display scenenario items
    @item_window.scenario_items_mode(true)
    @item_window.only_items_mode(false)
    @item_window.all_items_mode(false)
    # Changing command window visibility
    @item_window.visible = true
    # Refresh item window
    @item_window.refresh
    # Update Input
    Input.update
    return
  end
  #--------------------------------------------------------------------------
  # * End Scenario Scene
  #--------------------------------------------------------------------------
  def end_scenario_scene
    # End scenario processing
    @update_scenario_mode_processing = false
    # Change sceneraio header visibility to false
    @scenario_header.visible = false
    # Change item window mode to display normal items
    @item_window.active = false
    @item_window.only_items_mode(true)
    @item_window.all_items_mode(false)
    @item_window.scenario_items_mode(false)
    # Change item window index
    @item_window.index = -1
    # Changing command window visibility
    @item_window.visible = false
    # Refresh item window
    @item_window.refresh
    # Change command window visibility
    @command_window.visible = true
    @command_window.active = true
    # Deactivate status window
    @status_window.active = false
    # Changing visibily of gold window
    @gold_time_window.visible = true
    # Update Input
    Input.update
    return
  end
  #--------------------------------------------------------------------------
  # * Update Scenario Item Choosing
  #--------------------------------------------------------------------------
  def update_scenario_item_choosing
    # If Input Trigger Cancel
    if Input.trigger?(Input::B)
      # Play cancel sound
      Sound.play_cancel
      # If viewing sceneario information flag is true
      if @viewing_scenario_information_window == true
        # View scenario_ information
        view_scenario_item_information(@item_window.item)
        return
      end
      # End scenario scene processing
      end_scenario_scene
      return
    end

    # If Input Trigger CTRL
    if Input.trigger?(Input::CTRL)
      # PLay desicion sound
      Sound.play_decision
      # View item information
      view_scenario_item_information(@item_window.item)
      return
    end
  end
  #--------------------------------------------------------------------------
  # * View Scenario Item Information
  #    item : item from which to read data from
  #--------------------------------------------------------------------------
  def view_scenario_item_information(item)
    # If viewing scenario information flag is false
    if @viewing_scenario_information_window == false
      item_info = item
      # Change item window visibility and active
      @item_window.visible = false
      @item_window.active = false
      # Change scene help header visibility, add text and change text color
      @scene_help_header.visible = true
      @scene_help_header.contents.font.color = @scene_help_header.text_color(0)
      @scene_help_header.contents.clear
      @scene_help_header.contents.draw_text(0, 0 , 505-32, 24, item_info.name,1)
      # Change dummy help window visibility, add text and color
      @dummy_help_window.visible = true
      @dummy_help_window.contents.font.color =  @dummy_help_window.text_color(0)
      @dummy_help_window.contents.clear
      @dummy_help_window.contents.font.size = 22
      @dummy_help_window.contents.draw_text(0, -24, 505-32, 100-32,  item_info.description.capitalize)
      # Change viewing item information flag to true
      @viewing_scenario_information_window = true
    else
      # Change item window visibility and active
      @item_window.visible = true
      @item_window.active = true
      # Change help header window visibilty and clear text
      @scene_help_header.visible = false
      @scene_help_header.contents.clear
      # Change dummy help window visibily and clear text
      @dummy_help_window.visible = false
      @dummy_help_window.contents.clear
      # Change viewing scenario information flag to false
      @viewing_scenario_information_window = false
     return
    end
  end
  #--------------------------------------------------------------------------
  # * Termination Processing
  #--------------------------------------------------------------------------
  def terminate
    super
    # Dipose of back sprite
    @menuback_sprite.dispose
    @menuback_sprite.bitmap.dispose
    # Dispose command windows
    @command_window.dispose
    @item_command_window.dispose
    @spell_command_window.dispose
    # Dispose of windows
    @gold_time_window.dispose
    @status_window.dispose
    @item_window.dispose
    @skill_window.dispose
    # Dispose of headers and dummy windows
    @scene_header.dispose
    @dummy_help_window.dispose
    @scene_help_header.dispose
    @scenario_header.dispose
  end
end

#==============================================================================
# ** Window_MenuStatus
#------------------------------------------------------------------------------
#  This window displays party member status on the menu screen.
#==============================================================================

class Window_MenuStatus < Window_Selectable
  #--------------------------------------------------------------------------
  # * Public Instance Variables
  #--------------------------------------------------------------------------
  attr_reader   :normal_mode              #  Normal Mode flag
  attr_reader   :item_mode                #  Item Mode Flag
  attr_reader   :skill_mode               #  skill Mode Flag
  #--------------------------------------------------------------------------
  # * Object Initialization
  #     x : window X coordinate
  #     y : window Y coordinate
  #--------------------------------------------------------------------------
  def initialize(x, y)
    super(x, y, 544, 416)
    self.active = false
    self.contents.font.size = 18
    self.opacity = 0
    self.index = -1
    @normal_mode = true
    @item_mode = false
    @skill_mode = false
    refresh
  end
  #--------------------------------------------------------------------------
  # * Change Mode
  #    mode   : mode to modify 0 = Normal, 1 = Item, 2 = Skill
  #    value  : true or false value
  #--------------------------------------------------------------------------
  def change_mode(mode, value)
    # Modes array
    @normal_mode = (mode == 0 ? value : false )
    @item_mode =  (mode == 1 ? value : false )
    @skill_mode = (mode == 2 ? value : false )
    return
  end
  #--------------------------------------------------------------------------
  # * Refresh
  #--------------------------------------------------------------------------
  def refresh
    self.contents.clear
    @item_max = $game_party.members.size
    @column_max = 2
    for actor in $game_party.members
      y = 0
     if actor.index > 1
      x = 260 #272
      draw_actor_graphic(actor, 19 + actor.index * x - actor.index - @column_max * x, 90)
      draw_actor_name(actor, 96 + actor.index * x - actor.index - @column_max * x, 90)
      draw_actor_hp(actor, 96 + actor.index * x - actor.index - @column_max * x, y + 84 + WLH * 1 , 120, true)
      draw_actor_mp(actor, 96 + actor.index * x - actor.index - @column_max * x, y + 84 + WLH * 2 , 120, true)
      draw_actor_level(actor, 174 + actor.index * x - actor.index - @column_max * x, 90)
    else
      x = 260 #272
      draw_actor_graphic(actor, 20 + actor.index * x, 8)

      draw_actor_name(actor, 96 + actor.index * x, 10)
      draw_actor_hp(actor, 96 + actor.index * x, y + WLH * 1 + 4, 120, true)
      draw_actor_mp(actor, 96 + actor.index * x, y + WLH * 2 + 4, 120, true)
      draw_actor_level(actor, 174  + actor.index * x, 10)
    end
      x = actor.index * 96 + WLH / 2
      y = 0
    end
  end
  #--------------------------------------------------------------------------
  # * Draw Level
  #     actor : actor
  #     x     : draw spot x-coordinate
  #     y     : draw spot y-coordinate
  #--------------------------------------------------------------------------
  def draw_actor_level(actor, x, y)
    self.contents.font.color = system_color
    self.contents.draw_text(x, y, 32, WLH, Vocab::level_a)
    self.contents.font.color = normal_color
    self.contents.draw_text(x + 18, y, 24, WLH, actor.level, 2)
  end
  #--------------------------------------------------------------------------
  # * Draw Actor Walking Graphic
  #     actor : actor
  #     x     : draw spot x-coordinate
  #     y     : draw spot y-coordinate
  #--------------------------------------------------------------------------
  def draw_actor_graphic(actor, x, y)
    character_name = actor.character_name
    bitmap = Cache.character(character_name)
    sign = character_name[/^[\!\$]./]
    if sign != nil and sign.include?('$')
      cw = bitmap.width / 3
      ch = bitmap.height / 4
    else
      cw = bitmap.width / 12
      ch = bitmap.height / 8
    end
    n = actor.character_index
    src_rect = Rect.new((n%4*3+1)*cw, (n/4*4)*ch, cw, ch)
    dest_rect = Rect.new(x, y, 80, 80)
    dest_rect = Rect.new(x, y, 65, 65)
    self.contents.stretch_blt(dest_rect, bitmap, src_rect)
  end
  #--------------------------------------------------------------------------
  # * Draw Name
  #     actor : actor
  #     x     : draw spot x-coordinate
  #     y     : draw spot y-coordinate
  #--------------------------------------------------------------------------
  def draw_actor_name(actor, x, y)
    self.contents.font.color = hp_color(actor)
    self.contents.draw_text(x, y, 75, WLH, actor.name)
  end
  #--------------------------------------------------------------------------
  # * Update cursor
  #--------------------------------------------------------------------------
  def update_cursor
    if @index < 0               # No cursor
      self.cursor_rect.empty
    end
    case @index
     when 0, 1
       self.cursor_rect.set(19 + @index * 258, 0, 210, 86)
     when 2, 3
       self.cursor_rect.set(19 + @index * 258 - @index - @column_max * 258, 80, 210, 86)
     when 100
      self.cursor_rect.set(16, 0, contents.width-38, 163)

     end
   end
end

#==============================================================================
# ** Window_Gold & Time
#------------------------------------------------------------------------------
#  This window displays the amount of gold and played time.
#==============================================================================

class Window_Gold_Time < Window_Base
  #--------------------------------------------------------------------------
  # * Object Initialization
  #     x : window X coordinate
  #     y : window Y coordinate
  #--------------------------------------------------------------------------
  def initialize(x, y, width = 260, height = 80)
    super(x, y,  width, height)
    self.windowskin = Cache.system("TDS-Lufia Window")
    self.back_opacity = 255
    refresh
  end
  #--------------------------------------------------------------------------
  # * Refresh
  #--------------------------------------------------------------------------
  def refresh
    self.contents.clear
    self.contents.font.size = 25
    draw_playtime(0, 0, self.width-32, 0)
    draw_currency_value($game_party.gold, 0, 26, self.width-32)
  end
  #--------------------------------------------------------------------------
  # * Draw Play Time
  #     x : Draw spot X coordinate
  #     y : Draw spot Y coordinate
  #     width : Width
  #     align : Alignment
  #--------------------------------------------------------------------------
  def draw_playtime(x, y, width, align)
    @total_sec = Graphics.frame_count / Graphics.frame_rate
    hour = @total_sec / 60 / 60
    min = @total_sec / 60 % 60
    sec = @total_sec % 60
    time_string = sprintf("%02d:%02d:%02d", hour, min, sec)
    self.contents.font.color = normal_color
    self.contents.draw_text(x + 12, y, width, WLH, "TIME")
    self.contents.draw_text(x, y, width - 12, WLH + 2, time_string, 2)
  end
  #--------------------------------------------------------------------------
  # * Draw number with currency unit
  #     value : Number (gold, etc)
  #     x     : draw spot x-coordinate
  #     y     : draw spot y-coordinate
  #     width : Width
  #--------------------------------------------------------------------------
  def draw_currency_value(value, x, y, width)
    cx = contents.text_size(Vocab::gold).width
    self.contents.font.color = normal_color
    self.contents.draw_text(x, y, width-12, WLH, value, 2)
    self.contents.draw_text(x + 12, y, width, WLH, "GOLD")
  end
end

#==============================================================================
# ** TDS_Lufia_Window_Item
#------------------------------------------------------------------------------
#  This window displays a list of inventory items for the item screen, etc.
#==============================================================================

class TDS_Lufia_Window_Item < Window_Selectable
  #--------------------------------------------------------------------------
  # * Public Instance Variables
  #--------------------------------------------------------------------------
  attr_reader   :drop_mode               # Drop flag
  attr_reader   :item_mode               # Item display flag
  attr_reader   :all_mode                # All item display flag
  attr_reader   :scenario_mode           # Scenario display flag
  #--------------------------------------------------------------------------
  # * Object Initialization
  #     x      : window x-coordinate
  #     y      : window y-coordinate
  #     width  : window width
  #     height : window height
  #--------------------------------------------------------------------------
  def initialize(x, y, width, height)
    super(x, y, width, height)
    @use_custom_cursor = true
    @column_max = 1
    self.index = 0
    self.back_opacity = 255
    self.windowskin = Cache.system("TDS-Lufia Window")
    @drop_mode = false
    @item_mode = true
    @all_mode = false
    @scenario_mode = false
    refresh
  end
  #--------------------------------------------------------------------------
  # * Only Items Mode
  #--------------------------------------------------------------------------
  def all_items_mode(value)
    @all_mode = value
  end
  #--------------------------------------------------------------------------
  # * Only Items Mode
  #--------------------------------------------------------------------------
  def only_items_mode(value)
    @item_mode = value
  end
  #--------------------------------------------------------------------------
  # * Drop Items Mode
  #--------------------------------------------------------------------------
  def drop_items_mode(value)
    @drop_mode = value
  end
  #--------------------------------------------------------------------------
  # * Scenario Items Mode
  #--------------------------------------------------------------------------
  def scenario_items_mode(value)
    @scenario_mode = value
  end
  #--------------------------------------------------------------------------
  # * Get Item
  #--------------------------------------------------------------------------
  def item
    return @data[self.index]
  end
  #--------------------------------------------------------------------------
  # * Whether or not to include in item list
  #     item : item
  #--------------------------------------------------------------------------
  def include?(item)
    return false if item == nil
    if $game_temp.in_battle
      return false unless item.is_a?(RPG::Item)
    end
    return true
  end
  #--------------------------------------------------------------------------
  # * Whether or not to display in enabled state
  #     item : item
  #--------------------------------------------------------------------------
  def enable?(item)
    return $game_party.item_can_use?(item)
  end
  #--------------------------------------------------------------------------
  # * Drop item
  #     item : item
  #--------------------------------------------------------------------------
  def drop_item(item)
    $game_party.lose_item(item, $game_party.item_number(item))
  end
  #--------------------------------------------------------------------------
  # * Refresh
  #--------------------------------------------------------------------------
  def refresh
    @data = []
    for item in $game_party.items
      next unless include?(item)
      next if @item_mode == true and !$game_party.item_can_use?(item)
      next if @scenario_mode == true and !item.element_set.include?(17)
      if @item_mode == true
        if $game_party.item_can_use?(item) and !item.element_set.include?(17)
          @data.push(item)
        end
      end
      if @scenario_mode == true
        if item.element_set.include?(17)
          @data.push(item)
         end
      end
      if @all_mode
        if !item.element_set.include?(17)
          @data.push(item)
        end
      end
      if item.is_a?(RPG::Item) and item.id == $game_party.last_item_id
        self.index = @data.size - 1
      end
    end
    @data.push(nil) if include?(nil)
    @item_max = @data.size
    create_contents
    if @data.empty?
      @cursor_visible = false
    else
      @cursor_visible = true
    end
    for i in 0...@item_max
      draw_item(i)
    end
  end
  #--------------------------------------------------------------------------
  # * Draw Item
  #     index : item number
  #--------------------------------------------------------------------------
  def draw_item(index)
    rect = item_rect(index)
    self.contents.clear_rect(rect)
    item = @data[index]
    if item != nil
      number = $game_party.item_number(item)
      enabled = enable?(item)
      rect.width -= 30
      draw_item_name(item, rect.x += 26, rect.y, enabled)
      rect.x -= 20
      self.contents.draw_text(rect, sprintf(":%2d", number), 2)
    end
  end
  #--------------------------------------------------------------------------
  # * Draw Item
  #     index : item number
  #--------------------------------------------------------------------------
  def draw_item(index)
    rect = item_rect(index)
    self.contents.clear_rect(rect)
    item = @data[index]
    if item != nil
      number = $game_party.item_number(item)
      enabled = enable?(item)
      rect.width -= 30
      draw_item_name(item, rect.x += 26, rect.y, enabled)
      rect.x -= 20
      if @scenario_mode != true
        self.contents.draw_text(rect, sprintf(":%2d", number), 2)
      end
    end
  end
  #--------------------------------------------------------------------------
  # * Update Help Text
  #--------------------------------------------------------------------------
  def update_help
    @help_window.set_text(item == nil ? "" : item.description)
  end
end


#==============================================================================
# ** TDS_Lufia_Window_Skill
#------------------------------------------------------------------------------
#  This window displays a list of usable skills on the skill screen, etc.
#==============================================================================

class TDS_Lufia_Window_Skill < Window_Selectable
  #--------------------------------------------------------------------------
  # * Public Instance Variables
  #--------------------------------------------------------------------------
  attr_reader   :use_skill_mode               # Use skill display flag
  attr_reader   :all_skill_mode               # All skill display flag
  attr_reader   :actor                        # Actor information
  #--------------------------------------------------------------------------
  # * Object Initialization
  #     x      : window x-coordinate
  #     y      : window y-coordinate
  #     width  : window width
  #     height : window height
  #     actor  : actor
  #--------------------------------------------------------------------------
  def initialize(x, y, width, height, actor)
    super(x, y, width, height)
    @actor = actor
    @column_max = 2
    @use_custom_cursor = true
    self.index = 0
    self.back_opacity = 255
    self.windowskin = Cache.system("TDS-Lufia Window")
    self.index = 0
    @use_skill_mode = true
    @all_skill_mode = false
    refresh(@actor)
  end
  #--------------------------------------------------------------------------
  # * Only Use Skill Mode
  #--------------------------------------------------------------------------
  def only_use_skill_mode(value)
    @use_skill_mode = value
  end
  #--------------------------------------------------------------------------
  # * All skill display mode
  #--------------------------------------------------------------------------
  def all_skill_display_mode(value)
    @all_skill_mode = value
  end
  #--------------------------------------------------------------------------
  # * Get Skill
  #--------------------------------------------------------------------------
  def skill
    return @data[self.index]
  end
  #--------------------------------------------------------------------------
  # * Refresh
  #--------------------------------------------------------------------------
  def refresh(actor)
    @item_max = @data.size if @data != nil
    @data = []
    @actor = actor
    for skill in @actor.skills
      next if @use_skill_mode == true and skill_can_use?(skill) == false
      if @use_skill_mode == true
        @data.push(skill) if skill_can_use?(skill)
      end
      if @all_skill_mode == true
        @data.push(skill)
      end
      if skill.id == @actor.last_skill_id
        self.index = @data.size - 1
      end
    end
    @item_max = @data.size
    create_contents
    for i in 0...@item_max
      draw_item(i)
    end
    if @data.empty?
      @cursor_visible = false
    else
      @cursor_visible = true
    end
  end
  #--------------------------------------------------------------------------
  # * Draw Item
  #     index : item number
  #--------------------------------------------------------------------------
  def draw_item(index)
    rect = item_rect(index)
    self.contents.clear_rect(rect)
    skill = @data[index]
    if skill != nil
      rect.width -= 4
      enabled = skill_can_use?(skill, true)  # @actor.skill_can_use?(skill)

      draw_item_name(skill, rect.x + 26, rect.y, enabled)
      self.contents.draw_text(rect, @actor.calc_mp_cost(skill), 2)
    end
  end
  #--------------------------------------------------------------------------
  # * Determine Usable Skills
  #     skill : skill
  #--------------------------------------------------------------------------
  def skill_can_use?(skill,dead = false)
    skill = @data[index] if skill == nil
    return false unless skill.is_a?(RPG::Skill)
    return false unless @actor.movable? if dead == true
    return false if  @actor.silent? and skill.spi_f > 0
    return false if @actor.calc_mp_cost(skill) >  @actor.mp if dead == true
    return skill.menu_ok?
   end
  #--------------------------------------------------------------------------
  # * Update Help Text
  #--------------------------------------------------------------------------
  def update_help
    @help_window.set_text(skill == nil ? "" : skill.description)
  end
end

#==============================================================================
# ** Scene_Status
#------------------------------------------------------------------------------
#  This class performs the status screen processing.
#==============================================================================

class Scene_Status < Scene_Base
  #--------------------------------------------------------------------------
  # * Object Initialization
  #     actor_index : actor index
  #--------------------------------------------------------------------------
  def initialize(actor_index = 0)
    @actor_index = actor_index
  end
  #--------------------------------------------------------------------------
  # * Start processing
  #--------------------------------------------------------------------------
  def start
    super
    # Create Menu Back Sprite
    @menuback_sprite = Sprite.new
    @menuback_sprite.bitmap = Cache.system("Lufia Menu Back")
    @actor = $game_party.members[@actor_index]
    # Create Status Header Window
    @status_header = Window_Base.new(14, 330, 140, 56)
    @status_header.windowskin = Cache.system("TDS-Lufia Window")
    @status_header.back_opacity = 255
    @status_header.contents = Bitmap.new(140-32,56-32)
    @status_header.contents.font.color = @status_header.text_color(0)
    @status_header.contents.draw_text(0,0,140-32,56-32, "STATUS",1)
    # Create Status Window
    @status_window = Window_Status.new(@actor)
    # Create command window
    @command_window = TDS_Window_Command.new(370, ["NEXT", "PREVIOUS", "RETURN"],
    3, 0)
    @command_window.active = true
    @command_window.x = 154 #120 + 14
    @command_window.y = 330
  end
  #--------------------------------------------------------------------------
  # * Termination Processing
  #--------------------------------------------------------------------------
  def terminate
    super
    @menuback_sprite.dispose
    @menuback_sprite.bitmap.dispose
    @status_window.dispose
    @status_header.dispose
    @command_window.dispose
  end
  #--------------------------------------------------------------------------
  # * Return to Original Screen
  #--------------------------------------------------------------------------
  def return_scene
    $scene = Scene_Menu.new(1)
  end
  #--------------------------------------------------------------------------
  # * Switch to Next Actor Screen
  #--------------------------------------------------------------------------
  def next_actor
    @actor_index += 1
    @actor_index %= $game_party.members.size
    @status_window.refresh($game_party.members[@actor_index])
  end
  #--------------------------------------------------------------------------
  # * Switch to Previous Actor Screen
  #--------------------------------------------------------------------------
  def prev_actor
    @actor_index += $game_party.members.size - 1
    @actor_index %= $game_party.members.size
    @status_window.refresh($game_party.members[@actor_index])
  end
  #--------------------------------------------------------------------------
  # * Frame Update
  #--------------------------------------------------------------------------
  def update
    @command_window.update
    @status_window.update
    if Input.trigger?(Input::B)
      Sound.play_cancel
      return_scene
    end
    if Input.trigger?(Input::C)
      case @command_window.index
      when 0
        Sound.play_cursor
        next_actor
      when 1
        Sound.play_cursor
        prev_actor
      when 2
        Sound.play_cancel
        return_scene
      end
    end
    super
  end
end


#==============================================================================
# ** Window_Status
#------------------------------------------------------------------------------
#  This window displays full status specs on the status screen.
#==============================================================================

class Window_Status < Window_Base
  #--------------------------------------------------------------------------
  # * Object Initialization
  #     actor : actor
  #--------------------------------------------------------------------------
  def initialize(actor)
    super(0, 0, 544, 416)
    self.opacity = 0
    self.contents.font.size = 20
    @actor = actor
    refresh(@actor)
  end
  #--------------------------------------------------------------------------
  # * Refresh
  #--------------------------------------------------------------------------
  def refresh(actor)
    @actor = actor
    self.contents.clear
    draw_actor_name(@actor, 78, 24)
    self.contents.font.color = system_color
    self.contents.draw_text(260, 24, 80, WLH, "CLASS")
    self.contents.draw_text(260, 48, 80, WLH, "STATES")
    self.contents.font.color = normal_color
    draw_actor_class(@actor, 308 + 30, 24)
    draw_actor_graphic(@actor, 8, 24)
    draw_basic_info(128, 24)
    draw_parameters(55, 110)
    draw_exp_info(60, 218)
    draw_equipments(262, 110)
  end
  #--------------------------------------------------------------------------
  # * Draw Basic Information
  #     x : Draw spot X coordinate
  #     y : Draw spot Y coordinate
  #--------------------------------------------------------------------------
  def draw_basic_info(x, y)
    draw_actor_level(@actor, x + 25, y + WLH * 0)
    draw_actor_state(@actor, x + 180 + 30, y + WLH * 1)
    draw_actor_hp(@actor, 78, y + WLH * 2 -24, 120, true)
    draw_actor_mp(@actor, 78, y + WLH * 3 -24, 120, true)
  end
  #--------------------------------------------------------------------------
  # * Draw Parameters
  #     x : Draw spot X coordinate
  #     y : Draw spot Y coordinate
  #--------------------------------------------------------------------------
  def draw_parameters(x, y)
    draw_actor_parameter(@actor, x, y + WLH * 0, 0)
    draw_actor_parameter(@actor, x, y + WLH * 1, 1)
    draw_actor_parameter(@actor, x, y + WLH * 2, 2)
    draw_actor_parameter(@actor, x, y + WLH * 3, 3)
  end
  #--------------------------------------------------------------------------
  # * Draw Experience Information
  #     x : Draw spot X coordinate
  #     y : Draw spot Y coordinate
  #--------------------------------------------------------------------------
  def draw_exp_info(x, y)
    s1 = @actor.exp_s
    s2 = @actor.next_rest_exp_s
    s_next = sprintf(Vocab::ExpNext, Vocab::level)
    self.contents.font.color = system_color
    self.contents.draw_text(x, y + WLH * 0, 180, WLH, "NOW EXP")
    self.contents.draw_text(x, y + WLH * 2 , 180, WLH, "NEXT LEVEL")
    self.contents.font.color = normal_color
    self.contents.draw_text(x - 30, y + WLH * 1, 180, WLH, s1, 2)
    self.contents.draw_text(x - 30, y + WLH * 3 , 180, WLH, s2, 2)
  end
  #--------------------------------------------------------------------------
  # * Draw Actor Walking Graphic
  #     actor : actor
  #     x     : draw spot x-coordinate
  #     y     : draw spot y-coordinate
  #--------------------------------------------------------------------------
  def draw_actor_graphic(actor, x, y)
    character_name = actor.character_name
    bitmap = Cache.character(character_name)
    sign = character_name[/^[\!\$]./]
    if sign != nil and sign.include?('$')
      cw = bitmap.width / 3
      ch = bitmap.height / 4
    else
      cw = bitmap.width / 12
      ch = bitmap.height / 8
    end
    n = actor.character_index
    src_rect = Rect.new((n%4*3+1)*cw, (n/4*4)*ch, cw, ch)
    dest_rect = Rect.new(x, y, 80, 80)
    dest_rect = Rect.new(x, y, 65, 65)
    self.contents.stretch_blt(dest_rect, bitmap, src_rect)
  end
  #--------------------------------------------------------------------------
  # * Draw State
  #     actor : actor
  #     x     : draw spot x-coordinate
  #     y     : draw spot y-coordinate
  #     width : draw spot width
  #--------------------------------------------------------------------------
  def draw_actor_state(actor, x, y, width = 96)
    count = 0
    if actor.states.empty?
      self.contents.draw_text(x, y, 80, WLH, "Fine")
    end
    for state in actor.states
      draw_icon(state.icon_index, x + 24 * count, y)
      count += 1
      break if (24 * count > width - 24)
    end
  end
  #--------------------------------------------------------------------------
  # * Draw Level
  #     actor : actor
  #     x     : draw spot x-coordinate
  #     y     : draw spot y-coordinate
  #--------------------------------------------------------------------------
  def draw_actor_level(actor, x, y)
    self.contents.font.color = system_color
    self.contents.draw_text(x, y, 32, WLH, Vocab::level_a)
    self.contents.font.color = normal_color
    self.contents.draw_text(x + 18, y, 24, WLH, actor.level, 2)
  end
  #--------------------------------------------------------------------------
  # * Draw Name
  #     actor : actor
  #     x     : draw spot x-coordinate
  #     y     : draw spot y-coordinate
  #--------------------------------------------------------------------------
  def draw_actor_name(actor, x, y)
    self.contents.font.color = hp_color(actor)
    self.contents.draw_text(x, y, 75, WLH, actor.name)
  end
  #--------------------------------------------------------------------------
  # * Draw Equipment
  #     x : Draw spot X coordinate
  #     y : Draw spot Y coordinate
  #--------------------------------------------------------------------------
  def draw_equipments(x, y)
    self.contents.font.color = system_color
    for i in 0..4
    self.contents.font.size = 25
     if @actor.equips[i] == nil
      self.contents.draw_text(x + 37,  y + i * 32, 100, WLH, "No Equip")
     end
      draw_item_name(@actor.equips[i], x , y + i * 32)
    end
    self.contents.font.size = 20
  end
  #--------------------------------------------------------------------------
  # * Draw Item Name
  #     item    : Item (skill, weapon, armor are also possible)
  #     x       : draw spot x-coordinate
  #     y       : draw spot y-coordinate
  #     enabled : Enabled flag. When false, draw semi-transparently.
  #--------------------------------------------------------------------------
  def draw_item_name(item, x, y, enabled = true)
    if item != nil
      draw_icon(item.icon_index, x + 2, y, enabled)
      self.contents.font.color = Color.new(255, 255, 255, 255)
      self.contents.font.color.alpha = enabled ? 255 : 128
      self.contents.draw_text(x + 31, y, 290, WLH, item.name)
    end
  end
end

#==============================================================================
# ** Scene_Equip
#------------------------------------------------------------------------------
#  This class performs the equipment screen processing.
#==============================================================================

class Scene_Equip < Scene_Base
  #--------------------------------------------------------------------------
  # * Constants
  #--------------------------------------------------------------------------
  EQUIP_TYPE_MAX = 5                      # Number of equip region
  #--------------------------------------------------------------------------
  # * Object Initialization
  #     actor_index : actor index
  #     equip_index : equipment index
  #--------------------------------------------------------------------------
  def initialize(actor_index = 0, equip_index = 0, command_index = 0)
    @actor_index = actor_index
    @equip_index = equip_index
    @command_index = command_index
    @viewing_item_window_info = false
    @viewing_equip_window_info = false
    @remove_item_mode = false
    @drop_item_mode = false

    @item_index_return = 0
  end
  #--------------------------------------------------------------------------
  # * Start processing
  #--------------------------------------------------------------------------
  def start
    super
    # Create Menu Back Sprite
    @menuback_sprite = Sprite.new
    @menuback_sprite.bitmap = Cache.system("Lufia Menu Back")


    # Actor information
    @actor = $game_party.members[@actor_index]
    # Create command window
    @command_window = TDS_Window_Command.new(247, ["EQUIP", "STRONGEST",
    "REMOVE", "REMOVE ALL", "DROP"])
    @command_window.x = 250
    @command_window.y = 247
    @command_window.index = @command_index

    if @actor.fix_equipment
      for i in 0...@command_window.commands.size
        @command_window.draw_item(i, false)
      end
    end

    @equip_window = Window_Equip.new(228, 56, @actor)
    @equip_window.index = @equip_index
    @equip_window.active = false
    @equip_window.change_cursor_visibility(false)
    @status_window = Window_EquipStatus.new(0, 0, @actor)

    create_item_windows
    update_item_windows

    # Create Dummy help window
    @dummy_help_window = Window_Base.new(18, 298, 510, 101)

    @dummy_help_window.windowskin = Cache.system("TDS-Lufia Window")
    @dummy_help_window.contents = Bitmap.new(510-32,56-32)
    @dummy_help_window.contents.font.color =  @dummy_help_window.text_color(0)

    @dummy_help_window.contents.font.size = 22
    @dummy_help_window.contents.draw_text(0, -24, 510-32, 100-32, "Help window text test")

    @dummy_help_window.back_opacity = 255
    @dummy_help_window.visible = false
    @dummy_help_window.z = 5000
    # Create Help Window Header
    @scene_help_header = Window_Base.new(18, 247, 510, 56)
    @scene_help_header.windowskin = Cache.system("TDS-Lufia Window")
    @scene_help_header.back_opacity = 255
    @scene_help_header.contents = Bitmap.new(510-32,56-32)
    @scene_help_header.contents.font.color = @scene_help_header.text_color(0)
    @scene_help_header.contents.draw_text(0, 0 , 505-32,56-32, "Item name",1)
    @scene_help_header.visible = false
    @scene_help_header.z = 5000
  end
  #--------------------------------------------------------------------------
  # * Termination Processing
  #--------------------------------------------------------------------------
  def terminate
    super
    @menuback_sprite.dispose
    @menuback_sprite.bitmap.dispose
    @command_window.dispose
    @equip_window.dispose
    @status_window.dispose
    dispose_item_windows
    @dummy_help_window.dispose
    @scene_help_header.dispose
  end
  #--------------------------------------------------------------------------
  # * Update Frame
  #--------------------------------------------------------------------------
  def update
    super
    # Update windows
    @command_window.update
    @equip_window.update
    update_status_window
    update_item_windows
    # If not viewing any info and command window active
    if @viewing_equip_window_info == false and @viewing_item_window_info == false and
      @command_window.active == true
      if Input.trigger?(Input::R)
        Sound.play_cursor
        next_actor
       elsif Input.trigger?(Input::L)
         Sound.play_cursor
         prev_actor
       end
     end
     # If command Window active
     if @command_window.active
       update_command_selection
     end
     # If equip window active or viewing equip item info
     if @equip_window.active or @viewing_equip_window_info
       update_equip_selection
       @equip_window.change_cursor_visibility(true)
     else
      if @item_window.active == false and @viewing_item_window_info == false
        @equip_window.change_cursor_visibility(false)
      end
    end
    # If item window active or viewing item window info
    if @item_window.active or @viewing_item_window_info
       update_item_selection
    end
  end
  #--------------------------------------------------------------------------
  # * Update Command Selection
  #--------------------------------------------------------------------------
  def update_command_selection
    if Input.trigger?(Input::B)
      Sound.play_cancel
      $scene = Scene_Menu.new(3)
    end
    # If input trigger
    if Input.trigger?(Input::C)
      if @actor.fix_equipment
        Sound.play_buzzer
        return
      end
      case @command_window.index
      when 0 # Equip
        Sound.play_decision
        @command_window.active = false
        @command_window.visible = false
        @item_window.visible = true
        @equip_window.active = true
        @remove_item_mode = false
        @drop_item_mode = false
        Input.update
      when 1 # Equip Strongest
        Sound.play_equip

        for i in 0...3
          equip_strongest_armor(i, i+1)
        end
        for i in 0...5
          @item_windows[i].refresh
        end

        equip_strongest_weapon

        @status_window.refresh
        Input.update
        return
      when 2 # Remove
        Sound.play_decision
        @command_window.active = false
        @equip_window.active = true
        @item_window.visible = false
        @remove_item_mode = true
        Input.update
      when 3 # Remove all
      Sound.play_equip
      old_equip_index = @equip_window.index
      for i in 0...5
        @actor.change_equip(i, nil)
        @equip_window.index = i
        @item_windows[i].refresh
        if @equip_window.item != nil
          equip_redraw_index = @item_windows[i].return_item_index(@equip_window.item)
          if equip_redraw_index != nil
            @item_windows[i].draw_item(equip_redraw_index)
          end
        end
        @status_window.refresh
      end
      @equip_window.index = old_equip_index
      @equip_window.refresh
      when 4 # Drop
        Sound.play_decision
        @command_window.active = false
        @equip_window.active = true
        @item_window.visible = false
        @drop_item_mode = true
        Input.update
     end
      return
    end
  end
  #--------------------------------------------------------------------------
  # * Update Equip Region Selection
  #--------------------------------------------------------------------------
  def update_equip_selection
    if Input.trigger?(Input::B)
      Sound.play_cancel
      if @viewing_equip_window_info
        if @drop_item_mode == true or @remove_item_mode == true
          @dummy_help_window.visible = false
          @scene_help_header.visible = false
          @command_window.visible = true
          @equip_window.active = true
          @scene_help_header.contents.clear
          @viewing_equip_window_info = false
          return
        end
        @dummy_help_window.visible = false
        @scene_help_header.visible = false
        @item_window.visible = true
        @equip_window.active = true
        @scene_help_header.contents.clear
        @viewing_equip_window_info = false
        @remove_item_mode = false
        @drop_item_mode = false
        return
      end
      @item_window.visible = false
      @equip_window.active = false
      @equip_window.change_cursor_visibility(false)
      @command_window.active = true
      @command_window.visible = true
      @remove_item_mode = false
      @drop_item_mode = false
    end

    if Input.trigger?(Input::C) and @viewing_equip_window_info == false
      if @remove_item_mode == true
        if @actor.fix_equipment or @equip_window.item == nil
          Sound.play_buzzer
          Input.update
          return
        else
          Sound.play_equip
          draw_index = @item_window.return_item_index(@equip_window.item)
          @actor.change_equip(@equip_window.index, nil)
          if draw_index != nil
            @item_window.draw_item(draw_index)
          end
          @item_window.refresh
          @equip_window.refresh
          @status_window.refresh
          Input.update
        return
        end
      end

      if @drop_item_mode == true
        if @actor.fix_equipment or @equip_window.item == nil
          Sound.play_buzzer
          Input.update
          return
        else
          Sound.play_equip
          draw_index = @item_window.return_item_index(@equip_window.item)
          @actor.change_equip(@equip_window.index, nil)
          $game_party.lose_item(@equip_window.item, 1, true)
          @equip_window.refresh
          if draw_index != nil
            @item_window.draw_item(draw_index)
          end
          @item_window.refresh
          @status_window.refresh
          Input.update
        return
        end
      end

      if @actor.fix_equipment or @item_window.item_max == 0
        Sound.play_buzzer
      else
        Sound.play_decision
        @equip_window.active = false
        @item_window.active = true
        @item_window.index = 0
        Input.update
      end
    end

    if Input.trigger?(Input::CTRL)
      if @viewing_equip_window_info == false
        return Sound.play_buzzer if @equip_window.item == nil
        Sound.play_decision
        if @drop_item_mode == true or @remove_item_mode == true
          @command_window.active = false
          @command_window.visible = false
          @equip_window.active = false
          @dummy_help_window.visible = true
          @scene_help_header.visible = true
          @scene_help_header.contents.font.color = @scene_help_header.text_color(0)
          @scene_help_header.contents.clear
          @scene_help_header.contents.draw_text(0, 0 , 510-32,56-32, @equip_window.item.name,1)
          @dummy_help_window.contents.font.color =  @dummy_help_window.text_color(0)
          @dummy_help_window.contents.clear
          @dummy_help_window.contents.font.size = 22
          @dummy_help_window.contents.draw_text(0, -24, 510-32, 100-32,   @equip_window.item.description.capitalize)
          @viewing_equip_window_info = true
          return
        end
        @dummy_help_window.visible = true
        @scene_help_header.visible = true
        @item_window.visible = false
        @equip_window.active = false
        @item_index_return = @item_window.index
        @scene_help_header.contents.font.color = @scene_help_header.text_color(0)
        @scene_help_header.contents.clear
        @scene_help_header.contents.draw_text(0, 0 , 510-32,56-32, @equip_window.item.name,1)
        @dummy_help_window.contents.font.color =  @dummy_help_window.text_color(0)
        @dummy_help_window.contents.clear
        @dummy_help_window.contents.font.size = 22
        @dummy_help_window.contents.draw_text(0, -24, 510-32, 100-32,   @equip_window.item.description.capitalize)
        @item_window.index = -1
        @viewing_equip_window_info = true
      else
        if @drop_item_mode == true or @remove_item_mode == true
          Sound.play_decision
          @dummy_help_window.visible = false
          @scene_help_header.visible = false
          @command_window.visible = true
          @equip_window.active = true
          @scene_help_header.contents.clear
          @viewing_equip_window_info = false
          return
        end
        Sound.play_decision
        @dummy_help_window.visible = false
        @scene_help_header.visible = false
        @item_window.visible = true
        @equip_window.active = true
        @scene_help_header.contents.clear
        @viewing_equip_window_info = false
        end
      return
    end
  end
  #--------------------------------------------------------------------------
  # * Update Item Selection
  #--------------------------------------------------------------------------
  def update_item_selection
    if Input.trigger?(Input::B)
      Sound.play_cancel
      if @viewing_item_window_info
        @dummy_help_window.visible = false
        @scene_help_header.visible = false
        @item_window.active = true
        @item_window.visible = true
        @item_window.index = @item_index_return
        @scene_help_header.contents.clear
        @viewing_item_window_info = false
        return
      end
      @equip_window.active = true
      @item_window.active = false
      @item_window.index = -1
    end

    if Input.trigger?(Input::C) and @viewing_item_window_info == false
      Sound.play_equip
      @actor.change_equip(@equip_window.index, @item_window.item)
      @equip_window.active = true
      @item_window.active = false
      @item_window.index = -1
      @equip_window.refresh
      for item_window in @item_windows
        item_window.refresh
      end
    end

    if Input.trigger?(Input::CTRL)
      Sound.play_decision
      if @viewing_item_window_info == false
        @dummy_help_window.visible = true
        @scene_help_header.visible = true
        @item_window.visible = false
        @item_window.active = false
        @item_index_return = @item_window.index
        @scene_help_header.contents.font.color = @scene_help_header.text_color(0)
        @scene_help_header.contents.clear
        @scene_help_header.contents.draw_text(0, 0 , 510-32,56-32, @item_window.item.name,1)
        @dummy_help_window.contents.font.color =  @dummy_help_window.text_color(0)
        @dummy_help_window.contents.clear
        @dummy_help_window.contents.font.size = 22
        @dummy_help_window.contents.draw_text(0, -24, 510-32, 100-32,  @item_window.item.description.capitalize)
        @item_window.index = -1
        @viewing_item_window_info = true
       else
        @dummy_help_window.visible = false
        @scene_help_header.visible = false
        @item_window.active = true
        @item_window.visible = true
        @item_window.index = @item_index_return

        @scene_help_header.contents.clear
        @viewing_item_window_info = false
        end
      return
    end
  end
  #--------------------------------------------------------------------------
  # * Update Status Window
  #--------------------------------------------------------------------------
  def update_status_window
    if @equip_window.active
      @status_window.set_new_parameters(nil, nil, nil, nil)
    elsif @item_window.active
      temp_actor = @actor.clone
      temp_actor.change_equip(@equip_window.index, @item_window.item, true)
      new_atk = temp_actor.atk
      new_def = temp_actor.def
      new_spi = temp_actor.spi
      new_agi = temp_actor.agi
      @status_window.set_new_parameters(new_atk, new_def, new_spi, new_agi)
    end
    @status_window.update
  end
  #--------------------------------------------------------------------------
  # * Equip Strongest Weapon
  #--------------------------------------------------------------------------
  def equip_strongest_weapon
    # Owned weapons array
    weapons = []
    # Actor class weapon set
    weapon_set = @actor.class.weapon_set
    # Block
    weapon_set.each do |i|
      next if $game_party.has_item?($data_weapons[i]) == false
      next if @actor.equippable?($data_weapons[i]) == false
      # Push weapon values into weapons variable
      weapons << $data_weapons[i]
    end
    # Return if weaponsa array is empty
    return if weapons == []
    # If actors currently equiped weapon is nil
    if @actor.weapons[0] == nil
      ver_weapon = weapons[0]
    else
      ver_weapon = @actor.weapons[0]
    end

    for weapon in weapons
      next if weapon.two_handed
      if ver_weapon.atk < weapon.atk
        ver_weapon = weapon
      end
    end
    # Equip Strongest Weapon
    @actor.change_equip(0, ver_weapon)
    # Reresh equip window
    @equip_window.refresh

  end

  #--------------------------------------------------------------------------
  # * Equip Strongest Armor
  #--------------------------------------------------------------------------
  def equip_strongest_armor(armor_kind , index)

    # Owned armors array
    armors = []
    # Actor class armor set
    armor_set = @actor.class.armor_set
    # Block
    armor_set.each do |i|
      next if $data_armors[i].kind == 3
      next if $game_party.has_item?($data_armors[i]) == false
      next if @actor.armors[armor_kind] == $data_armors[i]

      if $data_armors[i].kind == armor_kind
        armors << $data_armors[i]
      end
    end
    # Return if armors array is empty
    return if armors == []

    # If actor armor is nil
    if @actor.armors[armor_kind] == nil
      ver_armor = armors[0]
    else
      ver_armor = @actor.armors[armor_kind]
    end

    for armor in armors
      if ver_armor.def < armor.def
        ver_armor = armor
      end
    end
    # Equip strongest armor
    @actor.change_equip(index, ver_armor)
    # Reresh equip window
    @equip_window.refresh
  end
  #--------------------------------------------------------------------------
  # * Create Item Window
  #--------------------------------------------------------------------------
  def create_item_windows
    @item_windows = []
    for i in 0...EQUIP_TYPE_MAX
      @item_windows[i] = Window_EquipItem.new(18, 247, 510, 152, @actor, i)
      @item_windows[i].visible = (@equip_index == i)
      @item_windows[i].active = false
      @item_windows[i].visible = false
      @item_windows[i].index = -1
    end
  end
  #--------------------------------------------------------------------------
  # * Dispose of Item Window
  #--------------------------------------------------------------------------
  def dispose_item_windows
    for window in @item_windows
      window.dispose
    end
  end
  #--------------------------------------------------------------------------
  # * Switch to Next Actor Screen
  #--------------------------------------------------------------------------
  def next_actor
    @actor_index += 1
    @actor_index %= $game_party.members.size
    @actor = $game_party.members[@actor_index]
    @status_window.refresh(@actor)
    @equip_window.refresh(@actor)


    create_item_windows
    update_item_windows

    @viewing_item_window_info = false
    @viewing_equip_window_info = false
    @remove_item_mode = false
    @drop_item_mode = false
  end
  #--------------------------------------------------------------------------
  # * Switch to Previous Actor Screen
  #--------------------------------------------------------------------------
  def prev_actor
    @actor_index += $game_party.members.size - 1
    @actor_index %= $game_party.members.size
    @actor = $game_party.members[@actor_index]
    @status_window.refresh(@actor)
    @equip_window.refresh(@actor)

    create_item_windows
    update_item_windows

    @viewing_item_window_info = false
    @viewing_equip_window_info = false
    @remove_item_mode = false
    @drop_item_mode = false
  end
  #--------------------------------------------------------------------------
  # * Update Item Window
  #--------------------------------------------------------------------------
  def update_item_windows
    for i in 0...EQUIP_TYPE_MAX
      @item_windows[i].visible = false if @command_window.active == true
      if @command_window.active == false and @remove_item_mode == false and
        @drop_item_mode == false
        @item_windows[i].visible = (@equip_window.index == i)
        @item_windows[i].update
      end
    end
    @item_window = @item_windows[@equip_window.index]
  end
end

#==============================================================================
# ** Window_Equip
#------------------------------------------------------------------------------
#  This window displays items the actor is currently equipped with on the
# equipment screen.
#==============================================================================

class Window_Equip < Window_Selectable
  #--------------------------------------------------------------------------
  # * Object Initialization
  #     x     : window X coordinate
  #     y     : window Y corrdinate
  #     actor : actor
  #--------------------------------------------------------------------------
  def initialize(x, y, actor)
    super(x, y, 290, 200)
    @actor = actor
    @use_custom_cursor = true
    self.windowskin = Cache.system("TDS-Lufia Window")
    self.contents.font.color = Color.new(255, 255, 255, 255)
    self.opacity = 0
    refresh
    self.index = 0
  end
  #--------------------------------------------------------------------------
  # * Get Item
  #--------------------------------------------------------------------------
  def item
    return @data[self.index]
  end
  #--------------------------------------------------------------------------
  # * Refresh
  #--------------------------------------------------------------------------
  def refresh(actor = nil)
    self.contents.clear
    @actor = actor if actor != nil
    @data = []
    for item in @actor.equips do @data.push(item) end
    @item_max = @data.size

    for i in 0...@data.size
      if @data[i] == nil
        self.contents.font.color = Color.new(255, 255, 255, 255)
        self.contents.draw_text(48, 32 * i , 172, 24, "No Equip")
      end
      self.contents.font.color = Color.new(255, 255, 255, 255)
      draw_item_name(@data[i], 24, 32 * i)
    end
  end
  #--------------------------------------------------------------------------
  # * Draw Item Name
  #     item    : Item (skill, weapon, armor are also possible)
  #     x       : draw spot x-coordinate
  #     y       : draw spot y-coordinate
  #     enabled : Enabled flag. When false, draw semi-transparently.
  #--------------------------------------------------------------------------
  def draw_item_name(item, x, y, enabled = true)
    if item != nil
      draw_icon(item.icon_index, x + 2, y, enabled)
      self.contents.font.color = Color.new(255, 255, 255, 255)
      self.contents.font.color.alpha = enabled ? 255 : 128
      self.contents.draw_text(x + 31, y, 290, WLH, item.name)
    end
  end
  #--------------------------------------------------------------------------
  # * Get rectangle for displaying items
  #     index : item number
  #--------------------------------------------------------------------------
  def item_rect(index)
    rect = Rect.new(0, 0, 0, 0)
    rect.width = (contents.width + @spacing) / @column_max - @spacing
    rect.height = 25
    rect.x = index % @column_max * (rect.width + @spacing)
    rect.y = index / @column_max * 32
    return rect
  end
end

#==============================================================================
# ** Window_EquipItem
#------------------------------------------------------------------------------
#  This window displays choices when opting to change equipment on the
# equipment screen.
#==============================================================================

class Window_EquipItem < Window_Item
  #--------------------------------------------------------------------------
  # * Object Initialization
  #     x          : sindow X coordinate
  #     y          : sindow Y corrdinate
  #     width      : sindow width
  #     height     : sindow height
  #     actor      : actor
  #     equip_type : equip region (0-4)
  #--------------------------------------------------------------------------
  def initialize(x, y, width, height, actor, equip_type)
    @actor = actor
    if equip_type == 1 and actor.two_swords_style
      equip_type = 0                              # Change shield to weapon
    end
    @equip_type = equip_type
    super(x, y, width, height)
    @column_max = 1
    @use_custom_cursor = true
    @normal_color = normal_color
    self.contents.font.color = @normal_color
    self.windowskin = Cache.system("TDS-Lufia Window")
    self.back_opacity = 255
    refresh
  end

  #--------------------------------------------------------------------------
  # * Whether to include item in list
  #     item : item
  #--------------------------------------------------------------------------
  def return_item_index(item)
    item_index = item
    item_index = @data.index(item)
    return item_index
  end
  #--------------------------------------------------------------------------
  # * Whether to include item in list
  #     item : item
  #--------------------------------------------------------------------------
  def include?(item)
    return true if item == nil
    if @equip_type == 0
      return false unless item.is_a?(RPG::Weapon)
    else
      return false unless item.is_a?(RPG::Armor)
      return false unless item.kind == @equip_type - 1
    end
    return @actor.equippable?(item)
  end
  #--------------------------------------------------------------------------
  # * Draw Item
  #     index : item number
  #--------------------------------------------------------------------------
  def draw_item(index)
    @item_max = @data.size-1
    rect = item_rect(index)
    self.contents.clear_rect(rect)
    self.contents.font.color = normal_color
    item = @data[index]
    if item != nil
      number = $game_party.item_number(item)
      enabled = enable?(item)
      rect.width -= 14
      draw_item_name(item, rect.x + 26, rect.y, enabled)
      self.contents.draw_text(rect, sprintf(":%2d", number), 2)
    end
  end

  #--------------------------------------------------------------------------
  # * Whether to display item in enabled state
  #     item : item
  #--------------------------------------------------------------------------
  def enable?(item)
    return true
  end
end

#==============================================================================
# ** Window_EquipStatus
#------------------------------------------------------------------------------
#  This window displays actor parameter changes on the equipment screen, etc.
#==============================================================================

class Window_EquipStatus < Window_Base
  #--------------------------------------------------------------------------
  # * Object Initialization
  #     x     : window X coordinate
  #     y     : window Y corrdinate
  #     actor : actor
  #--------------------------------------------------------------------------
  def initialize(x, y, actor)
    super(x, y, 290, 300)
    @actor = actor
    self.opacity = 0
    self.contents.font.size = 20
    refresh
  end
  #--------------------------------------------------------------------------
  # * Refresh
  #--------------------------------------------------------------------------
  def refresh(actor = nil)
    self.contents.clear
    @actor = actor if actor != nil
    x = 128
    y = 24
    draw_actor_name(@actor, 78, y)
    draw_actor_graphic(@actor, 8, y)

    draw_actor_level(@actor, x + 25, y + WLH * 0)
    draw_actor_state(@actor, x + 180 + 30, y + WLH * 1)
    draw_actor_hp(@actor, 78, y + WLH * 2 -24, 120, true)
    draw_actor_mp(@actor, 78, y + WLH * 3 -24, 120, true)

    draw_parameter(55, 90 + WLH * 1, 0)
    draw_parameter(55, 90 + WLH * 2, 1)
    draw_parameter(55, 90 + WLH * 3, 2)
    draw_parameter(55, 90 + WLH * 4, 3)

    if self.active == false

    end
  end
  #--------------------------------------------------------------------------
  # * Set Parameters After Equipping
  #     new_atk : attack after equipping
  #     new_def : defense after equipping
  #     new_spi : spirit after equipping
  #     new_agi : agility after equipping
  #--------------------------------------------------------------------------
  def set_new_parameters(new_atk, new_def, new_spi, new_agi)
    if @new_atk != new_atk or @new_def != new_def or
       @new_spi != new_spi or @new_agi != new_agi
      @new_atk = new_atk
      @new_def = new_def
      @new_spi = new_spi
      @new_agi = new_agi
      refresh
    end
  end
  #--------------------------------------------------------------------------
  # * Get Post Equip Parameter Drawing Color
  #     old_value : parameter before equipment change
  #     new_value : parameter after equipment change
  #--------------------------------------------------------------------------
  def new_parameter_color(old_value, new_value)
    if new_value > old_value      # Get stronger
      return power_up_color
    elsif new_value == old_value  # No change
      return normal_color
    else                          # Get weaker
      return power_down_color
    end
  end
  #--------------------------------------------------------------------------
  # * Draw Parameters
  #     x    : draw spot x-coordinate
  #     y    : draw spot y-coordinate
  #     type : type of parameter (0 - 3)
  #--------------------------------------------------------------------------
  def draw_parameter(x, y, type)
    case type
    when 0
      name = Vocab::atk
      value = @actor.atk
      new_value = @new_atk
    when 1
      name = Vocab::def
      value = @actor.def
      new_value = @new_def
    when 2
      name = Vocab::spi
      value = @actor.spi
      new_value = @new_spi
    when 3
      name = Vocab::agi
      value = @actor.agi
      new_value = @new_agi
    end
    self.contents.font.color = system_color
    self.contents.draw_text(x + 4, y, 80, WLH, name)
    self.contents.font.color = normal_color
    self.contents.draw_text(x + 50, y, 30, WLH, value, 2)
    self.contents.font.color = system_color


    stat_icons_positive = [120, 121, 122, 123]
    stat_icons_negative = [124, 125, 126, 127]
    if new_value != nil
      if new_value > value
        draw_icon(stat_icons_positive[type], x + 84, y-4, enabled = true)
      elsif new_value < value
        draw_icon(stat_icons_negative[type], x + 84, y, enabled = true)
      else
        draw_equal_icon(x + 84, y-2, enabled = true)
      end
    end

    if new_value != nil
      self.contents.font.color = new_parameter_color(value, new_value)
      self.contents.draw_text(x + 110, y, 30, WLH, new_value, 2)
    end
  end
  #--------------------------------------------------------------------------
  # * Draw Actor Walking Graphic
  #     actor : actor
  #     x     : draw spot x-coordinate
  #     y     : draw spot y-coordinate
  #--------------------------------------------------------------------------
  def draw_actor_graphic(actor, x, y)
    character_name = actor.character_name
    bitmap = Cache.character(character_name)
    sign = character_name[/^[\!\$]./]
    if sign != nil and sign.include?('$')
      cw = bitmap.width / 3
      ch = bitmap.height / 4
    else
      cw = bitmap.width / 12
      ch = bitmap.height / 8
    end
    n = actor.character_index
    src_rect = Rect.new((n%4*3+1)*cw, (n/4*4)*ch, cw, ch)
    dest_rect = Rect.new(x, y, 80, 80)
    dest_rect = Rect.new(x, y, 65, 65)
    self.contents.stretch_blt(dest_rect, bitmap, src_rect)
  end
  #--------------------------------------------------------------------------
  # * Draw Equal Icon
  #     x     : draw spot x-coordinate
  #     y     : draw spot y-coordinate
  #     enabled    : Enabled flag. When false, draw semi-transparently.
  #--------------------------------------------------------------------------
  def draw_equal_icon(x, y, enabled = true)
    bitmap = Cache.system("Equal Icon")
    rect = Rect.new(0, 0, 24, 24)
    self.contents.blt(x, y, bitmap, rect, enabled ? 255 : 128)
  end
  #--------------------------------------------------------------------------
  # * Draw Name
  #     actor : actor
  #     x     : draw spot x-coordinate
  #     y     : draw spot y-coordinate
  #--------------------------------------------------------------------------
  def draw_actor_name(actor, x, y)
    self.contents.font.color = hp_color(actor)
    self.contents.draw_text(x, y, 75, WLH, actor.name)
  end
  #--------------------------------------------------------------------------
  # * Draw Level
  #     actor : actor
  #     x     : draw spot x-coordinate
  #     y     : draw spot y-coordinate
  #--------------------------------------------------------------------------
  def draw_actor_level(actor, x, y)
    self.contents.font.color = system_color
    self.contents.draw_text(x, y, 32, WLH, Vocab::level_a)
    self.contents.font.color = normal_color
    self.contents.draw_text(x + 18, y, 24, WLH, actor.level, 2)
  end
end

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

class Scene_File < Scene_Base
  #--------------------------------------------------------------------------
  # * Object Initialization
  #     saving       : save flag (if false, load screen)
  #     from_title   : flag: it was called from "Continue" on the title screen
  #     from_event   : flag: it was called from the "Call Save Screen" event
  #     return_index : value index when returning to the scene
  #--------------------------------------------------------------------------
  def initialize(saving, from_title, from_event, return_index = nil)
    @saving = saving
    @from_title = from_title
    @from_event = from_event
    @return_index = return_index
    @updating_exit = false
  end
  #--------------------------------------------------------------------------
  # * Start processing
  #--------------------------------------------------------------------------
  def start
    super
    # Create Menu Back Sprite
    @menuback_sprite = Sprite.new
    @menuback_sprite.bitmap = Cache.system("Lufia Menu Back")
    if @saving == false
      load_database                     # Load databasee
    else
      # Create Scene Header
      @scene_header = Window_Base.new(18, 32, 140, 56)
      @scene_header.windowskin = Cache.system("TDS-Lufia Window")
      @scene_header.back_opacity = 255
      @scene_header.contents = Bitmap.new(140-32,56-32)
      @scene_header.contents.font.color = @scene_header.text_color(0)
      @scene_header.contents.draw_text(0,0,140-32,56-32, "SAVE",1)
    end
    create_savefile_windows
    # Create Scene Header
    @first_save_header = Window_Base.new(137, 32, 389, 56)
    @first_save_header.windowskin = Cache.system("TDS-Lufia Window")
    @first_save_header.back_opacity = 255
    @first_save_header.contents = Bitmap.new(140-32,56-32)
    @first_save_header.contents.font.color = @first_save_header.text_color(0)
    @first_save_header.contents.draw_text(0,0,140-32,56-32, "Game Saved.",0)
    @first_save_header.visible = false
    if @saving
      @index = $game_temp.last_file_index
    else
      @index = self.latest_file_index
    end
    if @return_index != nil
      @index = @return_index
    end
    @savefile_windows[@index].selected = true
  end
  #--------------------------------------------------------------------------
  # * Load Database
  #--------------------------------------------------------------------------
  def load_database
    $data_actors        = load_data("Data/Actors.rvdata")
    $data_classes       = load_data("Data/Classes.rvdata")
    $data_skills        = load_data("Data/Skills.rvdata")
    $data_items         = load_data("Data/Items.rvdata")
    $data_weapons       = load_data("Data/Weapons.rvdata")
    $data_armors        = load_data("Data/Armors.rvdata")
    $data_enemies       = load_data("Data/Enemies.rvdata")
    $data_troops        = load_data("Data/Troops.rvdata")
    $data_states        = load_data("Data/States.rvdata")
    $data_animations    = load_data("Data/Animations.rvdata")
    $data_common_events = load_data("Data/CommonEvents.rvdata")
    $data_system        = load_data("Data/System.rvdata")
    $data_areas         = load_data("Data/Areas.rvdata")
  end
  #--------------------------------------------------------------------------
  # * Command: New Game
  #--------------------------------------------------------------------------
  def command_new_game
    confirm_player_location
    Sound.play_decision
    $game_party.setup_starting_members            # Initial party
    $game_map.setup($data_system.start_map_id)    # Initial map position
    $game_player.moveto($data_system.start_x, $data_system.start_y)
    $game_player.refresh
    $scene = Scene_Map.new
    RPG::BGM.fade(1500)
    Graphics.fadeout(60)
    Graphics.wait(40)
    Graphics.frame_count = 0
    RPG::BGM.stop
    $game_map.autoplay
  end
  #--------------------------------------------------------------------------
  # * Check Player Start Location Existence
  #--------------------------------------------------------------------------
  def confirm_player_location
    if $data_system.start_map_id == 0
      print "Player start location not set."
      exit
    end
  end
  #--------------------------------------------------------------------------
  # * Termination Processing
  #--------------------------------------------------------------------------
  def terminate
    super
    dispose_item_windows
    if @saving == true
      @scene_header.dispose
    end
    @menuback_sprite.dispose
    @menuback_sprite.bitmap.dispose
    @first_save_header.dispose
  end
  #--------------------------------------------------------------------------
  # * Return to Original Screen
  #--------------------------------------------------------------------------
  def return_scene
    if @from_event
      $scene = Scene_Map.new
    else
      if @saving == true
        $scene = Scene_Menu.new(5)
      end
    end
  end
  #--------------------------------------------------------------------------
  # * Frame Update
  #--------------------------------------------------------------------------
  def update
    super

    update_savefile_windows
    if @updating_exit
      updating_first_time_save_exit
      return
    end
    update_savefile_selection
  end
  #--------------------------------------------------------------------------
  # * Create Save File Window
  #--------------------------------------------------------------------------
  def create_savefile_windows
    @savefile_windows = []
    for i in 0..4
      next if @saving == true and i == 0
      @savefile_windows.push(Window_SaveFile.new(i, "Save#{i}.rvdata"))
    end
    @item_max = (@saving == true ? 4 : 5 )
  end
  #--------------------------------------------------------------------------
  # * Dispose of Save File Window
  #--------------------------------------------------------------------------
  def dispose_item_windows
    for window in @savefile_windows
      window.dispose
    end
  end
  #--------------------------------------------------------------------------
  # * Update Save File Window
  #--------------------------------------------------------------------------
  def update_savefile_windows
    for window in @savefile_windows
      window.update
      window.update_cursor_graphic
      window.update_cursor_animation
    end
  end
  #--------------------------------------------------------------------------
  # * Update Save File Selection
  #--------------------------------------------------------------------------
  def update_savefile_selection
    if Input.trigger?(Input::C)
      determine_savefile
      elsif Input.trigger?(Input::B)
      if @saving == false
        return
      end
      Sound.play_cancel
      return_scene
    else
      last_index = @index


      return if @updating_exit

      if Input.repeat?(Input::DOWN)
        cursor_down(Input.trigger?(Input::DOWN))
      end
      if Input.repeat?(Input::UP)
        cursor_up(Input.trigger?(Input::UP))
      end

      if Input.repeat?(Input::LEFT)
        cursor_up(Input.trigger?(Input::LEFT))
      end

      if Input.repeat?(Input::RIGHT)
        cursor_down(Input.trigger?(Input::RIGHT))
      end

      if @index != last_index
        Sound.play_cursor
        @savefile_windows[last_index].selected = false
        @savefile_windows[@index].selected = true
      end
    end
  end
  #--------------------------------------------------------------------------
  # * Updating first time save exit
  #--------------------------------------------------------------------------
  def updating_first_time_save_exit
    # Exit frame count
    @frames = 0 if @frames == nil
    @frames += 1 if @frames < 70
    if @frames == 70
      return_scene
    end
  end
  #--------------------------------------------------------------------------
  # * Confirm Save File
  #--------------------------------------------------------------------------
  def determine_savefile
    if @saving
      if @savefile_windows[@index].file_exist == false
        @first_save_header.visible = true
        Sound.play_save
        do_save
      else
        Sound.play_decision
        $scene = Scene_File_II.new(@savefile_windows[@index].filename, @saving,
        @index, @from_event)
        return
       end
     else
      if @savefile_windows[0].selected == true
        command_new_game
        return
      end
      if @savefile_windows[@index].file_exist
         Sound.play_decision
         $scene = Scene_File_II.new(@savefile_windows[@index].filename, @saving,
         @index, @from_event)
      else
        Sound.play_buzzer
        return
      end
    end
    $game_temp.last_file_index = @index
  end
  #--------------------------------------------------------------------------
  # * Move cursor down
  #     wrap : Wraparound allowed
  #--------------------------------------------------------------------------
  def cursor_down(wrap)
    if @index < @item_max - 1 or wrap
      @index = (@index + 1) % @item_max
    end
  end
  #--------------------------------------------------------------------------
  # * Move cursor up
  #     wrap : Wraparound allowed
  #--------------------------------------------------------------------------
  def cursor_up(wrap)
    if @index > 0 or wrap
      @index = (@index - 1 + @item_max) % @item_max
    end
  end
  #--------------------------------------------------------------------------
  # * Create Filename
  #     file_index : save file index (0-4)
  #--------------------------------------------------------------------------
  def make_filename(file_index)
    return if file_index == 0
    return "Save#{file_index}.rvdata"
  end
  #--------------------------------------------------------------------------
  # * Select File With Newest Timestamp
  #--------------------------------------------------------------------------
  def latest_file_index
    index = 0
    latest_time = Time.at(0)
    for i in 1...@savefile_windows.size
      if @savefile_windows[i].time_stamp > latest_time
        latest_time = @savefile_windows[i].time_stamp
        index = i
      end
    end
    return index
  end
  #--------------------------------------------------------------------------
  # * Execute Save
  #--------------------------------------------------------------------------
  def do_save
    file = File.open(@savefile_windows[@index].filename, "wb")
    write_save_data(file)
    file.close
    @savefile_windows[@index].redraw_new_save_infofmation
    @updating_exit = true
    return
  end
  #--------------------------------------------------------------------------
  # * Write Save Data
  #     file : write file object (opened)
  #--------------------------------------------------------------------------
  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)
  end
  #--------------------------------------------------------------------------
  # * Read Save Data
  #     file : file object for reading (opened)
  #--------------------------------------------------------------------------
  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)
    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

#==============================================================================
# ** Scene_File_II
#------------------------------------------------------------------------------
#  This class performs the save and load screen processing when rewriting.
#==============================================================================

class Scene_File_II < Scene_Base
  #--------------------------------------------------------------------------
  # * Object Initialization
  #     file          : Save file to load data from
  #     saving        : save flag (if false, load screen)
  #     return_index  : index to return
  #--------------------------------------------------------------------------
  def initialize(file, saving, return_index, from_event)
    @file = file
    @saving = saving
    @return_index = return_index
    @from_event = from_event
    load_saved_game_data(@file)
  end
  #--------------------------------------------------------------------------
  # * Start processing
  #--------------------------------------------------------------------------
  def start
    # Create Menu Back Sprite
    @menuback_sprite = Sprite.new
    @menuback_sprite.bitmap = Cache.system("Lufia Menu Back")
    # Create Status window
    @status_window = Window_File_MenuStatus.new(0, 0, @game_party)
    @status_window.active = false
    # Get map information
    map_info = load_data("Data/MapInfos.rvdata")
    # Get map name
    map_name = map_info[@game_map.map_id].name
    # Create map name window header
    @map_name_header = Window_Base.new(18, 198, 505, 76)
    @map_name_header.windowskin = Cache.system("TDS-Lufia Window")
    @map_name_header.back_opacity = 255
    @map_name_header.contents = Bitmap.new(505-32, 76-32)
    @map_name_header.contents.font.size = 37
    @map_name_header.contents.font.color = @map_name_header.text_color(0)
    @map_name_header.contents.draw_text(18, 7 , 505-32, 37, map_name.to_s, 0)
    # Create dummy command window header
    @dummy_command_window_header = Window_Base.new(358, 274, 165, 135)
    @dummy_command_window_header.windowskin = Cache.system("TDS-Lufia Window")
    @dummy_command_window_header.back_opacity = 255
    @dummy_command_window_header.contents = Bitmap.new(180-32, 130-32)
    @dummy_command_window_header.contents.font.size = 20
    @dummy_command_window_header.contents.font.color = @dummy_command_window_header.text_color(0)
    if @saving == true
      @dummy_command_window_header.contents.draw_text(3, 0 , 165-32, 24, "Save over this")
      @dummy_command_window_header.contents.draw_text(3, 24 , 165-32, 24, "file?")
    else
      @dummy_command_window_header.contents.draw_text(3, 0 , 165-32, 24, "Start the game")
      @dummy_command_window_header.contents.draw_text(3, 24 , 165-32, 24, "from this file?")
    end
    @dummy_command_window_header.contents.font.size = 25
    # Create command window
    @command_window = TDS_Window_Command.new(165, ["YES", "NO"])
    @command_window.x = 370
    @command_window.y = 332
    @command_window.opacity = 0
    # Create gold & time window
    @gold_time_header = Window_Base.new(18, 274, 340, 78)
    @gold_time_header.windowskin = Cache.system("TDS-Lufia Window")
    @gold_time_header.back_opacity = 255
    @gold_time_header.contents = Bitmap.new(340-32, 78-32)
    @gold_time_header.contents.font.size = 25
    @gold_time_header.contents.font.color = @gold_time_header.text_color(0)
    @gold_time_header.contents.draw_text(18, 0, 340-32, 24, "TIME", 0)
    @gold_time_header.contents.draw_text(18, 24 , 340-32, 24, "GOLD", 0)
    @gold_time_header.contents.draw_text(18, 24 , 300-32, 24, @game_party.gold , 2)
    # Calculate playtime
    total_sec = Graphics.frame_count / Graphics.frame_rate
    hour = total_sec / 60 / 60
    min = total_sec / 60 % 60
    sec = total_sec % 60
    time_string = sprintf("%02d:%02d:%02d", hour, min, sec)
    @gold_time_header.contents.draw_text(18, 0 , 300-32, 24, time_string , 2)
    # Create save cofirmation header
    @save_confirmation_header = Window_Base.new(18, 352, 340, 57)
    @save_confirmation_header.windowskin = Cache.system("TDS-Lufia Window")
    @save_confirmation_header.back_opacity = 255
    @save_confirmation_header.contents = Bitmap.new(340-32, 78-32)
    @save_confirmation_header.contents.font.size = 25
    @save_confirmation_header.contents.font.color = @save_confirmation_header.text_color(0)
    @save_confirmation_header.contents.draw_text(18, 0, 340-32, 24, "Game saved.", 0)
    @save_confirmation_header.visible = false
    # Save process flag
    @saving_process = false
  end
  #--------------------------------------------------------------------------
  # * Load Saved Game Data
  #     file : Save file to load data from
  #--------------------------------------------------------------------------
  def load_saved_game_data(file = nil)
    filename = file
    file = File.open(filename, "r")
    @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)
    return
  end
  #--------------------------------------------------------------------------
  # * Frame Update
  #--------------------------------------------------------------------------
  def update
    # Update command window
    @command_window.update
    # If saving process flag is true
    if @saving_process
      update_save_process
      return
    end
    # If input trigger cancel
    if Input.trigger?(Input::B)
      Sound.play_cancel
      $scene = Scene_File.new(@saving, false, false, @return_index)
      return
    end

    # If input is confirm
    if Input.trigger?(Input::C)
      case @command_window.index
      when 0
        if @saving
          Sound.play_save
          @command_window.active = false
          @save_confirmation_header.visible = true
          @saving_process = true
          $game_temp.last_file_index
          return
        else
          Sound.play_load
          @command_window.active = false
          do_load
          return
        end
      when 1
        Sound.play_cancel
        $scene = Scene_File.new(@saving, false, false, @return_index)
        return
      end
    end
  end
  #--------------------------------------------------------------------------
  # * Update save process
  #--------------------------------------------------------------------------
  def update_save_process
    # Exit frame count
    @frames = 0 if @frames == nil
    @frames += 1 if @frames < 70
    if @frames == 70
      do_save
    end
  end
  #--------------------------------------------------------------------------
  # * Execute Load
  #--------------------------------------------------------------------------
  def do_load
    file = File.open(@file, "rb")
    read_save_data(file)
    file.close
    $scene = Scene_Map.new
    RPG::BGM.fade(1500)
    Graphics.fadeout(60)
    Graphics.wait(40)
    @last_bgm.play
    @last_bgs.play
  end
  #--------------------------------------------------------------------------
  # * Execute Save
  #--------------------------------------------------------------------------
  def do_save
    file = File.open(@file, "wb")
    write_save_data(file)
    file.close
    if @from_event
      $scene = Scene_Map.new
    else
      $scene = Scene_Menu.new(5)
    end
    return
  end
  #--------------------------------------------------------------------------
  # * Write Save Data
  #     file : write file object (opened)
  #--------------------------------------------------------------------------
  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)
  end
  #--------------------------------------------------------------------------
  # * Read Save Data
  #     file : file object for reading (opened)
  #--------------------------------------------------------------------------
  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)
    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
  #--------------------------------------------------------------------------
  # * Termination Processing
  #--------------------------------------------------------------------------
  def terminate
    @menuback_sprite.dispose
    @menuback_sprite.bitmap.dispose
    @status_window.dispose
    @map_name_header.dispose
    @dummy_command_window_header.dispose
    @command_window.dispose
    @gold_time_header.dispose
    @save_confirmation_header.dispose
  end
end

#==============================================================================
# ** Window_File_MenuStatus
#------------------------------------------------------------------------------
#  This window displays party member status on the save and load screen.
#==============================================================================

class Window_File_MenuStatus < Window_Base
  #--------------------------------------------------------------------------
  # * Object Initialization
  #     x : window X coordinate
  #     y : window Y coordinate
  #--------------------------------------------------------------------------
  def initialize(x, y, party_data)
    super(x, y, 544, 416)
    self.active = false
    self.contents.font.size = 18
    self.opacity = 0
    @party_data = party_data
    @column_max = 2
    refresh
  end
  #--------------------------------------------------------------------------
  # * Refresh
  #--------------------------------------------------------------------------
  def refresh
    self.contents.clear
    @item_max = @party_data.members.size
    for actor in @party_data.members
      actor_index = @party_data.members.index(actor)
      y = 0
      if actor_index > 1
        x = 260
        draw_actor_graphic(actor, 19 + actor_index * x - actor_index - @column_max * x, 90)
        draw_actor_name(actor, 96 + actor_index * x - actor_index - @column_max * x, 90)
        draw_actor_hp(actor, 96 + actor_index * x - actor_index - @column_max * x, y + 84 + WLH * 1 , 120, true)
        draw_actor_mp(actor, 96 + actor_index * x - actor_index - @column_max * x, y + 84 + WLH * 2 , 120, true)
        draw_actor_level(actor, 174 + actor_index * x - actor_index - @column_max * x, 90)
      else
        x = 260
        draw_actor_graphic(actor, 20 + actor_index * x, 8)
        draw_actor_name(actor, 96 + actor_index * x, 10)
        draw_actor_hp(actor, 96 + actor_index * x, y + WLH * 1 + 4, 120, true)
        draw_actor_mp(actor, 96 + actor_index * x, y + WLH * 2 + 4, 120, true)
        draw_actor_level(actor, 174  + actor_index * x, 10)
      end
        x = actor_index * 96 + WLH / 2
        y = 0
    end
  end
  #--------------------------------------------------------------------------
  # * Draw Level
  #     actor : actor
  #     x     : draw spot x-coordinate
  #     y     : draw spot y-coordinate
  #--------------------------------------------------------------------------
  def draw_actor_level(actor, x, y)
    self.contents.font.color = system_color
    self.contents.draw_text(x, y, 32, WLH, Vocab::level_a)
    self.contents.font.color = normal_color
    self.contents.draw_text(x + 18, y, 24, WLH, actor.level, 2)
  end
  #--------------------------------------------------------------------------
  # * Draw Actor Walking Graphic
  #     actor : actor
  #     x     : draw spot x-coordinate
  #     y     : draw spot y-coordinate
  #--------------------------------------------------------------------------
  def draw_actor_graphic(actor, x, y)
    character_name = actor.character_name
    bitmap = Cache.character(character_name)
    sign = character_name[/^[\!\$]./]
    if sign != nil and sign.include?('$')
      cw = bitmap.width / 3
      ch = bitmap.height / 4
    else
      cw = bitmap.width / 12
      ch = bitmap.height / 8
    end
    n = actor.character_index
    src_rect = Rect.new((n%4*3+1)*cw, (n/4*4)*ch, cw, ch)
    dest_rect = Rect.new(x, y, 80, 80)
    dest_rect = Rect.new(x, y, 65, 65)
    self.contents.stretch_blt(dest_rect, bitmap, src_rect)
  end
  #--------------------------------------------------------------------------
  # * Draw Name
  #     actor : actor
  #     x     : draw spot x-coordinate
  #     y     : draw spot y-coordinate
  #--------------------------------------------------------------------------
  def draw_actor_name(actor, x, y)
    self.contents.font.color = hp_color(actor)
    self.contents.draw_text(x, y, 75, WLH, actor.name)
  end
end

#==============================================================================
# ** Window_SaveFile
#------------------------------------------------------------------------------
#  This window displays save files on the save and load screens.
#==============================================================================

class Window_SaveFile < Window_Base
  #--------------------------------------------------------------------------
  # * Public Instance Variables
  #--------------------------------------------------------------------------
  attr_reader   :filename                 # filename
  attr_reader   :file_exist               # file existence flag
  attr_reader   :time_stamp               # timestamp
  attr_reader   :selected                 # selected
  #--------------------------------------------------------------------------
  # * Object Initialization
  #     file_index : save file index (0-3)
  #     filename   : filename
  #--------------------------------------------------------------------------
  def initialize(file_index, filename, saving = false)
    window_values = [
    # Start
    values = [18, 32, 140, 56 ],
    # Save files
    values = [18, 88, 254, 160 ],
    values = [272, 88, 254, 160 ],
    values = [18, 248, 254, 160 ],
    values = [272, 248, 254, 160 ],
    ]

    v_x = window_values[file_index][0]
    v_y = window_values[file_index][1]
    v_height = window_values[file_index][2]
    v_width = window_values[file_index][3]
    super(v_x, v_y, v_height, v_width)
    self.windowskin = Cache.system("TDS-Lufia Window")
    self.back_opacity = 255
    create_custom_cursor
    @file_index = file_index
    @filename = filename
    @saving = saving
    load_gamedata
    refresh
    @selected = false

#    self.visible = false
  end
  #--------------------------------------------------------------------------
  # * Load Partial Game Data
  #    By default, switches and variables are not used (for expansion use,
  #    such as displaying place names)
  #--------------------------------------------------------------------------
  def load_gamedata
    @time_stamp = Time.at(0)
    @file_exist = FileTest.exist?(@filename)
    if @file_exist
      file = File.open(@filename, "r")
      @time_stamp = file.mtime
      begin
        @characters     = Marshal.load(file)
        @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)
        # Reads self switches
        Marshal.load(file)
        @game_actors = Marshal.load(file)
        @game_party = Marshal.load(file)
        Marshal.load(file)
        @total_sec = @frame_count / Graphics.frame_rate
      rescue
        @file_exist = false
      ensure
        file.close
      end
    end
  end
  #--------------------------------------------------------------------------
  # * Refresh
  #--------------------------------------------------------------------------
  def refresh
    self.contents.clear
    self.contents.font.color = normal_color
    if @file_index == 0
      name = "    START    "
      self.contents.draw_text(4, 0, 200, WLH, name)
    end
    if @file_exist == false and @file_index != 0
      self.contents.draw_text(30, 0, 200, WLH, "FREE")
    end
    @name_width = contents.text_size(name).width
    if @file_exist
      draw_party_characters(35, 105)
      draw_playtime(-35, 34, contents.width - 4, 2)
      draw_party_leader_name(30, 0)
    end
  end

  #--------------------------------------------------------------------------
  # * Redraw New Save Information
  #--------------------------------------------------------------------------
  def redraw_new_save_infofmation
    self.contents.clear
    self.contents.font.color = normal_color

    @time_stamp = Time.at(0)
    @file_exist = FileTest.exist?(@filename)
    if @file_exist
      file = File.open(@filename, "r")
      @time_stamp = file.mtime
      begin
        @characters     = Marshal.load(file)
        @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)
        # Reads self switches
        Marshal.load(file)
        @game_actors = Marshal.load(file)
        @game_party = Marshal.load(file)
        Marshal.load(file)
        @total_sec = @frame_count / Graphics.frame_rate
      rescue
        @file_exist = false
      ensure
        file.close
      end
    end


    draw_party_characters(35, 105)
    draw_playtime(-35, 34, contents.width - 4, 2)
    draw_party_leader_name(30, 0)

  end

  #--------------------------------------------------------------------------
  # * Draw Party Characters
  #     x : Draw spot X coordinate
  #     y : Draw spot Y coordinate
  #--------------------------------------------------------------------------
  def draw_party_characters(x, y)
    for i in 0...@characters.size
      name = @characters[i][0]
      index = @characters[i][1]
      draw_character(name, index, x + i * 51, y)
      self.contents.font.size = 18
      self.contents.draw_text(-11 + x + i * 51, 105, 24, 24, @game_party.members[i].level, 1)
      self.contents.font.size = 25
    end
  end
  #--------------------------------------------------------------------------
  # * Draw Play Time
  #     x : Draw spot X coordinate
  #     y : Draw spot Y coordinate
  #     width : Width
  #     align : Alignment
  #--------------------------------------------------------------------------
  def draw_playtime(x, y, width, align)
    hour = @total_sec / 60 / 60
    min = @total_sec / 60 % 60
    sec = @total_sec % 60
    time_string = sprintf("%02d:%02d:%02d", hour, min, sec)
    self.contents.font.color = normal_color
    self.contents.draw_text(x, y, width, WLH, "TIME     " + time_string, 2)
  end
  #--------------------------------------------------------------------------
  # * Draw Party Leader Name
  #     x : Draw spot X coordinate
  #     y : Draw spot Y coordinate
  #--------------------------------------------------------------------------
  def draw_party_leader_name(x, y)
    self.contents.draw_text(x, y, 100, WLH, "NAME")
    self.contents.draw_text(x + 77 , y, 85, WLH, @game_party.members[0].name, 0)
  end
  #--------------------------------------------------------------------------
  # * Set Selected
  #     selected : new selected (true = selected, false = unselected)
  #--------------------------------------------------------------------------
  def selected=(selected)
    @selected = selected
    update_cursor
  end
  #--------------------------------------------------------------------------
  # * Dispose
  #--------------------------------------------------------------------------
  def dispose
    self.contents.dispose
    @sprite.bitmap.dispose
    @sprite.dispose
    super
  end
  #--------------------------------------------------------------------------
  # * Create Custom Cursor
  #--------------------------------------------------------------------------
  def create_custom_cursor
    @sprite = Sprite.new
    @sprite.bitmap = Cache.system("Cursor")
    @sprite.src_rect.width = @sprite.bitmap.width / 6
    if @file_index == 0
      @sprite.x = self.x + 16
      @sprite.y = self.y + 16 #+ 4
    else
      @sprite.x = self.x + 16
      @sprite.y = self.y + 14 #+ 4
    end
    @sprite.visible = @selected
    @sprite.z = 9999
    update_cursor_graphic
  end
  #--------------------------------------------------------------------------
  # * Update Cursor Graphic
  #--------------------------------------------------------------------------
  def update_cursor_graphic
     @sprite.visible = @selected
  end
  #--------------------------------------------------------------------------
  # * Update Cursor Animation
  #--------------------------------------------------------------------------
  def update_cursor_animation
    @duration = -1 if @duration == nil
     if @selected
       @duration += 1
       @duration %= 8
      if @duration == 8 -1
        @sprite.src_rect.x += 24
        @sprite.src_rect.x %= 6 * 24
      end
    else
       @duration += 1
       @duration %= 8
      if @duration == 8 - 1
        @sprite.src_rect.x -= 24
        @sprite.src_rect.x %= 7 * 24
      end
    end
  end
  #--------------------------------------------------------------------------
  # * Update cursor
  #--------------------------------------------------------------------------
  def update_cursor
    if @selected
      self.cursor_rect.set(0, 0, @name_width + 8, WLH)
      update_cursor_graphic
    else
      self.cursor_rect.empty
    end
  end
end

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

class Scene_End < Scene_Base
  #--------------------------------------------------------------------------
  # * Start processing
  #--------------------------------------------------------------------------
  def start
    super
    # Create Menu Back Sprite
    @menuback_sprite = Sprite.new
    @menuback_sprite.bitmap = Cache.system("Lufia Menu Back")
    create_command_window
  end
  #--------------------------------------------------------------------------
  # * Post-Start Processing
  #--------------------------------------------------------------------------
  def post_start
    super
    open_command_window
  end
  #--------------------------------------------------------------------------
  # * Pre-termination Processing
  #--------------------------------------------------------------------------
  def pre_terminate
    super
    close_command_window
  end
  #--------------------------------------------------------------------------
  # * Termination Processing
  #--------------------------------------------------------------------------
  def terminate
    super
    dispose_command_window
    @menuback_sprite.dispose
    @menuback_sprite.bitmap.dispose
  end
  #--------------------------------------------------------------------------
  # * Return to Original Screen
  #--------------------------------------------------------------------------
  def return_scene
    $scene = Scene_Menu.new(6)
  end
  #--------------------------------------------------------------------------
  # * Frame Update
  #--------------------------------------------------------------------------
  def update
    super
    @command_window.update
    if @command_window.active == false and @command_window.openness == 255
      @command_window.active = true
      @command_window.index = 0
      @command_window.change_cursor_visibility(false)
    end

    if Input.trigger?(Input::B)
      Sound.play_cancel
      @command_window.index = -1
      return_scene
    elsif Input.trigger?(Input::C) and @command_window.active
      case @command_window.index
      when 0  # to title
        command_to_title
      when 1  # shutdown
        command_shutdown
      when 2  # quit
        command_cancel
      end
    end
  end
  #--------------------------------------------------------------------------
  # * Create Command Window
  #--------------------------------------------------------------------------
  def create_command_window
    s1 = Vocab::to_title
    s2 = Vocab::shutdown
    s3 = Vocab::cancel
    @command_window = TDS_Window_Command.new(172, [s1, s2, s3])
    @command_window.x = (544 - @command_window.width) / 2
    @command_window.y = (416 - @command_window.height) / 2
    @command_window.index = -1
    @command_window.active = false
    @command_window.openness = 0
  end
  #--------------------------------------------------------------------------
  # * Dispose of Command Window
  #--------------------------------------------------------------------------
  def dispose_command_window
    @command_window.dispose
  end
  #--------------------------------------------------------------------------
  # * Open Command Window
  #--------------------------------------------------------------------------
  def open_command_window
    @command_window.open
    begin
      @command_window.update
      Graphics.update
    end until @command_window.openness == 255
  end
  #--------------------------------------------------------------------------
  # * Close Command Window
  #--------------------------------------------------------------------------
  def close_command_window
    @command_window.close
    begin
      @command_window.update
      Graphics.update
    end until @command_window.openness == 0
  end
  #--------------------------------------------------------------------------
  # * Process When Choosing [To Title] Command
  #--------------------------------------------------------------------------
  def command_to_title
    @command_window.index = -1
    Sound.play_decision
    RPG::BGM.fade(800)
    RPG::BGS.fade(800)
    RPG::ME.fade(800)
    close_command_window
    Graphics.fadeout(60)
    $scene = Scene_File.new(false, true, false)
    Audio.bgm_play("Audio/BGM/Lufia II - Title Loading Screen", 100, 100)
  end
  #--------------------------------------------------------------------------
  # * Process When Choosing [Shutdown] Command
  #--------------------------------------------------------------------------
  def command_shutdown
    @command_window.index = -1
    Sound.play_decision
    RPG::BGM.fade(800)
    RPG::BGS.fade(800)
    RPG::ME.fade(800)
    $scene = nil
    exit
  end
  #--------------------------------------------------------------------------
  # *  Process When Choosing [Cancel] Command
  #--------------------------------------------------------------------------
  def command_cancel
    @command_window.index = -1
    Sound.play_decision
    return_scene
  end
end