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

class Scene_Bag
  #--------------------------------------------------------------------------
  # * Object Initialization
  #     menu_index : command cursor's initial position
  #--------------------------------------------------------------------------
  def initialize(menu_index = 0)
    @menu_index = menu_index
  end
  #--------------------------------------------------------------------------
  # * Main Processing
  #--------------------------------------------------------------------------
  def main
    # Make Map background
    @map = Spriteset_Map.new
    # Make command window
    s1 = "Items"
    s2 = "Skills"
    s3 = "Equipment"
    s4 = "Back To Menu"
    @command_window = Window_Command.new(160, [s1, s2, s3, s4])
    @command_window.index = @menu_index
    # If number of party members is 0
    if $game_party.actors.size == 0
      # Disable items, skills, equipment, and status
      @command_window.disable_item(0)
      @command_window.disable_item(1)
      @command_window.disable_item(2)
      @command_window.disable_item(3)
    end
    # Make status window
    @status_window = Window_MenuStatus.new
    @status_window.x = 160
    @status_window.y = 0
    # If save is forbidden
    if $game_system.save_disabled
      # Disable save
      @command_window.disable_item(4)
    end
    # Execute transition
    Graphics.transition
    # Main loop
    loop do
      # Update game screen
      Graphics.update
      # Update input information
      Input.update
      # Frame update
      update
      # Abort loop if screen is changed
      if $scene != self
        break
      end
    end
    # Prepare for transition
    Graphics.freeze
    # Dispose of windows
    @command_window.dispose
    @status_window.dispose
  end
  #--------------------------------------------------------------------------
  # * Frame Update
  #--------------------------------------------------------------------------
  def update
    # Update windows
    @command_window.update
    @status_window.update
    # If command window is active: call update_command
    if @command_window.active
      update_command
      return
    end
    # If status window is active: call update_status
    if @status_window.active
      update_status
      return
    end
  end
  #--------------------------------------------------------------------------
  # * Frame Update (when command window is active)
  #--------------------------------------------------------------------------
  def update_command
    # If B button was pressed
    if Input.trigger?(Input::B)
      # Play cancel SE
      $game_system.se_play($data_system.cancel_se)
      # Switch to map screen
      $scene = Scene_Menu.new
      return
    end
    # If C button was pressed
    if Input.trigger?(Input::C)
      # If command other than save or end game, and party members = 0
      if $game_party.actors.size == 0 and @command_window.index < 4
        # Play buzzer SE
        $game_system.se_play($data_system.buzzer_se)
        return
      end
      # Branch by command window cursor position
      case @command_window.index
      when 0  # item
        # Play decision SE
        $game_system.se_play($data_system.decision_se)
        # Switch to item screen
        $scene = Scene_Item.new
      when 1  # skill
        # Play decision SE
        $game_system.se_play($data_system.decision_se)
        # Make status window active
        @command_window.active = false
        @status_window.active = true
        @status_window.index = 0
      when 2  # equipment
        # Play decision SE
        $game_system.se_play($data_system.decision_se)
        # Make status window active
        @command_window.active = false
        @status_window.active = true
        @status_window.index = 0
      when 3 # Back to menu
        # Play decision SE
        $game_system.se_play($data_system.decision_se)
        # Switch To Menu
        $scene = Scene_Menu.new
      end
      return
    end
  end
  #--------------------------------------------------------------------------
  # * Frame Update (when status window is active)
  #--------------------------------------------------------------------------
  def update_status
    # If B button was pressed
    if Input.trigger?(Input::B)
      # Play cancel SE
      $game_system.se_play($data_system.cancel_se)
      # Make command window active
      @command_window.active = true
      @status_window.active = false
      @status_window.index = -1
      return
    end
    # If C button was pressed
    if Input.trigger?(Input::C)
      # Branch by command window cursor position
      case @command_window.index
      when 1  # skill
        # If this actor's action limit is 2 or more
        if $game_party.actors[@status_window.index].restriction >= 2
          # Play buzzer SE
          $game_system.se_play($data_system.buzzer_se)
          return
        end
        # Play decision SE
        $game_system.se_play($data_system.decision_se)
        # Switch to skill screen
        $scene = Scene_Skill.new(@status_window.index)
      when 2  # equipment
        # Play decision SE
        $game_system.se_play($data_system.decision_se)
        # Switch to equipment screen
        $scene = Scene_Equip.new(@status_window.index)
      when 3  # status
        # Play decision SE
        $game_system.se_play($data_system.decision_se)
        # Switch to status screen
        $scene = Scene_Status.new(@status_window.index)
      end
      return
    end
  end
end
#==============================================================================
# ** Scene_Item
#------------------------------------------------------------------------------
#  This class performs item screen processing.
#==============================================================================

class Scene_Item
  #--------------------------------------------------------------------------
  # * Main Processing
  #--------------------------------------------------------------------------
  def main
    # Make help window, item window
    @help_window = Window_Help.new
    @item_window = Window_Item.new
    # Associate help window
    @item_window.help_window = @help_window
    # Make target window (set to invisible / inactive)
    @target_window = Window_Target.new
    @target_window.visible = false
    @target_window.active = false
    # Execute transition
    Graphics.transition
    # Main loop
    loop do
      # Update game screen
      Graphics.update
      # Update input information
      Input.update
      # Frame update
      update
      # Abort loop if screen is changed
      if $scene != self
        break
      end
    end
    # Prepare for transition
    Graphics.freeze
    # Dispose of windows
    @help_window.dispose
    @item_window.dispose
    @target_window.dispose
  end
  #--------------------------------------------------------------------------
  # * Frame Update
  #--------------------------------------------------------------------------
  def update
    # Update windows
    @help_window.update
    @item_window.update
    @target_window.update
    # If item window is active: call update_item
    if @item_window.active
      update_item
      return
    end
    # If target window is active: call update_target
    if @target_window.active
      update_target
      return
    end
  end
  #--------------------------------------------------------------------------
  # * Frame Update (when item window is active)
  #--------------------------------------------------------------------------
  def update_item
    # If B button was pressed
    if Input.trigger?(Input::B)
      # Play cancel SE
      $game_system.se_play($data_system.cancel_se)
      # Switch to menu screen
      $scene = Scene_Bag.new(0)
      return
    end
    # If C button was pressed
    if Input.trigger?(Input::C)
      # Get currently selected data on the item window
      @item = @item_window.item
      # If not a use item
      unless @item.is_a?(RPG::Item)
        # Play buzzer SE
        $game_system.se_play($data_system.buzzer_se)
        return
      end
      # If it can't be used
      unless $game_party.item_can_use?(@item.id)
        # Play buzzer SE
        $game_system.se_play($data_system.buzzer_se)
        return
      end
      # Play decision SE
      $game_system.se_play($data_system.decision_se)
      # If effect scope is an ally
      if @item.scope >= 3
        # Activate target window
        @item_window.active = false
        @target_window.x = (@item_window.index + 1) % 2 * 304
        @target_window.visible = true
        @target_window.active = true
        # Set cursor position to effect scope (single / all)
        if @item.scope == 4 || @item.scope == 6
          @target_window.index = -1
        else
          @target_window.index = 0
        end
      # If effect scope is other than an ally
      else
        # If command event ID is valid
        if @item.common_event_id > 0
          # Command event call reservation
          $game_temp.common_event_id = @item.common_event_id
          # Play item use SE
          $game_system.se_play(@item.menu_se)
          # If consumable
          if @item.consumable
            # Decrease used items by 1
            $game_party.lose_item(@item.id, 1)
            # Draw item window item
            @item_window.draw_item(@item_window.index)
          end
          # Switch to map screen
          $scene = Scene_Map.new
          return
        end
      end
      return
    end
  end
  #--------------------------------------------------------------------------
  # * Frame Update (when target window is active)
  #--------------------------------------------------------------------------
  def update_target
    # If B button was pressed
    if Input.trigger?(Input::B)
      # Play cancel SE
      $game_system.se_play($data_system.cancel_se)
      # If unable to use because items ran out
      unless $game_party.item_can_use?(@item.id)
        # Remake item window contents
        @item_window.refresh
      end
      # Erase target window
      @item_window.active = true
      @target_window.visible = false
      @target_window.active = false
      return
    end
    # If C button was pressed
    if Input.trigger?(Input::C)
      # If items are used up
      if $game_party.item_number(@item.id) == 0
        # Play buzzer SE
        $game_system.se_play($data_system.buzzer_se)
        return
      end
      # If target is all
      if @target_window.index == -1
        # Apply item effects to entire party
        used = false
        for i in $game_party.actors
          used |= i.item_effect(@item)
        end
      end
      # If single target
      if @target_window.index >= 0
        # Apply item use effects to target actor
        target = $game_party.actors[@target_window.index]
        used = target.item_effect(@item)
      end
      # If an item was used
      if used
        # Play item use SE
        $game_system.se_play(@item.menu_se)
        # If consumable
        if @item.consumable
          # Decrease used items by 1
          $game_party.lose_item(@item.id, 1)
          # Redraw item window item
          @item_window.draw_item(@item_window.index)
        end
        # Remake target window contents
        @target_window.refresh
        # If all party members are dead
        if $game_party.all_dead?
          # Switch to game over screen
          $scene = Scene_Gameover.new
          return
        end
        # If common event ID is valid
        if @item.common_event_id > 0
          # Common event call reservation
          $game_temp.common_event_id = @item.common_event_id
          # Switch to map screen
          $scene = Scene_Map.new
          return
        end
      end
      # If item wasn't used
      unless used
        # Play buzzer SE
        $game_system.se_play($data_system.buzzer_se)
      end
      return
    end
  end
end
#==============================================================================
# ** Scene_Skill
#------------------------------------------------------------------------------
#  This class performs skill screen processing.
#==============================================================================

class Scene_Skill
  #--------------------------------------------------------------------------
  # * Object Initialization
  #     actor_index : actor index
  #--------------------------------------------------------------------------
  def initialize(actor_index = 0, equip_index = 0)
    @actor_index = actor_index
  end
  #--------------------------------------------------------------------------
  # * Main Processing
  #--------------------------------------------------------------------------
  def main
    # Get actor
    @actor = $game_party.actors[@actor_index]
    # Make help window, status window, and skill window
    @help_window = Window_Help.new
    @status_window = Window_SkillStatus.new(@actor)
    @skill_window = Window_Skill.new(@actor)
    # Associate help window
    @skill_window.help_window = @help_window
    # Make target window (set to invisible / inactive)
    @target_window = Window_Target.new
    @target_window.visible = false
    @target_window.active = false
    # Execute transition
    Graphics.transition
    # Main loop
    loop do
      # Update game screen
      Graphics.update
      # Update input information
      Input.update
      # Frame update
      update
      # Abort loop if screen is changed
      if $scene != self
        break
      end
    end
    # Prepare for transition
    Graphics.freeze
    # Dispose of windows
    @help_window.dispose
    @status_window.dispose
    @skill_window.dispose
    @target_window.dispose
  end
  #--------------------------------------------------------------------------
  # * Frame Update
  #--------------------------------------------------------------------------
  def update
    # Update windows
    @help_window.update
    @status_window.update
    @skill_window.update
    @target_window.update
    # If skill window is active: call update_skill
    if @skill_window.active
      update_skill
      return
    end
    # If skill target is active: call update_target
    if @target_window.active
      update_target
      return
    end
  end
  #--------------------------------------------------------------------------
  # * Frame Update (if skill window is active)
  #--------------------------------------------------------------------------
  def update_skill
    # If B button was pressed
    if Input.trigger?(Input::B)
      # Play cancel SE
      $game_system.se_play($data_system.cancel_se)
      # Switch to menu screen
      $scene = Scene_Bag.new(1)
      return
    end
    # If C button was pressed
    if Input.trigger?(Input::C)
      # Get currently selected data on the skill window
      @skill = @skill_window.skill
      # If unable to use
      if @skill == nil or not @actor.skill_can_use?(@skill.id)
        # Play buzzer SE
        $game_system.se_play($data_system.buzzer_se)
        return
      end
      # Play decision SE
      $game_system.se_play($data_system.decision_se)
      # If effect scope is ally
      if @skill.scope >= 3
        # Activate target window
        @skill_window.active = false
        @target_window.x = (@skill_window.index + 1) % 2 * 304
        @target_window.visible = true
        @target_window.active = true
        # Set cursor position to effect scope (single / all)
        if @skill.scope == 4 || @skill.scope == 6
          @target_window.index = -1
        elsif @skill.scope == 7
          @target_window.index = @actor_index - 10
        else
          @target_window.index = 0
        end
      # If effect scope is other than ally
      else
        # If common event ID is valid
        if @skill.common_event_id > 0
          # Common event call reservation
          $game_temp.common_event_id = @skill.common_event_id
          # Play use skill SE
          $game_system.se_play(@skill.menu_se)
          # Use up SP
          @actor.sp -= @skill.sp_cost
          # Remake each window content
          @status_window.refresh
          @skill_window.refresh
          @target_window.refresh
          # Switch to map screen
          $scene = Scene_Map.new
          return
        end
      end
      return
    end
    # If R button was pressed
    if Input.trigger?(Input::R)
      # Play cursor SE
      $game_system.se_play($data_system.cursor_se)
      # To next actor
      @actor_index += 1
      @actor_index %= $game_party.actors.size
      # Switch to different skill screen
      $scene = Scene_Skill.new(@actor_index)
      return
    end
    # If L button was pressed
    if Input.trigger?(Input::L)
      # Play cursor SE
      $game_system.se_play($data_system.cursor_se)
      # To previous actor
      @actor_index += $game_party.actors.size - 1
      @actor_index %= $game_party.actors.size
      # Switch to different skill screen
      $scene = Scene_Skill.new(@actor_index)
      return
    end
  end
  #--------------------------------------------------------------------------
  # * Frame Update (when target window is active)
  #--------------------------------------------------------------------------
  def update_target
    # If B button was pressed
    if Input.trigger?(Input::B)
      # Play cancel SE
      $game_system.se_play($data_system.cancel_se)
      # Erase target window
      @skill_window.active = true
      @target_window.visible = false
      @target_window.active = false
      return
    end
    # If C button was pressed
    if Input.trigger?(Input::C)
      # If unable to use because SP ran out
      unless @actor.skill_can_use?(@skill.id)
        # Play buzzer SE
        $game_system.se_play($data_system.buzzer_se)
        return
      end
      # If target is all
      if @target_window.index == -1
        # Apply skill use effects to entire party
        used = false
        for i in $game_party.actors
          used |= i.skill_effect(@actor, @skill)
        end
      end
      # If target is user
      if @target_window.index <= -2
        # Apply skill use effects to target actor
        target = $game_party.actors[@target_window.index + 10]
        used = target.skill_effect(@actor, @skill)
      end
      # If single target
      if @target_window.index >= 0
        # Apply skill use effects to target actor
        target = $game_party.actors[@target_window.index]
        used = target.skill_effect(@actor, @skill)
      end
      # If skill was used
      if used
        # Play skill use SE
        $game_system.se_play(@skill.menu_se)
        # Use up SP
        @actor.sp -= @skill.sp_cost
        # Remake each window content
        @status_window.refresh
        @skill_window.refresh
        @target_window.refresh
        # If entire party is dead
        if $game_party.all_dead?
          # Switch to game over screen
          $scene = Scene_Gameover.new
          return
        end
        # If command event ID is valid
        if @skill.common_event_id > 0
          # Command event call reservation
          $game_temp.common_event_id = @skill.common_event_id
          # Switch to map screen
          $scene = Scene_Map.new
          return
        end
      end
      # If skill wasn't used
      unless used
        # Play buzzer SE
        $game_system.se_play($data_system.buzzer_se)
      end
      return
    end
  end
end
#==============================================================================
# ** Scene_Equip
#------------------------------------------------------------------------------
#  This class performs equipment screen processing.
#==============================================================================

class Scene_Equip
  #--------------------------------------------------------------------------
  # * Object Initialization
  #     actor_index : actor index
  #     equip_index : equipment index
  #--------------------------------------------------------------------------
  def initialize(actor_index = 0, equip_index = 0)
    @actor_index = actor_index
    @equip_index = equip_index
  end
  #--------------------------------------------------------------------------
  # * Main Processing
  #--------------------------------------------------------------------------
  def main
    # Get actor
    @actor = $game_party.actors[@actor_index]
    # Make windows
    @help_window = Window_Help.new
    @left_window = Window_EquipLeft.new(@actor)
    @right_window = Window_EquipRight.new(@actor)
    @item_window1 = Window_EquipItem.new(@actor, 0)
    @item_window2 = Window_EquipItem.new(@actor, 1)
    @item_window3 = Window_EquipItem.new(@actor, 2)
    @item_window4 = Window_EquipItem.new(@actor, 3)
    @item_window5 = Window_EquipItem.new(@actor, 4)
    # Associate help window
    @right_window.help_window = @help_window
    @item_window1.help_window = @help_window
    @item_window2.help_window = @help_window
    @item_window3.help_window = @help_window
    @item_window4.help_window = @help_window
    @item_window5.help_window = @help_window
    # Set cursor position
    @right_window.index = @equip_index
    refresh
    # Execute transition
    Graphics.transition
    # Main loop
    loop do
      # Update game screen
      Graphics.update
      # Update input information
      Input.update
      # Frame update
      update
      # Abort loop if screen is changed
      if $scene != self
        break
      end
    end
    # Prepare for transition
    Graphics.freeze
    # Dispose of windows
    @help_window.dispose
    @left_window.dispose
    @right_window.dispose
    @item_window1.dispose
    @item_window2.dispose
    @item_window3.dispose
    @item_window4.dispose
    @item_window5.dispose
  end
  #--------------------------------------------------------------------------
  # * Refresh
  #--------------------------------------------------------------------------
  def refresh
    # Set item window to visible
    @item_window1.visible = (@right_window.index == 0)
    @item_window2.visible = (@right_window.index == 1)
    @item_window3.visible = (@right_window.index == 2)
    @item_window4.visible = (@right_window.index == 3)
    @item_window5.visible = (@right_window.index == 4)
    # Get currently equipped item
    item1 = @right_window.item
    # Set current item window to @item_window
    case @right_window.index
    when 0
      @item_window = @item_window1
    when 1
      @item_window = @item_window2
    when 2
      @item_window = @item_window3
    when 3
      @item_window = @item_window4
    when 4
      @item_window = @item_window5
    end
    # If right window is active
    if @right_window.active
      # Erase parameters for after equipment change
      @left_window.set_new_parameters(nil, nil, nil)
    end
    # If item window is active
    if @item_window.active
      # Get currently selected item
      item2 = @item_window.item
      # Change equipment
      last_hp = @actor.hp
      last_sp = @actor.sp
      @actor.equip(@right_window.index, item2 == nil ? 0 : item2.id)
      # Get parameters for after equipment change
      new_atk = @actor.atk
      new_pdef = @actor.pdef
      new_mdef = @actor.mdef
      # Return equipment
      @actor.equip(@right_window.index, item1 == nil ? 0 : item1.id)
      @actor.hp = last_hp
      @actor.sp = last_sp
      # Draw in left window
      @left_window.set_new_parameters(new_atk, new_pdef, new_mdef)
    end
  end
  #--------------------------------------------------------------------------
  # * Frame Update
  #--------------------------------------------------------------------------
  def update
    # Update windows
    @left_window.update
    @right_window.update
    @item_window.update
    refresh
    # If right window is active: call update_right
    if @right_window.active
      update_right
      return
    end
    # If item window is active: call update_item
    if @item_window.active
      update_item
      return
    end
  end
  #--------------------------------------------------------------------------
  # * Frame Update (when right window is active)
  #--------------------------------------------------------------------------
  def update_right
    # If B button was pressed
    if Input.trigger?(Input::B)
      # Play cancel SE
      $game_system.se_play($data_system.cancel_se)
      # Switch to menu screen
      $scene = Scene_Bag.new(2)
      return
    end
    # If C button was pressed
    if Input.trigger?(Input::C)
      # If equipment is fixed
      if @actor.equip_fix?(@right_window.index)
        # Play buzzer SE
        $game_system.se_play($data_system.buzzer_se)
        return
      end
      # Play decision SE
      $game_system.se_play($data_system.decision_se)
      # Activate item window
      @right_window.active = false
      @item_window.active = true
      @item_window.index = 0
      return
    end
    # If R button was pressed
    if Input.trigger?(Input::R)
      # Play cursor SE
      $game_system.se_play($data_system.cursor_se)
      # To next actor
      @actor_index += 1
      @actor_index %= $game_party.actors.size
      # Switch to different equipment screen
      $scene = Scene_Equip.new(@actor_index, @right_window.index)
      return
    end
    # If L button was pressed
    if Input.trigger?(Input::L)
      # Play cursor SE
      $game_system.se_play($data_system.cursor_se)
      # To previous actor
      @actor_index += $game_party.actors.size - 1
      @actor_index %= $game_party.actors.size
      # Switch to different equipment screen
      $scene = Scene_Equip.new(@actor_index, @right_window.index)
      return
    end
  end
  #--------------------------------------------------------------------------
  # * Frame Update (when item window is active)
  #--------------------------------------------------------------------------
  def update_item
    # If B button was pressed
    if Input.trigger?(Input::B)
      # Play cancel SE
      $game_system.se_play($data_system.cancel_se)
      # Activate right window
      @right_window.active = true
      @item_window.active = false
      @item_window.index = -1
      return
    end
    # If C button was pressed
    if Input.trigger?(Input::C)
      # Play equip SE
      $game_system.se_play($data_system.equip_se)
      # Get currently selected data on the item window
      item = @item_window.item
      # Change equipment
      @actor.equip(@right_window.index, item == nil ? 0 : item.id)
      # Activate right window
      @right_window.active = true
      @item_window.active = false
      @item_window.index = -1
      # Remake right window and item window contents
      @right_window.refresh
      @item_window.refresh
      return
    end
  end
end

# Script Name: Animated CMS
# By: viraniz
# Instructions
=begin
1.place above main and below all other scripts
2.Get the Bestiary Script
3.Get The Bag Menu Script From RpgRevolution
=end
#==============================================================================
# ** Scene_Menu
#------------------------------------------------------------------------------
#  This class performs menu screen processing.
#==============================================================================

class Scene_Menu
  #--------------------------------------------------------------------------
  # * Object Initialization
  #     menu_index : command cursor's initial position
  #--------------------------------------------------------------------------
  def initialize(menu_index = 0)
    @menu_index = menu_index
  end
  #--------------------------------------------------------------------------
  # * Main Processing
  #--------------------------------------------------------------------------
  def main
    # Make Map background
    @map = Spriteset_Map.new
    # Make command window
    s1 = "Pokedex"
    s2 = "Bag"
    s3 = "Save"
    @command_window = Window_Command.new(160, [s1, s2, s3])
    @command_window.index = @menu_index
    @command_window.move(480, 0, 125)
    # If number of party members is 0
    if $game_party.actors.size == 0
      # Disable items, skills, equipment, and status
      @command_window.disable_item(0)
      @command_window.disable_item(1)
      @command_window.disable_item(2)
      @command_window.disable_item(3)
    end
    # If save is forbidden
    if $game_system.save_disabled
      # Disable save
      @command_window.disable_item(4)
    end
    # Make gold window
    @gold_window = Window_Gold.new
    @gold_window.x = 0
    @gold_window.y = 3*32+32
    @gold_window.move(480, 3*32+32, 125)
    # Make a Location window
    # Execute transition
    Graphics.transition
    # Main loop
    loop do
      # Update game screen
      Graphics.update
      # Update input information
      Input.update
      # Frame update
      update
      # Abort loop if screen is changed
      if $scene != self
        break
      end
    end
    # Prepare for transition
    Graphics.freeze
    # Dispose of windows
    @command_window.dispose
    @gold_window.dispose
  end
  #--------------------------------------------------------------------------
  # * Frame Update
  #--------------------------------------------------------------------------
  def update
    # Update windows
    @command_window.update
    @gold_window.update
    # If command window is active: call update_command
    if @command_window.active
      update_command
      return
    end
    # If status window is active: call update_status
    if @status_window.active
      update_status
      return
    end
  end
  #--------------------------------------------------------------------------
  # * Frame Update (when command window is active)
  #--------------------------------------------------------------------------
  def update_command
    # If B button was pressed
    if Input.trigger?(Input::B)
      # Play cancel SE
      $game_system.se_play($data_system.cancel_se)
      # Switch to map screen
      $scene = Scene_Map.new
      return
    end
    # If C button was pressed
    if Input.trigger?(Input::C)
      # If command other than save or end game, and party members = 0
      if $game_party.actors.size == 0 and @command_window.index < 4
        # Play buzzer SE
        $game_system.se_play($data_system.buzzer_se)
        return
      end
      # Branch by command window cursor position
      case @command_window.index
      when 0  # Pokedex
        # Play decision SE
        $game_system.se_play($data_system.decision_se)
        # switch to Pokedex
        $scene = Scene_MonsterBook.new        
      when 1  # Bag
        # Play decision SE
        $game_system.se_play($data_system.decision_se)
        # Switch To Bag Screen
        $scene = Scene_Bag.new        
      when 2  # Save
         # Play decision SE
        $game_system.se_play($data_system.decision_se)
        # Switch To Save Screen
        $scene = Scene_Save.new
      end
      return
    end
  end
  #--------------------------------------------------------------------------
  # * Frame Update (when status window is active)
  #--------------------------------------------------------------------------
  def update_status
    # If B button was pressed
    if Input.trigger?(Input::B)
      # Play cancel SE
      $game_system.se_play($data_system.cancel_se)
      # Make command window active
      @command_window.active = true
      @status_window.active = false
      @status_window.index = -1
      return
    end
    # If C button was pressed
    if Input.trigger?(Input::C)
      # Branch by command window cursor position
      case @command_window.index
      when 1  # skill
        # If this actor's action limit is 2 or more
        if $game_party.actors[@status_window.index].restriction >= 2
          # Play buzzer SE
          $game_system.se_play($data_system.buzzer_se)
          return
        end
        # Play decision SE
        $game_system.se_play($data_system.decision_se)
        # Switch to skill screen
        $scene = Scene_Skill.new(@status_window.index)
      when 2  # equipment
        # Play decision SE
        $game_system.se_play($data_system.decision_se)
        # Switch to equipment screen
        $scene = Scene_Equip.new(@status_window.index)
      when 3  # status
        # Play decision SE
        $game_system.se_play($data_system.decision_se)
        # Switch to status screen
        $scene = Scene_Status.new(@status_window.index)
      end
      return
    end
  end
end
#======================================
# date = "May 13, 2005"
# remembered about and found and some stuff fixed "June 20, 2005"
#======================================
# Moving windows for menu's by: makeamidget
# still need some new stuff, like two moving windows at once...
# and support for Selectable Windows and Command Windows
#======================================
# modified by HonorBlade, June 28, 2005
# now works with all types of windows
# create a window in the usual way, then use its "move" method
#======================================
# rewritten (barely) - makeamidget- i changed some stuff in here but
# it is still HonorBlades mod..  i just took out some now useless stuff... and
# made some code look prettier
#======================================
# it's HonorBlade once again
# man these comments are getting longer than the script itself:-)
# added: move window now works in all directions
# also had to fix a few bugs
#======================================

class Window_Base < Window

def initialize(x, y, width, height)
super()
@windowskin_name = $game_system.windowskin_name
self.windowskin = RPG::Cache.windowskin(@windowskin_name)
@end_x = self.x = x
@end_y = self.y = y
@end_o = self.opacity
@move_enabled = false
self.width = width
self.height = height
self.z = 100
end

def move(end_x=0, end_y=0, end_o =255)
@end_x = end_x
@end_y = end_y
@end_o = end_o
@move_enabled = true
end

def update_position
Graphics.update
if self.x < @end_x
if self.x + 20 < @end_x
self.x += 20
else
self.x = @end_x
end
end
if self.x > @end_x
if self.x - 20 > @end_x
self.x -= 20
else
self.x = @end_x
end
end
if self.y < @end_y
if self.y + 20 < @end_y
self.y += 20
else
self.y = @end_y
end
end
if self.y > @end_y
if self.y - 20 > @end_y
self.y -= 20
else
self.y = @end_y
end
end
if self.opacity.to_i < @end_o
if self.opacity + 20 < @end_o
self.opacity += 20
else
self.opacity = @end_o
end    
end
if self.opacity.to_i > @end_o
if self.opacity - 20 > @end_o
self.opacity -= 20
else
self.opacity = @end_o
end    
end

update
end

def update
super
if $game_system.windowskin_name != @windowskin_name
  @windowskin_name = $game_system.windowskin_name
  self.windowskin = RPG::Cache.windowskin(@windowskin_name)
end
if @move_enabled
if self.x != @end_x or self.y != @end_y or self.opacity != @end_o
  update_position
else
  @move_enabled = false
end
end
end

def finished?
if self.x == @end_x and self.y == @end_y
return true
else
return false
end
end

end

#==============================================================================
# ■ Bestiary
#------------------------------------------------------------------------------
# Created by Momomo
# Modified by Thousand Dragoon Link
#==============================================================================

module Enemy_Book_Config
DROP_ITEM_NEED_ANALYZE = false
EVA_NAME = "Evasion"            
SHOW_COMPLETE_TYPE = 3        
                        
end

class Game_Temp
attr_accessor :enemy_book_data
alias temp_enemy_book_data_initialize initialize
def initialize
  temp_enemy_book_data_initialize
  @enemy_book_data = Data_MonsterBook.new
end
end

class Game_Party
attr_accessor :enemy_info          
#--------------------------------------------------------------------------
alias book_info_initialize initialize
def initialize
  book_info_initialize
  @enemy_info = {}
end
#--------------------------------------------------------------------------
def add_enemy_info(enemy_id, type = 0)
  case type
  when 0
    if @enemy_info[enemy_id] == 2
      return false
    end
    @enemy_info[enemy_id] = 1
  when 1
    @enemy_info[enemy_id] = 2
  when -1
    @enemy_info[enemy_id] = 0
  end
end
#--------------------------------------------------------------------------
def enemy_book_max
  return $game_temp.enemy_book_data.id_data.size - 1
end
#--------------------------------------------------------------------------
def enemy_book_now
  now_enemy_info = @enemy_info.keys
  no_add = $game_temp.enemy_book_data.no_add_element
  new_enemy_info = []
  for i in now_enemy_info
    enemy = $data_enemies[i]
    next if enemy.name == ""
    if enemy.element_ranks[no_add] == 1
      next
    end
    new_enemy_info.push(enemy.id)
  end
  return new_enemy_info.size
end
#--------------------------------------------------------------------------
def enemy_book_complete_percentage
  e_max = enemy_book_max.to_f
  e_now = enemy_book_now.to_f
  comp = e_now / e_max * 100
  return comp.truncate
end
end

class Interpreter
def enemy_book_max
  return $game_party.enemy_book_max
end
def enemy_book_now
  return $game_party.enemy_book_now
end
def enemy_book_comp
  return $game_party.enemy_book_complete_percentage
end
end

class Scene_Battle
alias add_enemy_info_start_phase5 start_phase5
def start_phase5
  for enemy in $game_troop.enemies
    unless enemy.hidden
      $game_party.add_enemy_info(enemy.id, 0)
    end
  end
  add_enemy_info_start_phase5
end
end

class Window_Base < Window
#--------------------------------------------------------------------------
def draw_enemy_drop_item(enemy, x, y)
  self.contents.font.color = normal_color
  treasures = []
  if enemy.item_id > 0
    treasures.push($data_items[enemy.item_id])
  end
  if enemy.weapon_id > 0
    treasures.push($data_weapons[enemy.weapon_id])
  end
  if enemy.armor_id > 0
    treasures.push($data_armors[enemy.armor_id])
  end
  if treasures.size > 0
    item = treasures[0]
    bitmap = RPG::Cache.icon(item.icon_name)
    opacity = 255
    self.contents.blt(x, y + 4, bitmap, Rect.new(0, 0, 24, 24), opacity)
    name = treasures[0].name
  else
    self.contents.font.color = disabled_color
    name = "No Item"
  end
  self.contents.draw_text(x+28, y, 212, 32, name)
end
#--------------------------------------------------------------------------
def draw_enemy_book_id(enemy, x, y)
  self.contents.font.color = normal_color
  id = $game_temp.enemy_book_data.id_data.index(enemy.id)
  self.contents.draw_text(x, y, 32, 32, id.to_s)
end
#--------------------------------------------------------------------------
def draw_enemy_name(enemy, x, y)
  self.contents.font.color = normal_color
  self.contents.draw_text(x, y, 152, 32, enemy.name)
end
#--------------------------------------------------------------------------
def draw_enemy_graphic(enemy, x, y, opacity = 255)
  bitmap = RPG::Cache.battler(enemy.battler_name, enemy.battler_hue)
  cw = bitmap.width
  ch = bitmap.height
  src_rect = Rect.new(0, 0, cw, ch)
  x = x + (cw / 2 - x) if cw / 2 > x
  self.contents.blt(x - cw / 2, y - ch, bitmap, src_rect, opacity)
end
#--------------------------------------------------------------------------
def draw_enemy_exp(enemy, x, y)
  self.contents.font.color = system_color
  self.contents.draw_text(x, y, 120, 32, "EXP")
  self.contents.font.color = normal_color
  self.contents.draw_text(x + 120, y, 36, 32, enemy.exp.to_s, 2)
end
#--------------------------------------------------------------------------
def draw_enemy_gold(enemy, x, y)
  self.contents.font.color = system_color
  self.contents.draw_text(x, y, 120, 32, $data_system.words.gold)
  self.contents.font.color = normal_color
  self.contents.draw_text(x + 120, y, 36, 32, enemy.gold.to_s, 2)
end
end

class Game_Enemy_Book < Game_Enemy
#--------------------------------------------------------------------------
def initialize(enemy_id)
  super(2, 1)
  @enemy_id = enemy_id
  enemy = $data_enemies[@enemy_id]
  @battler_name = enemy.battler_name
  @battler_hue = enemy.battler_hue
  @hp = maxhp
  @sp = maxsp
end
end

class Data_MonsterBook
attr_reader :id_data
#--------------------------------------------------------------------------
def initialize
  @id_data = enemy_book_id_set
end
#--------------------------------------------------------------------------
def no_add_element
  no_add = 0
  for i in 1...$data_system.elements.size
    if $data_system.elements[i] =~ /図鑑登録無効/
      no_add = i
      break
    end
  end
  return no_add
end
#--------------------------------------------------------------------------
def enemy_book_id_set
  data = [0]
  no_add = no_add_element
  for i in 1...$data_enemies.size
    enemy = $data_enemies[i]
    next if enemy.name == ""
    if enemy.element_ranks[no_add] == 1
      next
    end
    data.push(enemy.id)
  end
  return data
end
end


class Window_MonsterBook < Window_Selectable
attr_reader   :data
#--------------------------------------------------------------------------
def initialize(index=0)
  super(0, 64, 640, 416)
  @column_max = 2
  @book_data = $game_temp.enemy_book_data
  @data = @book_data.id_data.dup
  @data.shift
  #@data.sort!
  @item_max = @data.size
  self.index = 0
  refresh if @item_max > 0
end
#--------------------------------------------------------------------------
def data_set
  data = $game_party.enemy_info.keys
  data.sort!
  newdata = []
  for i in data
    next if $game_party.enemy_info[i] == 0
    if book_id(i) != nil
      newdata.push(i)
    end
  end
  return newdata
end
#--------------------------------------------------------------------------
def show?(id)
  if $game_party.enemy_info[id] == 0 or $game_party.enemy_info[id] == nil
    return false
  else
    return true
  end
end
#--------------------------------------------------------------------------
def book_id(id)
  return @book_data.index(id)
end
#--------------------------------------------------------------------------
def item
  return @data[self.index]
end
#--------------------------------------------------------------------------
def refresh
  if self.contents != nil
    self.contents.dispose
    self.contents = nil
  end
  self.contents = Bitmap.new(width - 32, row_max * 32)
  if @item_max > 0
    for i in 0...@item_max
     draw_item(i)
    end
  end
end
#--------------------------------------------------------------------------
def draw_item(index)
  enemy = $data_enemies[@data[index]]
  return if enemy == nil
  x = 4 + index % 2 * (288 + 32)
  y = index / 2 * 32
  rect = Rect.new(x, y, self.width / @column_max - 32, 32)
  self.contents.fill_rect(rect, Color.new(0, 0, 0, 0))
  self.contents.font.color = normal_color
  draw_enemy_book_id(enemy, x, y)
  if show?(enemy.id)
    self.contents.draw_text(x + 28+16, y, 212, 32, enemy.name, 0)
  else
    self.contents.draw_text(x + 28+16, y, 212, 32, "－－－－－", 0)
    return
  end
  if analyze?(@data[index])
    self.contents.font.color = text_color(3)
    self.contents.draw_text(x + 256, y, 24, 32, "済", 2)
  end
end
#--------------------------------------------------------------------------
def analyze?(enemy_id)
  if $game_party.enemy_info[enemy_id] == 2
    return true
  else
    return false
  end
end
end


class Window_MonsterBook_Info < Window_Base
include Enemy_Book_Config
#--------------------------------------------------------------------------
def initialize
  super(0, 0+64, 640, 480-64)
  self.contents = Bitmap.new(width - 32, height - 32)
end
#--------------------------------------------------------------------------
def refresh(enemy_id)
  self.contents.clear
  self.contents.font.size = 22
  enemy = Game_Enemy_Book.new(enemy_id)
  draw_enemy_graphic(enemy, 96, 240+48+64, 200)
  draw_enemy_book_id(enemy, 4, 0)
  draw_enemy_name(enemy, 48, 0)
  draw_actor_hp(enemy, 288, 0)
  draw_actor_sp(enemy, 288+160, 0)
  draw_actor_parameter(enemy, 288    ,  32, 0)
  self.contents.font.color = system_color
  self.contents.draw_text(288+160, 32, 120, 32, EVA_NAME)
  self.contents.font.color = normal_color
  self.contents.draw_text(288+160 + 120, 32, 36, 32, enemy.eva.to_s, 2)
  draw_actor_parameter(enemy, 288    ,  64, 3)
  draw_actor_parameter(enemy, 288+160,  64, 4)
  draw_actor_parameter(enemy, 288    ,  96, 5)
  draw_actor_parameter(enemy, 288+160,  96, 6)
  draw_actor_parameter(enemy, 288    , 128, 1)
  draw_actor_parameter(enemy, 288+160, 128, 2)
  draw_enemy_exp(enemy, 288, 160)
  draw_enemy_gold(enemy, 288+160, 160)
  if analyze?(enemy.id) or !DROP_ITEM_NEED_ANALYZE
    self.contents.draw_text(288, 192, 96, 32, "Drop Item")
    draw_enemy_drop_item(enemy, 288+96+4, 192)
    self.contents.font.color = normal_color
    #draw_element_guard(enemy, 320-32, 160-16+96)
  end
end
#--------------------------------------------------------------------------
def analyze?(enemy_id)
  if $game_party.enemy_info[enemy_id] == 2
    return true
  else
    return false
  end
end
end


class Scene_MonsterBook
include Enemy_Book_Config
#--------------------------------------------------------------------------
def main
  $game_temp.enemy_book_data = Data_MonsterBook.new
  @title_window = Window_Base.new(0, 0, 640, 64)
  @title_window.contents = Bitmap.new(640 - 32, 64 - 32)
  @title_window.contents.draw_text(4, 0, 320, 32, "Pokedex", 0)
  if SHOW_COMPLETE_TYPE != 0
    case SHOW_COMPLETE_TYPE
    when 1
      e_now = $game_party.enemy_book_now
      e_max = $game_party.enemy_book_max
      text = e_now.to_s + "/" + e_max.to_s
    when 2
      comp = $game_party.enemy_book_complete_percentage
      text = comp.to_s + "%"
    when 3
      e_now = $game_party.enemy_book_now
      e_max = $game_party.enemy_book_max
      comp = $game_party.enemy_book_complete_percentage
      text = e_now.to_s + "/" + e_max.to_s + "　" + comp.to_s + "%"
    end
    if text != nil
      @title_window.contents.draw_text(320, 0, 288, 32,  text, 2)
    end
  end
  @main_window = Window_MonsterBook.new
  @main_window.active = true
  @info_window = Window_MonsterBook_Info.new
  @info_window.z = 110
  @info_window.visible = false
  @info_window.active = false
  @visible_index = 0
  Graphics.transition
  loop do
    Graphics.update
    Input.update
    update
    if $scene != self
      break
    end
  end
  Graphics.freeze
  @main_window.dispose
  @info_window.dispose
  @title_window.dispose
end
#--------------------------------------------------------------------------
def update
  @main_window.update
  @info_window.update
  if @info_window.active
    update_info
    return
  end
  if @main_window.active
    update_main
    return
  end
end
#--------------------------------------------------------------------------
def update_main
  if Input.trigger?(Input::B)
    $game_system.se_play($data_system.cancel_se)
    $scene = Scene_Menu.new
    return
  end
  if Input.trigger?(Input::C)
    if @main_window.item == nil or @main_window.show?(@main_window.item) == false
      $game_system.se_play($data_system.buzzer_se)
      return
    end
    $game_system.se_play($data_system.decision_se)
    @main_window.active = false
    @info_window.active = true
    @info_window.visible = true
    @visible_index = @main_window.index
    @info_window.refresh(@main_window.item)
    return
  end
end
#--------------------------------------------------------------------------
def update_info
  if Input.trigger?(Input::B)
    $game_system.se_play($data_system.cancel_se)
    @main_window.active = true
    @info_window.active = false
    @info_window.visible = false
    return
  end
  if Input.trigger?(Input::C)
    #$game_system.se_play($data_system.decision_se)
    return
  end
  if Input.trigger?(Input::L)
    $game_system.se_play($data_system.decision_se)
    loop_end = false
    while loop_end == false
      if @visible_index != 0
        @visible_index -= 1
      else
        @visible_index = @main_window.data.size - 1
      end
      loop_end = true if @main_window.show?(@main_window.data[@visible_index])
    end
    id = @main_window.data[@visible_index]
    @info_window.refresh(id)
    return
  end
  if Input.trigger?(Input::R)
    $game_system.se_play($data_system.decision_se)
    loop_end = false
    while loop_end == false
      if @visible_index != @main_window.data.size - 1
        @visible_index += 1
      else
        @visible_index = 0
      end
      loop_end = true if @main_window.show?(@main_window.data[@visible_index])
    end
    id = @main_window.data[@visible_index]
    @info_window.refresh(id)
    return
  end
end
end

$scene = Scene_Bag.new