Gambit Database Organizer

#==============================================================================
# GAMBIT DATABASE ORGANIZER
#------------------------------------------------------------------------------
# WRITTEN BY: Gambit
#------------------------------------------------------------------------------
# VERSION: 1.50
#------------------------------------------------------------------------------
# CHANGELOG:
#  v 1.50 - June 6, 2014 > Added support for variables
#                        > Added support for self switches
#  v 1.15 - June 5, 2014 > Significant performance improvements
#                        > Added support for switches
#  v 1.10 - June 4, 2014 > Added Database Organizer scene
#  v 1.00 - June 4, 2014 > Initial release
#------------------------------------------------------------------------------
# DESCRIPTION AND FEATURES:
#   This script allows a user to modify the order of objects in most databases
#   while preserving all game references to the original objects. In the project
#   editor, if you attempt to swap two Items by cutting and pasting, all
#   references to the items would be reversed. The references are tied to the ID
#   instead of the object itself. This script allows you to manipulate the
#   databases while preserving all references to the original objects.
#
#   A message will appear when the tasks you have specified are completed
#   successfully. CLOSE AND REOPEN THE PROJECT for the changes to finalize and
#   appear in the editor. If you save the project after running the script but
#   before closing and reopening it, the Organizer tasks will be REVERTED.
#
#   The script will print out a note to the console as each task is completed.
#   If you encounter an error and would like to revert all the tasks that were
#   performed prior to the error, just save your project. Again, saving the
#   project after running the script will revert the changes. To finalize the
#   changes, you must close the project after running the script then reopen it.
#
#  Features:
#   - Swap, move, insert, and delete database objects without ruining all of the
#     references in your game
#   - Update and redirect object references
#   - User-friendly Database Organizer scene to facilitate organization
#   - Optional task queue is available which will automatically perform the
#     specified tasks in the order they are provided
#   - Most objects are supported:
#     - Actors
#     - Animations
#     - Armors
#     - Classes
#     - Common Events
#     - Enemies
#     - Items
#     - Self Switches
#     - Skills
#     - States
#     - Switches
#     - Tilesets
#     - Troops
#     - Variables
#     - Weapons
#------------------------------------------------------------------------------
# REQUIRES:
# - None
#------------------------------------------------------------------------------
# INSTRUCTIONS AND SETUP:
#  Place this script below Materials and above Main Process.
#
#  Setup for this script is below. Please read explanations in comments.
#------------------------------------------------------------------------------
# Terms of Use:
# - Credit if used
# - Free for use in non-commercial projects
# - Please do not repost elsewhere, convert, or translate this script without
#   permission.
# - If seeking to use in commercial projects (projects that are generating money
#   in any way, including advertisements), please contact me via PM at:
#   http://www.rpgmakervxace.net/user/14194-gambit/
# - When using third-party scripts, the terms and conditions of those scripts
#   also apply. Please be aware of them prior to using.
# - Not for use in any project involving any form of nudity, commercial or not
#==============================================================================

module Gambit
  module DatabaseOrganizer

    # Determines whether Database Organizer will run when your game starts.
    Enabled = true

    # Determines whether to use the Database Organizer scene.
    # If set to true, you do not need to set up Tasks below.
    UseGUI = true

    # Only needed if UseGUI is set to false.
    # This allows you to queue tasks if you prefer creating them manually and
    # bypassing the Database Organizer scene.
    #       -------------------------------------------------------------
    # Tasks that you want to perform. The tasks are performed in the order
    # listed, one after the other. So feel free to chain tasks by using the IDs
    # that would result from the previous tasks.
    #       -------------------------------------------------------------
    # Each entry should have this format:
    # [task type, object type, old ID, new ID(, map ID)],
    #       -------------------------------------------------------------
    # task type =
    #   :swap   = swaps old ID object with new ID object and updates the
    #             references to both.
    #   :move   = moves old ID object to new ID, overwriting object that was
    #             previously at new ID. References to old ID will be changed to
    #             new ID so references to both the old and new IDs will point at
    #             new ID. The old ID will be a blank object.
    #   :insert = inserts old ID object at new ID. If old ID is less than new
    #             ID, all objects in between are shifted up one. If old ID is
    #             greater than new ID, all objects in between are shifted down
    #             one. All references are updated accordingly.
    #   :delete = deletes old ID object and shifts the IDs of all the following
    #             objects up one. All references are updated accordingly.
    #             References to the old ID will be redirected to the last ID.
    #             The last ID will be a blank object. A new ID is not needed.
    #   :update = updates and redirects old ID references to new ID.
    #
    # object type = :actor, :animation, :armor, :class, :common_event, :enemy,
    #               :item, :self_switch, :skill, :state, :switch, :tileset,
    #               :troop, :variable, :weapon
    # old ID      = original ID
    # new ID      = target ID (not needed for :delete task type)
    #       -------------------------------------------------------------
    # For Self Switches only:
    # map ID      = map ID
    #
    # Only the :swap and :update task types can be used.
    # Use strings for the IDs ('A', 'B', 'C', 'D').
    #       -------------------------------------------------------------
    Tasks = [
      [:swap,   :actor,   5,  6],
      [:move,   :class,  10,  4],
      [:insert, :weapon, 23, 34],
      [:delete, :skill,   7    ],
      [:update, :armor,  10, 12],
    ]

  end
end

###############################################################################
###############################################################################
###############################################################################
###############################################################################
### END OF SETTING UP ###### ONLY EDIT BELOW IF YOU KNOW WHAT YOU ARE DOING ###
###############################################################################
###############################################################################
###############################################################################
###############################################################################


($imported ||={})["GambitDatabaseOrganizer"] = true

#==============================================================================
# ** DataManager
#------------------------------------------------------------------------------
#  This module manages the database and game objects. Almost all of the
# global variables used by the game are initialized by this module.
#==============================================================================

module DataManager
  class <<self
    alias gam_dborganizer_load_normal_database load_normal_database
  end
  #--------------------------------------------------------------------------
  # * Load Normal Database
  #--------------------------------------------------------------------------
  def self.load_normal_database
    gam_dborganizer_load_normal_database
    if Gambit::DatabaseOrganizer::Enabled && !Gambit::DatabaseOrganizer::UseGUI
      Gambit::DatabaseOrganizer::Tasks.each_with_index do |task, index|
        organize_database(task, index)
      end
      database_organizer_done
    end
  end
  #--------------------------------------------------------------------------
  # * Perform Database Organizer Tasks
  #--------------------------------------------------------------------------
  def self.organize_database(task, index = nil)
    task_type, type, old_id, new_id, map_id = task
    case task_type
    when :swap
      separator = '↔'
      database_swap(*task.drop(1))
      update_references(*task)
    when :move
      separator = '→'
      database_move(*task.drop(1))
      update_references(*task)
    when :insert
      separator = '↓'
      database_insert(*task.drop(1))
      update_references(*task)
    when :delete
      new_id = determine_type(type)[0].drop(1).size
      task.size == 3 ? task << new_id : task[-1] = new_id
      database_delete(type, old_id)
      update_references(*task)
    when :update
      separator = '↑'
      update_references(*task)
    else
      error = true
      puts "XTask #{index + 1}: Skipped - #{task_type}: invalid task type"
    end unless type == :self_switch
    if type == :self_switch
      case task_type
      when :swap
        separator = '↔'
        update_references(*task)
      when :update
        separator = '→'
        update_references(*task)
      else
        error = true
        puts "XTask #{index + 1}: Skipped - #{task_type}: invalid task type " +
          'for self switch object type'
      end
    else
      save_data(*determine_type(type, true)) unless error
    end
    if task_type == :delete
      puts "✓Task #{index + 1}: Completed - #{task_type}: #{type} #{old_id}"
    elsif !error
      puts "✓Task #{index + 1}: Completed - #{task_type}: #{type} #{old_id} " +
        "#{separator} #{new_id}"
    end
  end
  #--------------------------------------------------------------------------
  # * Present Database Organizer Completion Message
  #--------------------------------------------------------------------------
  def self.database_organizer_done
    message = "Database organization has been performed successfully! Close and
               reopen your project for the changes to show in the database. You
               can now disable the Gambit Database Organizer script or change
               the tasks to prevent them from being repeated."
    title   = "Gambit Database Organizer: Successful"
    message.gsub!(/\s+/," ").gsub!(/! C/,"!\n\nC").gsub!(/. Y/,".\n\nY")
    win32 = Win32API.new("user32", "MessageBox", ['i', 'p', 'p', 'i'], 'i')
    win32.call(0, message, title, 64)
    exit
  end
  #--------------------------------------------------------------------------
  # * Delete Database Object
  #--------------------------------------------------------------------------
  def self.database_delete(type, old_id)
    array = determine_type(type)[0]
    array.delete_at(old_id)
    array << array[-1].class.new
    return if type == :switch || type == :variable
    array[old_id..array.size - 1].each_with_index do |object, index|
      object.id = index + old_id
    end
  end
  #--------------------------------------------------------------------------
  # * Insert Database Object
  #--------------------------------------------------------------------------
  def self.database_insert(type, old_id, new_id)
    array = determine_type(type)[0]
    array.insert(new_id, array.delete_at(old_id))
    return if type == :switch || type == :variable
    array[[old_id, new_id].min..[old_id, new_id].max].each_with_index do
      |object, index|
      object.id = index + [old_id, new_id].min
    end
  end
  #--------------------------------------------------------------------------
  # * Move Database Object
  #--------------------------------------------------------------------------
  def self.database_move(type, old_id, new_id)
    return if old_id == new_id
    array = determine_type(type)[0]
    array[new_id] = array[old_id]
    array[new_id].id = new_id unless type == :switch || type == :variable
    array[old_id] = array[old_id].class.new unless type == :self_switch
    return if type == :switch || type == :variable
    array[old_id].id = old_id
  end
  #--------------------------------------------------------------------------
  # * Swap Database Objects
  #--------------------------------------------------------------------------
  def self.database_swap(type, old_id, new_id)
    array = determine_type(type)[0]
    array.swap!(old_id, new_id)
    return if type == :switch || type == :variable
    array[old_id].id = old_id
    array[new_id].id = new_id
  end
  #--------------------------------------------------------------------------
  # * Get Data and File Name of Type
  #--------------------------------------------------------------------------
  def self.determine_type(type, save = false)
    case type
    when :actor
      array = $data_actors
      file = "Data/Actors.rvdata2"
    when :animation
      array = $data_animations
      file = "Data/Animations.rvdata2"
    when :armor
      array = $data_armors
      file = "Data/Armors.rvdata2"
    when :class
      array = $data_classes
      file = "Data/Classes.rvdata2"
    when :common_event
      array = $data_common_events
      file = "Data/CommonEvents.rvdata2"
    when :enemy
      array = $data_enemies
      file = "Data/Enemies.rvdata2"
    when :item
      array = $data_items
      file = "Data/Items.rvdata2"
    when :self_switch
      array = [*'A'..'D']
      file = false
    when :skill
      array = $data_skills
      file = "Data/Skills.rvdata2"
    when :state
      array = $data_states
      file = "Data/States.rvdata2"
    when :switch
      array = save ? $data_system : $data_system.switches
      file = "Data/System.rvdata2"
    when :tileset
      array = $data_tilesets
      file = "Data/Tilesets.rvdata2"
    when :troop
      array = $data_troops
      file = "Data/Troops.rvdata2"
    when :variable
      array = save ? $data_system : $data_system.variables
      file = "Data/System.rvdata2"
    when :weapon
      array = $data_weapons
      file = "Data/Weapons.rvdata2"
    end
    [array, file]
  end
  #--------------------------------------------------------------------------
  # * Update References to Object IDs and Save Data
  #--------------------------------------------------------------------------
  def self.update_references(*args)
    type = args[1]
    #------------------------------------------------------------------------
    # * Modify Map References to Self Switches
    #------------------------------------------------------------------------
    if type == :self_switch
      file = sprintf("Data/Map%03d.rvdata2", args[-1])
      map = load_data(file)
      map.events.values.each do |event|
        event.pages.each do |page|
          page.condition.self_switch_ch.dborg!(*args)
          change_event_references(*args, page)
        end
      end
      save_data(map, file)
      return
    end
    #------------------------------------------------------------------------
    # * Modify Common Event References to IDs
    #------------------------------------------------------------------------
    $data_common_events.drop(1).each do |page|
      page.switch_id = page.switch_id.dborg(*args) if type == :switch
      change_event_references(*args, page)
    end
    save_data($data_common_events, "Data/CommonEvents.rvdata2")
    #------------------------------------------------------------------------
    # * Modify Map References to IDs
    #------------------------------------------------------------------------
    $data_mapinfos.keys.each do |map_id|
      file = sprintf("Data/Map%03d.rvdata2", map_id)
      map = load_data(file)
      map.tileset_id = map.tileset_id.dborg(*args) if type == :tileset
      map.encounter_list.each do |encounter|
        encounter.troop_id = encounter.troop_id.dborg(*args)
      end if type == :troop
      map.events.values.each do |event|
        event.pages.each do |page|
          case type
          when :actor
            page.condition.actor_id = page.condition.actor_id.dborg(*args)
          when :item
            page.condition.item_id = page.condition.item_id.dborg(*args)
          when :switch
            page.condition.switch1_id = page.condition.switch1_id.dborg(*args)
            page.condition.switch2_id = page.condition.switch2_id.dborg(*args)
            page.move_route.list.each do |move_command|
              next unless move_command.code == 27 || move_command.code == 28
              move_command.parameters[0] =
                move_command.parameters[0].dborg(*args)
            end
          when :variable
            page.condition.variable_id = page.condition.variable_id.dborg(*args)
          end
          change_event_references(*args, page)
        end
      end
      save_data(map, file)
    end
    #------------------------------------------------------------------------
    # * Modify Troop References to IDs
    #------------------------------------------------------------------------
    $data_troops.drop(1).each do |troop|
      troop.members.each do |member|
        member.enemy_id = member.enemy_id.dborg(*args)
      end if type == :enemy
      troop.pages.each do |page|
        page.condition.actor_id = page.condition.actor_id.dborg(*args) if
          type == :actor
        page.condition.switch_id = page.condition.switch_id.dborg(*args) if
          type == :switch
        change_event_references(*args, page)
      end
    end
    save_data($data_troops, "Data/Troops.rvdata2")
    #------------------------------------------------------------------------
    # * Modify System References to Actor IDs
    #------------------------------------------------------------------------
    if type == :actor
      $data_system.party_members.map! {|id| id.dborg(*args) }
      $data_system.test_battlers.each do |battler|
        battler.actor_id = battler.actor_id.dborg(*args)
      end
      save_data($data_system, "Data/System.rvdata2")
    end
    #------------------------------------------------------------------------
    # * Modify Item, Skill, and Weapon References to Animation IDs
    #------------------------------------------------------------------------
    if type == :animation
      ($data_skills | $data_items | $data_weapons).compact.each do |object|
        object.animation_id = object.animation_id.dborg(*args)
      end
      save_data($data_skills,  "Data/Skills.rvdata2")
      save_data($data_items,   "Data/Items.rvdata2")
      save_data($data_weapons, "Data/Weapons.rvdata2")
    end
    #------------------------------------------------------------------------
    # * Modify Actor References to Class IDs
    #------------------------------------------------------------------------
    if type == :class
      $data_actors.drop(1).each do |actor|
        actor.class_id = actor.class_id.dborg(*args)
      end
      save_data($data_actors, "Data/Actors.rvdata2")
    end
    #------------------------------------------------------------------------
    # * Modify Class References to Skill IDs
    #------------------------------------------------------------------------
    if type == :skill
      $data_classes.drop(1).each do |class_object|
        class_object.learnings.each do |learning|
          learning.skill_id = learning.skill_id.dborg(*args)
        end
      end
    end
    #------------------------------------------------------------------------
    # * Modify Skill and Item References to Variable IDs
    #------------------------------------------------------------------------
    if type == :variable
      ($data_skills | $data_items).compact.map {|obj| obj.damage.formula }.
        each do |formula|
        formula.gsub!(/v\[(\d+)\]/) { "v[#{$1.to_i.dborg(*args)}]" }
      end
      save_data($data_skills, "Data/Skills.rvdata2")
      save_data($data_items,  "Data/Items.rvdata2")
    end
    #------------------------------------------------------------------------
    # * Modify Enemy References to Armor, Item, and Weapon IDs
    #------------------------------------------------------------------------
    if [:armor, :item, :weapon].include?(type)
      $data_enemies.drop(1).each do |enemy|
        enemy.drop_items.each do |item|
          case type
          when :armor
            next unless item.kind == 3
            item.data_id = item.data_id.dborg(*args)
          when :item
            next unless item.kind == 1
            item.data_id = item.data_id.dborg(*args)
          when :weapon
            next unless item.kind == 2
            item.data_id = item.data_id.dborg(*args)
          end
        end
      end
      save_data($data_enemies, "Data/Enemies.rvdata2")
    end
    #------------------------------------------------------------------------
    # * Modify Actor and System References to Armor and Weapon IDs
    #------------------------------------------------------------------------
    if type == :armor || type == :weapon
      $data_actors.drop(1).each do |actor|
        case type
        when :armor
          [*2..4].each do |index|
            actor.equips[index] = actor.equips[index].dborg(*args)
          end
          actor.equips[1] = actor.equips[1].dborg(*args) if (actor.features |
            $data_classes[actor.class_id].features).none? {|feature|
            feature.code == 55 }
        when :weapon
          actor.equips[0] = actor.equips[0].dborg(*args)
          actor.equips[1] = actor.equips[1].dborg(*args) if (actor.features |
            $data_classes[actor.class_id].features).any? {|feature|
            feature.code == 55 }
        end
      end
      save_data($data_actors, "Data/Actors.rvdata2")
      $data_system.test_battlers.each do |battler|
        case type
        when :armor
          [*2..4].each do |index|
            battler.equips[index] = battler.equips[index].dborg(*args)
          end
          battler.equips[1] = battler.equips[1].dborg(*args) if
            ($data_actors[battler.actor_id].features |
            $data_classes[$data_actors[battler.actor_id].class_id].features).
            none? {|feature| feature.code == 55 }
        when :weapon
          battler.equips[0] = battler.equips[0].dborg(*args)
          battler.equips[1] = battler.equips[1].dborg(*args) if
            ($data_actors[battler.actor_id].features |
            $data_classes[$data_actors[battler.actor_id].class_id].features).
            any? {|feature| feature.code == 55 }
        end
      end
      save_data($data_system, "Data/System.rvdata2")
    end
    #------------------------------------------------------------------------
    # * Modify Effect References to Common Event, Skill, and State IDs
    #------------------------------------------------------------------------
    if [:common_event, :skill, :state].include?(type)
      ($data_skills | $data_items).compact.map {|obj| obj.effects }.flatten.
        each do |effect|
        case type
        when :common_event
          next unless effect.code == 44
          effect.data_id = effect.data_id.dborg(*args)
        when :skill
          next unless effect.code == 43
          effect.data_id = effect.data_id.dborg(*args)
        when :state
          next unless effect.code == 21 || effect.code == 22
          effect.data_id = effect.data_id.dborg(*args)
        end
      end
      save_data($data_skills, "Data/Skills.rvdata2")
      save_data($data_items,  "Data/Items.rvdata2")
    end
    #------------------------------------------------------------------------
    # * Modify Feature References to Skill and State IDs
    #------------------------------------------------------------------------
    if type == :skill || type == :state
      ($data_actors | $data_classes | $data_weapons | $data_armors |
        $data_enemies | $data_states).compact.map {|obj| obj.features }.flatten.
        each do |feature|
        case type
        when :skill
          next unless feature.code == 43 || feature.code == 44
          feature.data_id = feature.data_id.dborg(*args)
        when :state
          next unless [13, 14, 32].include?(feature.code)
          feature.data_id = feature.data_id.dborg(*args)
        end
      end
      save_data($data_actors,  "Data/Actors.rvdata2")
      save_data($data_classes, "Data/Classes.rvdata2")
      save_data($data_weapons, "Data/Weapons.rvdata2")
      save_data($data_armors,  "Data/Armors.rvdata2")
      save_data($data_enemies, "Data/Enemies.rvdata2")
      save_data($data_states,  "Data/States.rvdata2")
    end
    #------------------------------------------------------------------------
    # * Modify Enemy References to Skill, State, and Switch IDs
    #------------------------------------------------------------------------
    if [:skill, :state, :switch].include?(type)
      $data_enemies.drop(1).each do |enemy|
        enemy.actions.each do |action|
          case type
          when :skill
            action.skill_id = action.skill_id.dborg(*args)
          when :state
            next unless action.condition_type == 4
            action.condition_param1 = action.condition_param1.dborg(*args)
          when :switch
            next unless action.condition_type == 6
            action.condition_param1 = action.condition_param1.dborg(*args)
          end
        end
      end
      save_data($data_enemies, "Data/Enemies.rvdata2")
    end
  end
  #--------------------------------------------------------------------------
  # * Determine Type to Modify in Event Commands
  #--------------------------------------------------------------------------
  def self.change_event_references(*args)
    case args[1]
    when :actor
      change_event_actors(*args)
    when :animation
      change_event_animations(*args)
    when :armor
      change_event_armors(*args)
    when :class
      change_event_classes(*args)
    when :common_event
      change_event_common_events(*args)
    when :enemy
      change_event_enemies(*args)
    when :item
      change_event_items(*args)
    when :self_switch
      change_event_self_switches(*args)
    when :skill
      change_event_skills(*args)
    when :switch
      change_event_switches(*args)
    when :state
      change_event_states(*args)
    when :tileset
      change_event_tilesets(*args)
    when :troop
      change_event_troops(*args)
    when :variable
      change_event_variables(*args)
    when :weapon
      change_event_weapons(*args)
    end
  end
  #--------------------------------------------------------------------------
  # * Modify Actor IDs in Event Commands
  #--------------------------------------------------------------------------
  def self.change_event_actors(*args)
    page = args.pop
    page.list.each do |command|
      case command.code
      when 111
        next unless command.parameters[0] == 4
        command.parameters[1] = command.parameters[1].dborg(*args)
      when 122
        next unless command.parameters[3..4] == [3, 3]
        command.parameters[5] = command.parameters[5].dborg(*args)
      when 129, 303, 319..322, 324
        command.parameters[0] = command.parameters[0].dborg(*args)
      when 311..318
        next unless command.parameters[0] == 0
        command.parameters[1] = command.parameters[1].dborg(*args)
      when 339
        next unless command.parameters[0] == 1
        command.parameters[1] = command.parameters[1].dborg(*args)
      when 401, 405
        command.parameters[0].gsub!(/\\(N)\[(\d+)\]/i) {
          "\\#{$1}[#{$2.to_i.dborg(*args)}]" }
      end
    end
  end
  #--------------------------------------------------------------------------
  # * Modify Animation IDs in Event Commands
  #--------------------------------------------------------------------------
  def self.change_event_animations(*args)
    page = args.pop
    page.list.each do |command|
      next unless command.code == 212 || command.code == 337
      command.parameters[1] = command.parameters[1].dborg(*args)
    end
  end
  #--------------------------------------------------------------------------
  # * Modify Armor IDs in Event Commands
  #--------------------------------------------------------------------------
  def self.change_event_armors(*args)
    page = args.pop
    page.list.each do |command|
      case command.code
      when 111
        next unless command.parameters.values_at(*[0, 2]) == [4, 5] ||
          command.parameters[0] == 10
        if command.parameters[0] == 10
          command.parameters[1] = command.parameters[1].dborg(*args)
        else
          command.parameters[3] = command.parameters[3].dborg(*args)
        end
      when 122
        next unless command.parameters[3..4] == [3, 2]
        command.parameters[5] = command.parameters[5].dborg(*args)
      when 128
        command.parameters[0] = command.parameters[0].dborg(*args)
      when 302, 605
        next unless command.parameters[0] == 2
        command.parameters[1] = command.parameters[1].dborg(*args)
      when 319
        next unless command.parameters[1] > 0
        command.parameters[2] = command.parameters[2].dborg(*args)
      end
    end
  end
  #--------------------------------------------------------------------------
  # * Modify Class IDs in Event Commands
  #--------------------------------------------------------------------------
  def self.change_event_classes(*args)
    page = args.pop
    page.list.each do |command|
      case command.code
      when 111
        next unless command.parameters.values_at(*[0, 2]) == [4, 2]
        command.parameters[3] = command.parameters[3].dborg(*args)
      when 321
        command.parameters[1] = command.parameters[1].dborg(*args)
      end
    end
  end
  #--------------------------------------------------------------------------
  # * Modify Common Event IDs in Event Commands
  #--------------------------------------------------------------------------
  def self.change_event_common_events(*args)
    page = args.pop
    page.list.each do |command|
      next unless command.code == 117
      command.parameters[0] = command.parameters[0].dborg(*args)
    end
  end
  #--------------------------------------------------------------------------
  # * Modify Enemy IDs in Event Commands
  #--------------------------------------------------------------------------
  def self.change_event_enemies(*args)
    page = args.pop
    page.list.each do |command|
      next unless command.code == 336
      command.parameters[1] = command.parameters[1].dborg(*args)
    end
  end
  #--------------------------------------------------------------------------
  # * Modify Item IDs in Event Commands
  #--------------------------------------------------------------------------
  def self.change_event_items(*args)
    page = args.pop
    page.list.each do |command|
      case command.code
      when 111
        next unless command.parameters[0] == 8
        command.parameters[1] = command.parameters[1].dborg(*args)
      when 122
        next unless command.parameters[3..4] == [3, 0]
        command.parameters[5] = command.parameters[5].dborg(*args)
      when 126
        command.parameters[0] = command.parameters[0].dborg(*args)
      when 302, 605
        next unless command.parameters[0] == 0
        command.parameters[1] = command.parameters[1].dborg(*args)
      end
    end
  end
  #--------------------------------------------------------------------------
  # * Modify Self Switches in Event Commands
  #--------------------------------------------------------------------------
  def self.change_event_self_switches(*args)
    page = args.pop
    page.list.each do |command|
      case command.code
      when 111
        next unless command.parameters[0] == 2
        command.parameters[1].dborg!(*args)
      when 123
        command.parameters[0].dborg!(*args)
      end
    end
  end
  #--------------------------------------------------------------------------
  # * Modify Skill IDs in Event Commands
  #--------------------------------------------------------------------------
  def self.change_event_skills(*args)
    page = args.pop
    page.list.each do |command|
      case command.code
      when 111
        next unless command.parameters.values_at(*[0, 2]) == [4, 3]
        command.parameters[3] = command.parameters[3].dborg(*args)
      when 318
        command.parameters[3] = command.parameters[3].dborg(*args)
      when 339
        command.parameters[2] = command.parameters[2].dborg(*args)
      end
    end
  end
  #--------------------------------------------------------------------------
  # * Modify Switch IDs in Event Commands
  #--------------------------------------------------------------------------
  def self.change_event_switches(*args)
    page = args.pop
    page.list.each do |command|
      case command.code
      when 111
        next unless command.parameters[0] == 0
        command.parameters[1] = command.parameters[1].dborg(*args)
      when 121
        command.parameters[0] = command.parameters[0].dborg(*args)
        command.parameters[1] = command.parameters[1].dborg(*args)
      when 205
        command.parameters[1].list.each do |move_command|
          next unless move_command.code == 27 || move_command.code == 28
          move_command.parameters[0] = move_command.parameters[0].dborg(*args)
        end
      end
    end
  end
  #--------------------------------------------------------------------------
  # * Modify State IDs in Event Commands
  #--------------------------------------------------------------------------
  def self.change_event_states(*args)
    page = args.pop
    page.list.each do |command|
      case command.code
      when 111
        next unless command.parameters.values_at(*[0, 2]) == [4, 6] ||
          command.parameters.values_at(*[0, 2]) == [5, 1]
        command.parameters[3] = command.parameters[3].dborg(*args)
      when 313
        command.parameters[3] = command.parameters[3].dborg(*args)
      when 333
        command.parameters[2] = command.parameters[2].dborg(*args)
      end
    end
  end
  #--------------------------------------------------------------------------
  # * Modify Tileset IDs in Event Commands
  #--------------------------------------------------------------------------
  def self.change_event_tilesets(*args)
    page = args.pop
    page.list.each do |command|
      next unless command.code == 282
      command.parameters[0] = command.parameters[0].dborg(*args)
    end
  end
  #--------------------------------------------------------------------------
  # * Modify Troop IDs in Event Commands
  #--------------------------------------------------------------------------
  def self.change_event_troops(*args)
    page = args.pop
    page.list.each do |command|
      next unless command.code == 301 && command.parameters[0] == 0
      command.parameters[1] = command.parameters[1].dborg(*args)
    end
  end
  #--------------------------------------------------------------------------
  # * Modify Variable IDs in Event Commands
  #--------------------------------------------------------------------------
  def self.change_event_variables(*args)
    page = args.pop
    page.list.each do |command|
      case command.code
      when 103, 104
        command.parameters[0] = command.parameters[0].dborg(*args)
      when 111
        next unless command.parameters[0] == 1
        command.parameters[1] = command.parameters[1].dborg(*args)
        next unless command.parameters[2] == 1
        command.parameters[3] = command.parameters[3].dborg(*args)
      when 122
        command.parameters[0] = command.parameters[0].dborg(*args)
        command.parameters[1] = command.parameters[1].dborg(*args)
        next unless command.parameters[3] == 1
        command.parameters[4] = command.parameters[4].dborg(*args)
      when 125
        next unless command.parameters[1] == 1
        command.parameters[2] = command.parameters[2].dborg(*args)
      when 126..128, 331, 332
        next unless command.parameters[2] == 1
        command.parameters[3] = command.parameters[3].dborg(*args)
      when 201
        next unless command.parameters[0] == 1
        command.parameters[1] = command.parameters[1].dborg(*args)
        command.parameters[2] = command.parameters[2].dborg(*args)
        command.parameters[3] = command.parameters[3].dborg(*args)
      when 202
        next unless command.parameters[1] == 1
        command.parameters[2] = command.parameters[2].dborg(*args)
        command.parameters[3] = command.parameters[3].dborg(*args)
        command.parameters[4] = command.parameters[4].dborg(*args)
      when 203
        next unless command.parameters[1] == 1
        command.parameters[2] = command.parameters[2].dborg(*args)
        command.parameters[3] = command.parameters[3].dborg(*args)
      when 231, 232
        next unless command.parameters[3] == 1
        command.parameters[4] = command.parameters[4].dborg(*args)
        command.parameters[5] = command.parameters[5].dborg(*args)
      when 285
        command.parameters[0] = command.parameters[0].dborg(*args)
        next unless command.parameters[2] == 1
        command.parameters[3] = command.parameters[3].dborg(*args)
        command.parameters[4] = command.parameters[4].dborg(*args)
      when 301, 313, 314, 318
        next unless command.parameters[0] == 1
        command.parameters[1] = command.parameters[1].dborg(*args)
      when 311, 312, 315, 316
        command.parameters[1] = command.parameters[1].dborg(*args) if
          command.parameters[0] == 1
        command.parameters[4] = command.parameters[4].dborg(*args) if
          command.parameters[3] == 1
      when 317
        command.parameters[1] = command.parameters[1].dborg(*args) if
          command.parameters[0] == 1
        command.parameters[5] = command.parameters[5].dborg(*args) if
          command.parameters[4] == 1
      when 401, 405
        command.parameters[0].gsub!(/\\(V)\[(\d+)\]/i) {
          "\\#{$1}[#{$2.to_i.dborg(*args)}]" }
      end
    end
  end
  #--------------------------------------------------------------------------
  # * Modify Weapon IDs in Event Commands
  #--------------------------------------------------------------------------
  def self.change_event_weapons(*args)
    page = args.pop
    page.list.each do |command|
      case command.code
      when 111
        next unless command.parameters.values_at(*[0, 2]) == [4, 4] ||
          command.parameters[0] == 9
        if command.parameters[0] == 9
          command.parameters[1] = command.parameters[1].dborg(*args)
        else
          command.parameters[3] = command.parameters[3].dborg(*args)
        end
      when 122
        next unless command.parameters[3..4] == [3, 1]
        command.parameters[5] = command.parameters[5].dborg(*args)
      when 127
        command.parameters[0] = command.parameters[0].dborg(*args)
      when 302, 605
        next unless command.parameters[0] == 1
        command.parameters[1] = command.parameters[1].dborg(*args)
      when 319
        next unless command.parameters[1] == 0
        command.parameters[2] = command.parameters[2].dborg(*args)
      end
    end
  end
end

#==============================================================================
# ** SceneManager
#------------------------------------------------------------------------------
#  This module manages scene transitions. For example, it can handle
# hierarchical structures such as calling the item screen from the main menu
# or returning from the item screen to the main menu.
#==============================================================================

module SceneManager
  class <<self
    alias gam_dborganizer_first_scene_class first_scene_class
  end
  #--------------------------------------------------------------------------
  # * Get First Scene Class
  #--------------------------------------------------------------------------
  def self.first_scene_class
    Gambit::DatabaseOrganizer::Enabled && !$BTEST ? Scene_DatabaseOrganizer :
      gam_dborganizer_first_scene_class
  end
end

#==============================================================================
# ** Window_DatabaseControls
#------------------------------------------------------------------------------
#  This window shows the control explanations on the database organizer screen.
#==============================================================================

class Window_DatabaseControls < Window_Base
  #--------------------------------------------------------------------------
  # * Set Category Controls Text
  #--------------------------------------------------------------------------
  def set_category
    contents.clear
    change_color(system_color)
    draw_text(0, 0, contents_width, line_height, 'Select a database to')
    draw_text(0, line_height, contents_width, line_height,
      'organize.')
  end
  #--------------------------------------------------------------------------
  # * Set Database Controls Text
  #--------------------------------------------------------------------------
  def set_database(old_id)
    contents.clear
    cw = contents_width
    change_color(system_color)
    draw_text(0, line_height * 2, cw / 5 * 3, line_height, "Select #{old_id}:",
      2)
    draw_text(0, line_height * 3, cw / 5 * 3, line_height, "Delete #{old_id}:",
      2)
    draw_text(0, contents_height - line_height, cw / 2, line_height, 'Cancel:',
      2)
    change_color(normal_color)
    draw_text(cw / 5 * 3, line_height * 2, cw, line_height, ' Z / Enter')
    draw_text(cw / 5 * 3, line_height * 3, cw, line_height, ' D')
    draw_text(cw / 2, contents_height - line_height, cw / 2, line_height,
      ' X / Esc')
  end
  #--------------------------------------------------------------------------
  # * Set Pending Database Controls Text
  #--------------------------------------------------------------------------
  def set_pending(old_id, new_id)
    contents.clear
    cw = contents_width
    change_color(system_color)
    draw_text(0, line_height * 2, cw / 5 * 3, line_height,
      "Swap with #{new_id}:", 2)
    draw_text(0, line_height * 3, cw / 5 * 3, line_height,
      "Move to #{new_id}:", 2)
    draw_text(0, line_height * 4, cw / 5 * 3, line_height,
      "Insert at #{new_id}:", 2)
    draw_text(0, line_height * 5, cw / 5 * 3, line_height,
      "Update to #{new_id}:", 2)
    draw_text(0, contents_height - line_height, cw / 2, line_height, 'Cancel:',
      2)
    change_color(normal_color)
    draw_text(0, line_height * 0, cw, line_height, "Original ID: #{old_id}", 1)
    draw_text(cw / 5 * 3, line_height * 2, cw, line_height, ' Z / Enter')
    draw_text(cw / 5 * 3, line_height * 3, cw, line_height, ' S')
    draw_text(cw / 5 * 3, line_height * 4, cw, line_height, ' Shift')
    draw_text(cw / 5 * 3, line_height * 5, cw, line_height, ' A')
    draw_text(cw / 2, contents_height - line_height, cw / 2, line_height,
      ' X / Esc')
  end
  #--------------------------------------------------------------------------
  # * Set Map Database Controls Text
  #--------------------------------------------------------------------------
  def set_map
    contents.clear
    change_color(system_color)
    draw_text(0, 0, contents_width, line_height, 'Select a map to organize.')
  end
  #--------------------------------------------------------------------------
  # * Set Self Switch Database Controls Text
  #--------------------------------------------------------------------------
  def set_self_switch_database(map, old_id)
    contents.clear
    cw = contents_width
    change_color(system_color)
    draw_text(0, line_height * 2, cw / 5 * 3, line_height, "Select #{old_id}:",
      2)
    draw_text(0, contents_height - line_height, cw / 2, line_height, 'Cancel:',
      2)
    change_color(normal_color)
    draw_text(0, line_height * 0, cw, line_height, "Map: #{map}", 1)
    draw_text(cw / 5 * 3, line_height * 2, cw, line_height, ' Z / Enter')
    draw_text(cw / 2, contents_height - line_height, cw / 2, line_height,
      ' X / Esc')
  end
  #--------------------------------------------------------------------------
  # * Set Pending Self Switch Database Controls Text
  #--------------------------------------------------------------------------
  def set_pending_self_switch_database(map, old_id, new_id)
    contents.clear
    cw = contents_width
    change_color(system_color)
    draw_text(0, line_height * 3, cw / 5 * 3, line_height,
      "Swap with #{new_id}:", 2)
    draw_text(0, line_height * 4, cw / 5 * 3, line_height,
      "Update to #{new_id}:", 2)
    draw_text(0, contents_height - line_height, cw / 2, line_height, 'Cancel:',
      2)
    change_color(normal_color)
    draw_text(0, line_height * 0, cw, line_height, "Map: #{map}", 1)
    draw_text(0, line_height * 1, cw, line_height, "Original Switch: #{old_id}",
      1)
    draw_text(cw / 5 * 3, line_height * 3, cw, line_height, ' Z / Enter')
    draw_text(cw / 5 * 3, line_height * 4, cw, line_height, ' A')
    draw_text(cw / 2, contents_height - line_height, cw / 2, line_height,
      ' X / Esc')
  end
end

#==============================================================================
# ** Window_DatabaseList
#------------------------------------------------------------------------------
#  This window displays a list of database objects on the database organizer
# screen.
#==============================================================================

class Window_DatabaseList < Window_Selectable
  #--------------------------------------------------------------------------
  # * Public Instance Variables
  #--------------------------------------------------------------------------
  attr_reader   :pending_index            # Pending position
  attr_accessor :map                      # selected map id
  #--------------------------------------------------------------------------
  # * Object Initialization
  #--------------------------------------------------------------------------
  def initialize(x, y, width, height)
    super
    @category = :none
    @map = false
    @pending_index = -1
  end
  #--------------------------------------------------------------------------
  # * Set Category
  #--------------------------------------------------------------------------
  def category=(category)
    return if @category == category
    @category = category
    refresh unless @category == :none
    self.oy = 0
  end
  #--------------------------------------------------------------------------
  # * Set Controls Window
  #--------------------------------------------------------------------------
  def controls_window=(controls_window)
    @controls_window = controls_window
    call_update_help
  end
  #--------------------------------------------------------------------------
  # * Set Pending Position
  #--------------------------------------------------------------------------
  def pending_index=(index)
    last_pending_index = @pending_index
    @pending_index = index
    redraw_item(@pending_index)
    redraw_item(last_pending_index)
  end
  #--------------------------------------------------------------------------
  # * Get Number of Items
  #--------------------------------------------------------------------------
  def item_max
    @data ? @data.size : 1
  end
  #--------------------------------------------------------------------------
  # * Get Item Height
  #--------------------------------------------------------------------------
  def item_height
    @category == :actor ? 34 : line_height
  end
  #--------------------------------------------------------------------------
  # * Get Item
  #--------------------------------------------------------------------------
  def item
    @data && index >= 0 ? @data[index] : nil
  end
  #--------------------------------------------------------------------------
  # * Create Item List
  #--------------------------------------------------------------------------
  def make_item_list
    if @category == :self_switch && @map
      @data = DataManager::determine_type(@category)[0]
    elsif @category == :self_switch
      @data = $data_mapinfos.map do |map_id, info|
        map = RPG::BaseItem.new
        map.id = map_id
        map.name = info.name
        map
      end
    else
      @data = DataManager::determine_type(@category)[0].drop(1)
    end
  end
  #--------------------------------------------------------------------------
  # * Draw Item
  #--------------------------------------------------------------------------
  def draw_item(index)
    item = @data[index]
    if item
      rect = item_rect(index)
      rect.x += 2
      rect.width -= 4
      draw_item_background(index)
      draw_item_id(rect, item, index)
      draw_item_name(item, rect.x + 38, rect.y, rect.height)
    end
  end
  #--------------------------------------------------------------------------
  # * Draw Background for Item
  #--------------------------------------------------------------------------
  def draw_item_background(index)
    if index == @pending_index
      contents.fill_rect(item_rect(index), pending_color)
    end
  end
  #--------------------------------------------------------------------------
  # * Draw ID of Item
  #--------------------------------------------------------------------------
  def draw_item_id(rect, item, index)
    return if @map
    if @category == :switch || @category == :variable
      draw_text(rect, sprintf("%03d:", index + 1))
    else
      draw_text(rect, sprintf("%03d:", item.id))
    end
  end
  #--------------------------------------------------------------------------
  # * Draw Item Name
  #--------------------------------------------------------------------------
  def draw_item_name(item, x, y, height)
    return unless item
    case @category
    when :actor
      draw_actor_graphic(item, x + 12, y + 33)
      offset = 26
    when :skill, :item, :weapon, :armor, :state
      draw_icon(item.icon_index, x, y)
      offset = 24
    else
      offset = 0
    end
    width = contents_width - x - offset
    if @category == :switch || @category == :variable || @map
      draw_text(x + offset, y, width, height, item)
    else
      draw_text(x + offset, y, width, height, item.name)
    end
  end
  #--------------------------------------------------------------------------
  # * Update Help Text
  #--------------------------------------------------------------------------
  def update_help
    @help_window.set_item(item) if item.respond_to?(:description)
    if @map && @pending_index >= 0
      @controls_window.set_pending_self_switch_database(@map.name,
        @data[@pending_index], item)
    elsif @pending_index >= 0
      @controls_window.set_pending(@pending_index + 1, index + 1)
    elsif @category == :self_switch && !map
      @controls_window.set_map
    elsif @map
      @controls_window.set_self_switch_database(@map.name, item)
    else
      @controls_window.set_database(index + 1)
    end
  end
  #--------------------------------------------------------------------------
  # * Redraw Item
  #--------------------------------------------------------------------------
  def redraw_item(index)
    @data[index] = DataManager::determine_type(@category)[0].drop(1)[index] if
      @category != :self_switch
    super
  end
  #--------------------------------------------------------------------------
  # * Redraw Range of Items
  #--------------------------------------------------------------------------
  def refresh_range(first, last)
    for number in [*[first, last].min..[first, last].max]
      redraw_item(number)
    end
  end
  #--------------------------------------------------------------------------
  # * Refresh
  #--------------------------------------------------------------------------
  def refresh
    make_item_list
    create_contents
    draw_all_items
  end
  #--------------------------------------------------------------------------
  # * Handling Processing for OK and Cancel Etc.
  #--------------------------------------------------------------------------
  def process_handling
    super
    return unless open? && active
    return process_delete if Input.trigger?(:Z) && @category != :self_switch
    return unless @pending_index >= 0
    return process_move   if Input.trigger?(:Y) && @category != :self_switch
    return process_insert if Input.trigger?(:A) && @category != :self_switch
    return process_update if Input.trigger?(:X)
  end
  #--------------------------------------------------------------------------
  # * Processing When OK Button Is Pressed
  #--------------------------------------------------------------------------
  def process_ok(task_type = :ok)
    Sound.play_ok
    Input.update
    deactivate
    call_handler(task_type)
  end
  #--------------------------------------------------------------------------
  # * Processing When Move Button Is Pressed
  #--------------------------------------------------------------------------
  def process_move
    process_ok(:move)
  end
  #--------------------------------------------------------------------------
  # * Processing When Insert Button Is Pressed
  #--------------------------------------------------------------------------
  def process_insert
    process_ok(:insert)
  end
  #--------------------------------------------------------------------------
  # * Processing When Delete Button Is Pressed
  #--------------------------------------------------------------------------
  def process_delete
    @pending_index >= 0 ? process_cancel : process_ok(:delete)
  end
  #--------------------------------------------------------------------------
  # * Processing When Update Button Is Pressed
  #--------------------------------------------------------------------------
  def process_update
    process_ok(:update)
  end
end

#==============================================================================
# ** Window_DatabaseCategory
#------------------------------------------------------------------------------
#  This window is for selecting a category from a list of databases on the
# database organizer screen.
#==============================================================================

class Window_DatabaseCategory < Window_Command
  #--------------------------------------------------------------------------
  # * Public Instance Variables
  #--------------------------------------------------------------------------
  attr_reader   :database_window
  #--------------------------------------------------------------------------
  # * Object Initialization
  #--------------------------------------------------------------------------
  def initialize
    super(0, 0)
  end
  #--------------------------------------------------------------------------
  # * Get Window Width
  #--------------------------------------------------------------------------
  def window_width
    Graphics.width
  end
  #--------------------------------------------------------------------------
  # * Get Number of Lines to Show
  #--------------------------------------------------------------------------
  def visible_line_number
    3
  end
  #--------------------------------------------------------------------------
  # * Get Digit Count
  #--------------------------------------------------------------------------
  def col_max
    return 5
  end
  #--------------------------------------------------------------------------
  # * Get Spacing for Items Arranged Side by Side
  #--------------------------------------------------------------------------
  def spacing
    return 0
  end
  #--------------------------------------------------------------------------
  # * Get Rectangle for Drawing Items (for Text)
  #--------------------------------------------------------------------------
  def item_rect_for_text(index)
    item_rect(index)
  end
  #--------------------------------------------------------------------------
  # * Frame Update
  #--------------------------------------------------------------------------
  def update
    super
    @database_window.category = current_symbol if @database_window
  end
  #--------------------------------------------------------------------------
  # * Create Command List
  #--------------------------------------------------------------------------
  def make_command_list
    add_command('Actors',        :actor)
    add_command('Classes',       :class)
    add_command('Skills',        :skill)
    add_command('Items',         :item)
    add_command('Weapons',       :weapon)
    add_command('Armors',        :armor)
    add_command('Enemies',       :enemy)
    add_command('Troops',        :troop)
    add_command('States',        :state)
    add_command('Animations',    :animation)
    add_command('Tilesets',      :tileset)
    add_command('Common Events', :common_event)
    add_command('Switches',      :switch)
    add_command('Variables',     :variable)
    add_command('Self Switches', :self_switch)
  end
  #--------------------------------------------------------------------------
  # * Get Alignment
  #--------------------------------------------------------------------------
  def alignment
    return 1
  end
  #--------------------------------------------------------------------------
  # * Set Database Window
  #--------------------------------------------------------------------------
  def database_window=(database_window)
    @database_window = database_window
    update
  end
end

#==============================================================================
# ** Scene_DatabaseOrganizer
#------------------------------------------------------------------------------
#  This class performs the database organizer screen processing.
#==============================================================================

class Scene_DatabaseOrganizer < Scene_Base
  #--------------------------------------------------------------------------
  # * Start Processing
  #--------------------------------------------------------------------------
  def start
    Graphics.resize_screen(640, 480)
    super
    @task_count = 0
    create_help_window
    create_category_window
    create_database_window
    create_controls_window
  end
  #--------------------------------------------------------------------------
  # * Create Help Window
  #--------------------------------------------------------------------------
  def create_help_window
    @help_window = Window_Help.new
    @help_window.y = Graphics.height - @help_window.height
    @help_window.viewport = @viewport
  end
  #--------------------------------------------------------------------------
  # * Create Category Window
  #--------------------------------------------------------------------------
  def create_category_window
    @category_window = Window_DatabaseCategory.new
    @category_window.viewport = @viewport
    @category_window.help_window = @help_window
    @category_window.set_handler(:ok,     method(:on_category_ok))
    @category_window.set_handler(:cancel, method(:on_category_cancel))
  end
  #--------------------------------------------------------------------------
  # * Create Database Window
  #--------------------------------------------------------------------------
  def create_database_window
    wy = @category_window.height
    wh = Graphics.height - wy - @help_window.height
    @database_window = Window_DatabaseList.new(0, wy, Graphics.width / 2, wh)
    @database_window.viewport = @viewport
    @database_window.help_window = @help_window
    @database_window.set_handler(:ok,     method(:on_database_ok))
    @database_window.set_handler(:move,   method(:on_database_move))
    @database_window.set_handler(:insert, method(:on_database_insert))
    @database_window.set_handler(:delete, method(:on_database_delete))
    @database_window.set_handler(:update, method(:on_database_update))
    @database_window.set_handler(:cancel, method(:on_database_cancel))
    @category_window.database_window = @database_window
  end
  #--------------------------------------------------------------------------
  # * Create Controls Window
  #--------------------------------------------------------------------------
  def create_controls_window
    wx = @database_window.width
    wy = @category_window.height
    wh = @database_window.height
    @controls_window = Window_DatabaseControls.new(wx, wy, wx, wh)
    @controls_window.viewport = @viewport
    @controls_window.set_category
    @database_window.controls_window = @controls_window
  end
  #--------------------------------------------------------------------------
  # * Category [OK]
  #--------------------------------------------------------------------------
  def on_category_ok
    @database_window.activate
    @database_window.select(0)
  end
  #--------------------------------------------------------------------------
  # * Category [Cancel]
  #--------------------------------------------------------------------------
  def on_category_cancel
    DataManager::database_organizer_done
  end
  #--------------------------------------------------------------------------
  # * Database [OK]
  #--------------------------------------------------------------------------
  def on_database_ok(task_type = :swap)
    if @database_window.pending_index >= 0
      DataManager::organize_database(task(task_type), @task_count)
      @task_count += 1
      @database_window.refresh_range(@database_window.pending_index,
        @database_window.index) if task_type == :insert
      @database_window.pending_index = -1
      @database_window.redraw_item(@database_window.index) unless
        @category_window.current_symbol == :self_switch
    elsif task_type == :delete
      DataManager::organize_database(task(task_type), @task_count)
      @task_count += 1
      @database_window.refresh_range(@database_window.index,
        @database_window.item_max - 1)
    elsif @category_window.current_symbol == :self_switch &&
      !@database_window.map
      @database_window.map = @database_window.item
      @database_window.select(0)
      @database_window.refresh
    else
      @database_window.pending_index = @database_window.index
    end
    @database_window.activate
  end
  #--------------------------------------------------------------------------
  # * Database [Move]
  #--------------------------------------------------------------------------
  def on_database_move
    on_database_ok(:move)
  end
  #--------------------------------------------------------------------------
  # * Database [Insert]
  #--------------------------------------------------------------------------
  def on_database_insert
    on_database_ok(:insert)
  end
  #--------------------------------------------------------------------------
  # * Database [Delete]
  #--------------------------------------------------------------------------
  def on_database_delete
    on_database_ok(:delete)
  end
  #--------------------------------------------------------------------------
  # * Database [Update]
  #--------------------------------------------------------------------------
  def on_database_update
    on_database_ok(:update)
  end
  #--------------------------------------------------------------------------
  # * Database [Cancel]
  #--------------------------------------------------------------------------
  def on_database_cancel
    if @database_window.pending_index >= 0
      @database_window.pending_index = -1
      @database_window.activate
    elsif @database_window.map
      @database_window.select(@database_window.map.id - 1)
      @database_window.map = false
      @database_window.refresh
      @database_window.activate
    else
      @controls_window.set_category
      @database_window.unselect
      @category_window.activate
    end
  end
  #--------------------------------------------------------------------------
  # * Get Task Array
  #--------------------------------------------------------------------------
  def task(task_type)
    if task_type == :delete
      task = [task_type, @category_window.current_symbol,
        @database_window.index + 1]
    elsif @category_window.current_symbol == :self_switch
      array = DataManager::determine_type(:self_switch)[0]
      task = [task_type, @category_window.current_symbol,
        array[@database_window.pending_index], array[@database_window.index],
        @database_window.map.id]
    else
      task = [task_type, @category_window.current_symbol,
        @database_window.pending_index + 1, @database_window.index + 1]
    end
  end
end

class Array
  #--------------------------------------------------------------------------
  # * Swap Two Elements by Indices
  #--------------------------------------------------------------------------
  def swap!(a, b)
    self[a], self[b] = self[b], self[a]
    self
  end
end

class Integer
  #--------------------------------------------------------------------------
  # * Determine Database Organizer Reference ID
  #--------------------------------------------------------------------------
  def dborg(task_type, type, old_id, new_id)
    value = self
    case task_type
    when :swap
      if self == old_id
        value = new_id
      elsif self == new_id
        value = old_id
      end
    when :move, :update
      value = new_id if self == old_id
    when :insert
      unless self < [old_id, new_id].min || self > [old_id, new_id].max
        if self == old_id
          value = new_id
        elsif old_id < new_id
          value -= 1
        elsif old_id > new_id
          value += 1
        end
      end
    when :delete
      unless self < old_id
        if self == old_id
          value = new_id
        else
          value -= 1
        end
      end
    end
    value
  end
end

class String
  #--------------------------------------------------------------------------
  # * Determine Database Organizer Reference Self Switch
  #--------------------------------------------------------------------------
  def dborg!(task_type, type, old_id, new_id, map_id)
    value = self
    case task_type
    when :swap
      if self == old_id
        value = new_id
      elsif self == new_id
        value = old_id
      end
    when :update
      value = new_id if self == old_id
    end
    self.replace(value)
  end
end