Visible Debug 1.2

# Visible Debug v. 1.2
# VX version
# by mikb89

# Details:
#  Sometimes something goes wrong with events switches and variables. You don't
#   know what is happening, you just know they don't work.
#  With this script you can set in game a list of parameters to take under
#   control and they'll be shown and updated in real time.
#  This list includes:
#   - switches and variables, events' self switches;
#   - events, player, actors, battlers character's graphic;
#   - events and player Through state and position;
#   - tile id of current player position;
#   - items, weapons, armors possession number;
#   - battlers' hp, mp, rage (if you use YEM), atk, def, spi, agi, two states;
#   - actors' name & level (enemies don't have that);
#   - others useful datas you can check here in configurations and can add your
#     own.

# Configurations:
module VDEBUG
  # Here's a list of terms you can change as you want:
  HELP_TEXT = "Enter: add/remove; Pag: change list." # Help yourself!
  # These are what appears on F9 press:
    CALL_CLASSIC_DEBUG_TEXT = "Debug call"
    CALL_VDEBUG_SETTINGS_TEXT = "Visible Debug data"
  # These are lists names:
    SWITCH_LIST_TEXT = "Switches"
    VARIABLE_LIST_TEXT = "Variables"
    ITEM_LIST_TEXT = "Items"
    ACTOR_LIST_TEXT = "Actors"
    EVENT_LIST_TEXT = "Events"
    DATA_LIST_TEXT = "Infos"
    WEAPON_LIST_TEXT = "Weapons"
    ARMOR_LIST_TEXT = "Armors"
    ENEMY_LIST_TEXT = "Enemies"

  SHOW_EVENT_NAME = true # Show the event name. Set false for compatibility.
  MOVE_AROUND_KEY = Input::ALT
   # Pressing this key many times the debug sprite will move in the four angles
   #  of the screen and then hide.

  # The available data:
  def self.collect_mainlist
    poss = [] # You can change the order as you want, but can add nothing.
    poss << [-1, $data_system.switches.size-1]
    poss << [-2, $data_system.variables.size-1]
    poss << [-3, $data_items.size-1]
    poss << [-4, $data_actors.size-1]
    poss << [0, $game_player]
    poss << [-5, $game_map.events.size] # No need of -1 because it's a Hash. D:
    poss << [-6, self.useful_data.size-1]
    poss << [-7, $data_weapons.size-1]
    poss << [-8, $data_armors.size-1]
    poss << [-9, [$game_troop.members.size, 8].max]
    poss # Unless you know what you're doing, of course.
  end
  def self.useful_data
    da = [nil] # First value must be nil.
    da << [["Party:", $game_party.members.size], # Open an array, add the item.
           ["G:", $game_party.gold], # First value is a string shown...
           ["S:", $game_party.steps], # ...second value is the variable to show.
           ["T:", self.adjust_time(Graphics.frame_count)], # Remember the ,
           ["Sav:", $game_system.save_count]] # Close the data array.
           # Will show: "Party: 3 G: 333 S: 33 T: 3:33 Sav: 3" with something
           #  instead of 3.
    da << ["Timer:", self.adjust_time($game_system.timer)]
           # Even a single item can be added. And variable can also be a def.
    da << [["Map id:", $game_map.map_id],
           ["Size:", $game_map.width], ["x", $game_map.height]]
           # You can, as an exercise, add for example the map name. 

     # Add here your own! We want YOU for items adding.

    da # Here just returns the datas.
  end
  def self.adjust_time(value) # Example of a function. Returns formatted time.
    value /= Graphics.frame_rate # Graphics.frame_rate = 1 second.
    sec = value % 60 # Get the seconds.
    value -= sec # Subtract them.
    "#{value/60}:#{sprintf("%02d",sec)}" # Return min:sec formatted time string.
  end
end

#Codename: vdebug


($imported ||= {})[:mikb89_vdebug] = true

# License:
# - You can ask me to include support for other scripts as long as these scripts
#   use the $imported[script] = true;
# - You can modify and even repost my scripts, after having received a response
#   by me. For reposting it, anyway, you must have done heavy edit or porting,
#   you can't do a post with the script as is;
# - You can use my scripts for whatever you want, from free to open to
#   commercial games. I'd appreciate by the way if you let me know about what
#   you're doing;
# - You must credit me, if you use this script or part of it.

# * operations to let the Visible Debug configuration be available

class Scene_Map
#class Scene_Map#def call_debug() <- rewritten
  def call_debug
    Sound.play_decision
    $game_temp.next_scene = nil
    $scene = Scene_ChoiceDebug.new
  end
end

  # Yanfly liked to destroy the Scene_End, let's support him! 
if $imported["SystemGameOptions"]
# REQUIRE YEM - System Game Options
  class Scene_ChoiceDebug < Scene_Base # this is just a clone of the Scene_End
#class Scene_ChoiceDebug#def start()
    def start; super; create_menu_background; create_command_window; end
#class Scene_ChoiceDebug#def post_start()
    def post_start; super; open_command_window; end
#class Scene_ChoiceDebug#def pre_terminate()
    def pre_terminate; super; close_command_window; end
#class Scene_ChoiceDebug#def terminate()
    def terminate; super; @command_window.dispose; dispose_menu_background; end
#class Scene_ChoiceDebug#def update()
    def update
      super; update_menu_background; @command_window.update
      if Input.trigger?(Input::
        Sound.play_cancel; return_scene
      elsif Input.trigger?(Input::C); case @command_window.index
        when 0; command_to_title
        when 1; command_shutdown
        when 2; Sound.play_decision; return_scene
      end; end
    end
#class Scene_ChoiceDebug#def update_menu_background()
    def update_menu_background; super; @menuback_sprite.tone.set(0,0,0,128); end
#class Scene_ChoiceDebug#def open_command_window()
    def open_command_window
      @command_window.open; begin
        @command_window.update; Graphics.update
      end until @command_window.openness == 255
    end
#class Scene_ChoiceDebug#def close_command_window()
    def close_command_window
      @command_window.close; begin
        @command_window.update; Graphics.update
      end until @command_window.openness == 0
    end
  end
# END REQUIRE
else
  class Scene_ChoiceDebug < Scene_End; end
end

class Scene_ChoiceDebug
#class Scene_ChoiceDebug#def return_scene()
  def return_scene
    $scene = Scene_Map.new
  end
#class Scene_ChoiceDebug#def create_command_window()
  def create_command_window
    s1 = VDEBUG::CALL_CLASSIC_DEBUG_TEXT
    s2 = VDEBUG::CALL_VDEBUG_SETTINGS_TEXT
    s3 = Vocab::cancel
    @command_window = Window_Command.new(272, [s1, s2, s3])
    @command_window.x = (544 - @command_window.width) / 2
    @command_window.y = (416 - @command_window.height) / 2
    @command_window.openness = 0
  end
  # just using original Scene_End class names
#class Scene_ChoiceDebug#def command_to_title()
  def command_to_title
    Sound.play_decision
    $scene = Scene_Debug.new
    close_command_window
  end
#class Scene_ChoiceDebug#def command_shutdown()
  def command_shutdown
    Sound.play_decision
    $scene = Scene_VisibleDebug.new
    close_command_window
  end
end

# * operations to let the Visible Debug sprite work

#class Game_Event#def name()
(class Game_Event; def name; @event.name; end; end) if VDEBUG::SHOW_EVENT_NAME
 # why isn't the event name readable by default? WHY???

class Scene_End
  alias_method(:terminateSE_b4_vdebug, :terminate) unless method_defined?(:terminateSE_b4_vdebug)
#class Scene_End#def terminate() <- aliased
  def terminate
    terminateSE_b4_vdebug
    # dispose the sprite on Shutdown and To title commands
    $game_player.sdebug.dispose if !$scene || $scene.is_a?(Scene_Title)
  end
end

class Scene_Base
  alias_method(:updateSB_b4_vdebug, :update) unless method_defined?(:updateSB_b4_vdebug)
#class Scene_Base#def update() <- aliased
  def update
    updateSB_b4_vdebug
    # update the debug sprite just everywhere!
    $game_player.sdebug.update if $game_player
  end
  alias_method(:snapshot_for_background_b4_vdebug, :snapshot_for_background) unless method_defined?(:snapshot_for_background_b4_vdebug)
#class Scene_Base#def snapshot_for_background() <- aliased
  def snapshot_for_background
    # we don't want the debug sprite to be captured in the snapshot
    $game_player.sdebug.visible = false if $game_player
    snapshot_for_background_b4_vdebug
    $game_player.sdebug.visible = true if $game_player
  end
end
class Game_Player
  # rely sprite on $game_player due to its reperibility. No, I'm not kidding :E
#class Game_Player#def sdebug()
  def sdebug
    @sdebug ||= Sprite_Debug.new
  end
end

class Sprite_Debug < Sprite
  attr_reader :infos
#class Sprite_Debug#def initialize(i, pos, vp)
  def initialize(i = nil, pos = 0, vp = nil)
    if vp == nil; super(); else; super(vp); end # viewport?
    self.infos = (i.is_a?(Array) ? i : [i]) # must be an array
    self.z = 99999999 # a big value
    self.opacity = 222 # little transparency
    @last_values = []
    @pos = pos - 1; move_around # position set
  end
#class Sprite_Debug#def move_around()
  def move_around
    @pos += 1; @pos %= 5 # increase position, modulate value
    self.x = w*(@pos%2) # right/left
    self.y = Graphics.height/2*(@pos/2) # up/down/out
  end
#class Sprite_Debug#def w()
  def w # just to write a little less
    Graphics.width/2
  end
#class Sprite_Debug#def infos=(i)
  def infos=(i)
    @infos = i
    create_bitmap # once data change, we recreate the image
  end
#class Sprite_Debug#def marshal_dump()
  def marshal_dump
    [@infos, @pos, self.viewport] # values to save
  end
#class Sprite_Debug#def marshal_load(data)
  def marshal_load(data)
    initialize(data[0] || nil, data[1] || 0, data[2] || nil)
  end
#class Sprite_Debug#def create_bitmap()
  def create_bitmap
    self.bitmap.dispose if self.bitmap && !self.bitmap.disposed?
    h = @infos.size*24
    self.bitmap = Bitmap.new(w,[h,1].max) # h is 0, if there's no item
    for i in 0...@infos.size
      next if @infos[i] == nil || @infos[i].size < 2
      draw_row(i, true)
    end
  end
#class Sprite_Debug#def draw_row(i, new)
  def draw_row(i, new = false)
    self.bitmap.clear_rect(0,i*24,w,24) unless new # no need to clear if new
    im = get_item(@infos[i]) # get the bitmap then blt it. This way I can get
    return unless im         #  the same bitmap everywhere ^^
    draw_placement(0, i*24)
    self.bitmap.blt(0, i*24, im, im.rect)
    im.dispose
  end
#class Sprite_Debug#def draw_placement(x, y)
  def draw_placement(x, y)
    self.bitmap.fill_rect(x+4,y+6,w-8,24-8,Color.new(0,0,0,128)) # a bLackground
  end
#class Sprite_Debug#def collect(v)
  def collect(v) # gets the relevant value(s) for each item
    case v[0]
      when 0; collect_player
      when 1; $game_switches[v[1]]
      when 2; $game_variables[v[1]]
      when 3; $game_party.item_number($data_items[v[1]])
      when 4; collect_actor($game_actors[v[1]])
      when 5; collect_event($game_map.events[v[1]])
      when 6; collect_data(VDEBUG::useful_data[v[1]])
      when 7; $game_party.item_number($data_weapons[v[1]])
      when 8; $game_party.item_number($data_armors[v[1]])
      when 9; collect_enemy($game_troop.members[v[1]-1])
      else; nil
    end
  end
#class Sprite_Debug#def collect_player()
  def collect_player
    da = []
    da << $game_player.character_name
    da << $game_player.character_index
    da << $game_player.direction
    da << $game_player.x
    da << $game_player.y
    da << ($game_player.through || $game_player.debug_through?)
    for i in [0, 1, 2]
      da << $game_map.data[$game_player.x, $game_player.y, i]
    end
    da
  end
#class Sprite_Debug#def collect_actor(actor)
  def collect_actor(actor)
    da = []
    da << actor.character_name
    da << actor.character_index
    da << actor.name
    da << actor.level
    da << actor.hp
    da << actor.maxhp
    da << actor.mp
    da << actor.maxmp
    da << actor.states
    da << actor.atk
    da << actor.def
    da << actor.spi
    da << actor.agi
    da
  end
#class Sprite_Debug#def collect_event(event)
  def collect_event(event)
    da = []
    return da if event.nil?
    da << event.character_name
    da << event.character_index
    da << event.direction
    da << event.x
    da << event.y
    da << (event.through || event.debug_through?)
    for ss in ['A', 'B', 'C', 'D']
      da << $game_self_switches[[$game_map.map_id, event.id, ss]]
    end
    da
  end
#class Sprite_Debug#def collect_data(data)
  def collect_data(data)
    da = []
    return da if data.nil? || !data.is_a?(Array)
    data = [data] unless data[0].is_a?(Array)
    return da if data.size < 1
    for val in data
      da << val[1]
    end
    da
  end
#class Sprite_Debug#def collect_enemy(enemy)
  def collect_enemy(enemy)
    da = []
    return da if enemy.nil?
    da << enemy.battler_name
    da << enemy.battler_hue
    da << enemy.name
    da << enemy.hp
    da << enemy.maxhp
    da << enemy.mp
    da << enemy.maxmp
    da << enemy.states
    da << enemy.atk
    da << enemy.def
    da << enemy.spi
    da << enemy.agi
    da
  end
#class Sprite_Debug#def get_item(item, width, enabled)
  def get_item(item, width = w, enabled = true) # draw item in a returned bitmap
    bit = Bitmap.new(width,24)
    bit.font.color.alpha = blta = enabled ? 255 : 128
    case item[0]
    when -9; draw_container(VDEBUG::ENEMY_LIST_TEXT, item[1], bit)
    when -8; draw_container(VDEBUG::ARMOR_LIST_TEXT, item[1], bit)
    when -7; draw_container(VDEBUG::WEAPON_LIST_TEXT, item[1], bit)
    when -6; draw_container(VDEBUG::DATA_LIST_TEXT, item[1], bit)
    when -5; draw_container(VDEBUG::EVENT_LIST_TEXT, item[1], bit)
    when -4; draw_container(VDEBUG::ACTOR_LIST_TEXT, item[1], bit)
    when -3; draw_container(VDEBUG::ITEM_LIST_TEXT, item[1], bit)
    when -2; draw_container(VDEBUG::VARIABLE_LIST_TEXT, item[1], bit)
    when -1; draw_container(VDEBUG::SWITCH_LIST_TEXT, item[1], bit)
    when 0; draw_player(item[1], bit, blta)
    when 1; draw_switch(item[1], bit, blta)
    when 2; draw_variable(item[1], bit, blta)
    when 3; draw_item(item[1], bit, blta)
    when 4; draw_actor(item[1], bit, blta)
    when 5; draw_event(item[1], bit, blta)
    when 6; draw_data(item[1], bit, blta)
    when 7; draw_weapon(item[1], bit, blta)
    when 8; draw_armor(item[1], bit, blta)
    when 9; draw_enemy(item[1], bit, blta)
    else; bit.dispose; bit = nil
    end
    bit
  end
#class Sprite_Debug#def draw_container(txt, n, bitmap)
  def draw_container(txt, n, bitmap)
    bitmap.draw_text(12, 0, bitmap.width-32, 24, txt)
    bitmap.draw_text(0, 0, bitmap.width, 24, n > 0 ? "(#{n})" : "", 2)
  end
#class Sprite_Debug#def draw_player(item, bitmap, blta)
  def draw_player(item, bitmap, blta)
    if item != nil
      bitmap.blt(0, 0, get_character_icon(item, true), Rect.new(0,0,24,24), blta)
      bitmap.draw_text(24, 0, bitmap.width, 24, "(#{item.x};#{item.y})")
      tile = ""
      for i in [0, 1, 2]
        tile += $game_map.data[item.x, item.y, i].to_s + (i != 2 ? ", " : "")
      end
      bitmap.draw_text(0, 0, bitmap.width-3, 24, "Tile: #{tile}", 2)
      if (item.through || item.debug_through?)
        bitmap.font.size /= 2
        bitmap.font.shadow = false
        col = false
        for i in -1..2; for j in -1..1 # I could avoid all this, but...
          next if i == j && i == 0
          if i == 2
            next if j != 0
            col = true
            i = 0
          end
          bitmap.font.color = col ? Color.new(0,0,0) : Color.new(99,33,55)
          bitmap.draw_text(i, j+8, 23, 24, "T", 2)
          break if i == j && j == 0
        end; end
      end
    end
  end
#class Sprite_Debug#def draw_switch(n, bitmap, blta)
  def draw_switch(n, bitmap, blta)
    if n != nil
      name = $data_system.switches[n]
      bitmap.blt(0, 0, get_text_icon("S"), Rect.new(0,0,24,24), blta)
      bitmap.draw_text(24, 0, bitmap.width-32, 24, "[#{n}] #{name}:")
      bitmap.draw_text(0, 0, bitmap.width, 24, "[O#{$game_switches[n] ? "N" : "FF"}]", 2)
    end
  end
#class Sprite_Debug#def draw_variable(n, bitmap, blta)
  def draw_variable(n, bitmap, blta)
    if n != nil
      name = $data_system.variables[n]
      bitmap.blt(0, 0, get_text_icon("V"), Rect.new(0,0,24,24), blta)
      bitmap.draw_text(24, 0, bitmap.width-32, 24, "[#{n}] #{name}:")
      bitmap.draw_text(0, 0, bitmap.width-3, 24, $game_variables[n].to_s, 2)
    end
  end
#class Sprite_Debug#def draw_item(n, bitmap, blta)
  def draw_item(n, bitmap, blta)
    item = $data_items[n]
    if item != nil
      bitmap.blt(0, 0, get_icon(item.icon_index), Rect.new(0,0,24,24), blta)
      bitmap.draw_text(24, 0, bitmap.width, 24, item.name)
      bitmap.draw_text(0, 0, bitmap.width-3, 24, $game_party.item_number(item), 2)
    end
  end
#class Sprite_Debug#def draw_actor(n, bitmap, blta)
  def draw_actor(n, bitmap, blta)
    item = $game_actors[n]
    if item != nil
      iw = bitmap.width
      bitmap.draw_text(24, 0, bitmap.width, 24, item.name)
      wb = Window_Base.new(-(iw+32),-56,iw+32,56) # I get a Window_Base for its
      wb.draw_actor_name(item, 24, 0)             #  useful draw_this, draw_that
      gs = iw-w
      vals = [-8, -2]
      if $imported["CoreFixesUpgradesMelody"] || $imported["BattleEngineMelody"]
        # REQUIRE YEM Battle Engine Melody OR YEM Core Fixes and Upgrades
          if item.use_rage?
            vals[0] -= 4; vals[1] -= 4; vals << 0
            wb.draw_enemy_rage_gauge(item, 96, vals[2], 48+gs)
          end
        # END REQUIRE
      end
      wb.draw_actor_hp_gauge(item, 96, vals[0], 48+gs)
      wb.draw_actor_mp_gauge(item, 96, vals[1], 48+gs)
      wb.draw_actor_state(item, 154+gs, 0, 48)
      wb.contents.font.size /= 2
      wb.contents.font.shadow = false
      col = false
      for i in -1..2; for j in -1..1
        next if i == j && i == 0
        if i == 2
          next if j != 0
          col = true
          i = 0
        end
        wb.contents.font.color = col ? Color.new(0,0,0) : wb.system_color
        wb.contents.draw_text(i+6-1, j+8, 12, 24, Vocab::level_a)
        wb.contents.draw_text(i+iw-80+16, j-4, 22, 24, Vocab::atk[0...3])
        wb.contents.draw_text(i+iw-48+16, j-4, 22, 24, Vocab::def[0...3])
        wb.contents.draw_text(i+iw-80+16, j+6, 22, 24, Vocab::spi[0...3])
        wb.contents.draw_text(i+iw-48+16, j+6, 22, 24, Vocab::agi[0...3])
        wb.contents.font.color = col ? Color.new(0,0,0) : wb.normal_color
        wb.contents.draw_text(i, j+8, 23, 24, item.level, 2)
        wb.contents.draw_text(i+iw-80+26, j-4, 18, 24, item.atk, 2)
        wb.contents.draw_text(i+iw-48+26, j-4, 18, 24, item.def, 2)
        wb.contents.draw_text(i+iw-80+26, j+6, 18, 24, item.spi, 2)
        wb.contents.draw_text(i+iw-48+26, j+6, 18, 24, item.agi, 2)
        break if i == j && j == 0
      end;end
      bitmap.blt(0, 0, get_character_icon(item), Rect.new(0,0,24,24), blta)
      bitmap.blt(0, 0, wb.contents, wb.contents.rect, blta)
      wb.dispose
    end
  end
#class Sprite_Debug#def draw_event(n, bitmap, blta)
  def draw_event(n, bitmap, blta)
    item = $game_map.events[n]
    if item != nil
      bitmap.blt(0, 0, get_character_icon(item, true), Rect.new(0,0,24,24), blta)
      nm = VDEBUG::SHOW_EVENT_NAME ? item.name : ""
      bitmap.draw_text(24, 0, bitmap.width-3, 24, "[#{item.id}](#{item.x};#{item.y})#{nm}")
      loc = "ON:"
      for ss in ['A', 'B', 'C', 'D']
        loc += " " + ss + "," if $game_self_switches[[$game_map.map_id, item.id, ss]]
      end
      loc[-1] = "" if loc[-1].chr == ','
      bitmap.draw_text(0, 0, bitmap.width, 24, loc, 2)
      if (item.through || item.debug_through?)
        bitmap.font.size /= 2
        bitmap.font.shadow = false
        col = false
        for i in -1..2; for j in -1..1
          next if i == j && i == 0
          if i == 2
            next if j != 0
            col = true
            i = 0
          end
          bitmap.font.color = col ? Color.new(0,0,0) : Color.new(99,33,55)
          bitmap.draw_text(i, j+8, 23, 24, "T", 2) if (item.through || item.debug_through?)
          break if i == j && j == 0
        end; end
      end
    else
      bitmap.blt(0, 0, get_text_icon(n.to_s), Rect.new(0,0,24,24), blta)
      bitmap.draw_text(0, 0, bitmap.width, 24, "EV#{sprintf("%03d", n)}", 1)
    end
  end
#class Sprite_Debug#def draw_data(n, bitmap, blta)
  def draw_data(n, bitmap, blta)
    item = VDEBUG::useful_data[n]
    if item != nil && item.is_a?(Array)
      item = [item] unless item[0].is_a?(Array)
      return if item.size < 1
      str = ""
      for val in item
        str += val[0] + " #{val[1]} "
      end
      str[-1] = "" if str[-1].chr == " "
      bitmap.draw_text(0, 0, bitmap.width, 24, str, 1)
    end
  end
#class Sprite_Debug#def draw_weapon(n, bitmap, blta)
  def draw_weapon(n, bitmap, blta)
    item = $data_weapons[n]
    if item != nil
      bitmap.blt(0, 0, get_icon(item.icon_index), Rect.new(0,0,24,24), blta)
      bitmap.draw_text(24, 0, bitmap.width, 24, item.name)
      bitmap.draw_text(0, 0, bitmap.width-3, 24, $game_party.item_number(item), 2)
    end
  end
#class Sprite_Debug#def draw_armor(n, bitmap, blta)
  def draw_armor(n, bitmap, blta)
    item = $data_armors[n]
    if item != nil
      bitmap.blt(0, 0, get_icon(item.icon_index), Rect.new(0,0,24,24), blta)
      bitmap.draw_text(24, 0, bitmap.width, 24, item.name)
      bitmap.draw_text(0, 0, bitmap.width-3, 24, $game_party.item_number(item), 2)
    end
  end
#class Sprite_Debug#def draw_enemy(n, bitmap, blta)
  def draw_enemy(n, bitmap, blta)
    item = $game_troop.members[n-1]
    iw = bitmap.width
    if item != nil
      wb = Window_Base.new(-(iw+32),-56,iw+32,56) # I get a Window_Base for its
      wb.draw_actor_name(item, 24, 0)             #  useful draw_this, draw_that
      gs = iw-w
      vals = [-8, -2]
      if $imported["CoreFixesUpgradesMelody"] || $imported["BattleEngineMelody"]
        # REQUIRE YEM Battle Engine Melody OR YEM Core Fixes and Upgrades
          if item.use_rage?
            vals[0] -= 4; vals[1] -= 4; vals << 0
            wb.draw_enemy_rage_gauge(item, 96, vals[2], 48+gs)
          end
        # END REQUIRE
      end
      wb.draw_actor_hp_gauge(item, 96, vals[0], 48+gs)
      wb.draw_actor_mp_gauge(item, 96, vals[1], 48+gs)
      wb.draw_actor_state(item, 154+gs, 0, 48)
      wb.contents.font.size /= 2
      wb.contents.font.shadow = false
      col = false
      for i in -1..2; for j in -1..1
        next if i == j && i == 0
        if i == 2
          next if j != 0
          col = true
          i = 0
        end
        wb.contents.font.color = col ? Color.new(0,0,0) : wb.system_color
        wb.contents.draw_text(i+iw-80+16, j-4, 22, 24, Vocab::atk[0...3])
        wb.contents.draw_text(i+iw-48+16, j-4, 22, 24, Vocab::def[0...3])
        wb.contents.draw_text(i+iw-80+16, j+6, 22, 24, Vocab::spi[0...3])
        wb.contents.draw_text(i+iw-48+16, j+6, 22, 24, Vocab::agi[0...3])
        wb.contents.font.color = col ? Color.new(0,0,0) : wb.normal_color
        wb.contents.draw_text(i, j+8, 23, 24, item.letter, 2)
        wb.contents.draw_text(i+iw-80+26, j-4, 18, 24, item.atk, 2)
        wb.contents.draw_text(i+iw-48+26, j-4, 18, 24, item.def, 2)
        wb.contents.draw_text(i+iw-80+26, j+6, 18, 24, item.spi, 2)
        wb.contents.draw_text(i+iw-48+26, j+6, 18, 24, item.agi, 2)
        break if i == j && j == 0
      end;end
      bitmap.blt(0, 0, get_enemy_icon(item), Rect.new(0,0,24,24), blta)
      bitmap.blt(0, 0, wb.contents, wb.contents.rect, blta)
      wb.dispose
    else
      bitmap.blt(0, 0, get_text_icon(n.to_s), Rect.new(0,0,24,24), blta)
      bitmap.draw_text(0, 0, iw, 24, "...", 1)
    end
  end
#class Sprite_Debug#def get_icon(index)
  def get_icon(index) # get an icon with the Window_Base, cache it
    @icache ||= {}
    return @icache[index] if @icache[index]
    wb = Window_Base.new(-56,-56,56,56)
    wb.draw_icon(index,0,0)
    bit = wb.contents.clone
    wb.dispose
    @icache[index] = bit
    bit
  end
#class Sprite_Debug#def get_character_icon(chara, dir)
  def get_character_icon(chara, dir = false) # get iconized character from...
    if $imported["BattleEngineMelody"] && !dir # actors here have icons ^^
      # REQUIRE YEM Battle Engine Melody
        return get_icon(chara.battler_icon)
      # END REQUIRE
    end
    @icache ||= {}
    c_id = chara.character_name + "_" + chara.character_index.to_s + "_" +
           (dir ? chara.direction.to_s : "2")
    return @icache[c_id] if @icache[c_id]
    if dir
      cp = chara.clone
      cp.transparent = true
      sc = Sprite_Character.new(nil, cp) # ...a Sprite_Character or...
      bit = Bitmap.new(24, 24)
      bit.blt((24-sc.src_rect.width)/2,(24-sc.src_rect.height)/2,sc.bitmap, sc.src_rect)
      sc.dispose
      cp = nil
    else
      wb = Window_Base.new(-56,-56,56,56) # ...a Window_Base...
      wb.draw_actor_graphic(chara,12,33)
      bit = wb.contents.clone
      wb.dispose
    end
    @icache[c_id] = bit # ...and cache it
    bit
  end
#class Sprite_Debug#def get_text_icon(text)
  def get_text_icon(text) # get an iconized text, like S, V or numbers
    @icache ||= {}
    return @icache[text] if @icache[text]
    bit = Bitmap.new(24,24)
    bit.font.shadow = false
    bit.font.italic = true
    bit.font.bold = true
    bit.font.size -= 1
    bit.font.color = Color.new(81,59,59, 128)
    for i in -2..2; for j in -1..1 # draw black text many times around
      bit.draw_text(i,j+2,24,24,text,1)
    end; end
    bit.blur # then blur it
    bit.font.color = Color.new(255,255,255)
    bit.draw_text(0,2,24,24,text,1)
    @icache[text] = bit
    bit
  end
#class Sprite_Debug#def get_enemy_icon(enemy)
  def get_enemy_icon(enemy) # get an iconized enemy graphic
    @icache ||= {}
    if $imported["BattleEngineMelody"] # battlers here already have an icon ^^
      # REQUIRE YEM Battle Engine Melody
        wtf = enemy.enemy.enemy_icon_hue # enemy enemy enemy enemy enemy xD
        id = enemy.battler_icon.to_s + "_" + wtf.to_s
        return @icache[id] if @icache[id]
        bit = get_icon(enemy.battler_icon).clone
        bit.hue_change(wtf) if wtf != 0
      # END REQUIRE
    else
      id = enemy.battler_name + "_" + enemy.battler_hue.to_s
      return @icache[id] if @icache[id]
      bit = Bitmap.new(24,24)
      sb = Sprite_Battler.new(nil, enemy) # get the bitmap from a Sprite_Battler
      sb.opacity = 0 # don't wanna see the full battler
      if $imported["TankentaiSideview(Kaduki)"]
        # REQUIRE RPG Tankentai Sideview Battle System
          sb.make_battler # Tankentai has its own function for battler drawing
        # END REQUIRE
      else
        sb.update_battler_bitmap # let the graphic be loaded
      end
      sb.dispose if sb.bitmap.nil? || sb.bitmap.disposed? # no graphic?
      return bit if sb.disposed?
      b2 = Bitmap.new(sb.src_rect.width, sb.src_rect.height) # I get a new bitmap
      b2.blt(0, 0, sb.bitmap, sb.src_rect)                   #  within src_rect
      sb.bitmap = b2 # disposing sb even its bitmap will be disposed
      if b2.width <= 24 || b2.height <= 24 # if little bitmap just center it
        bit.blt((24-b2.width)/2, (24-b2.height)/2, b2, b2.rect)
      else # else resize
        fact = (b2.width > b2.height ? b2.height : b2.width)/24.0
        nw = b2.width/fact; nh = b2.height/fact
        bit.stretch_blt(Rect.new((24-nw)/2, (24-nh)/2, nw, nh), b2, b2.rect)
      end
      sb.dispose
    end
    @icache[id] = bit
    bit
  end
#class Sprite_Debug#def update()
  def update
    move_around if Input.trigger?(VDEBUG::MOVE_AROUND_KEY)
    for i in 0...@infos.compact.size
      v = @infos[i]
      # set every new value and redraw if needed
      draw_row(i) if @last_values[i] != (@last_values[i] = collect(v))
    end
    super
  end
end

# * operation to create a Visible Debug options screen

class Window_VDList < Window_Selectable
  # a silly, simple, window that handle a list
  attr_reader :data
#class Window_VDList#def initialize(x, y, list, ctd)
  def initialize(x, y, list = [], ctd = false)
    super(x, y, Graphics.width/2, Graphics.height-y)
    @column_max = 1
    @cantdisable = ctd
    self.index = 0
    set_list(list)
  end
#class Window_VDList#def set_list(list)
  def set_list(list)
    @data = list
    @item_max = @data.size
    self.index = @item_max - 1 if self.index > 0 && @item_max < self.index
    refresh
  end
#class Window_VDList#def enabled?(index)
  def enabled?(index)
    return true if @cantdisable
    !$game_player.sdebug.infos.include?(@data[index])
  end
#class Window_VDList#def item()
  def item
    return @data[self.index]
  end
#class Window_VDList#def add_item(it)
  def add_item(it)
    @data.push(it)
    set_list(@data.compact)
  end
#class Window_VDList#def remove_item(it)
  def remove_item(it)
    remove(@data.index(it))
  end
#class Window_VDList#def remove(index)
  def remove(index)
    return if index == nil
    return if index < 0
    return if index >= @data.size
    @data.delete_at(index)
    set_list(@data)
  end
#class Window_VDList#def refresh()
  def refresh
    create_contents
    for i in 0...@item_max
      draw_item(i)
    end
  end
#class Window_VDList#def draw_item(index)
  def draw_item(index)
    rect = item_rect(index)
    self.contents.clear_rect(rect)
    return if @data[index].nil?
    im = $game_player.sdebug.get_item(@data[index], rect.width-4, enabled?(index))
    self.contents.blt(rect.x, rect.y, im, im.rect) if im
    im.dispose if im
  end
end

class Scene_VisibleDebug < Scene_Base
  # a silly, simple, scene
#class Scene_VisibleDebug#def start()
  def start
    super
    create_menu_background
    @help_window = Window_Help.new
    @help_window.set_text(VDEBUG::HELP_TEXT)
    ips = @help_window.height
    # third list window parameter is the list, fourth is the cantdisable value
    @mainlist_window = Window_VDList.new(0, ips, VDEBUG::collect_mainlist)
    @debuglist_window = Window_VDList.new(@mainlist_window.width, ips,
                                          $game_player.sdebug.infos, true)
    @elementlist_window = Window_VDList.new(0, ips)
    @elementlist_window.visible = false
    @elementlist_window.active = false
    @debuglist_window.active = false
  end
#class Scene_VisibleDebug#def terminate()
  def terminate
    super
    dispose_menu_background
    @help_window.dispose
    @mainlist_window.dispose
    @debuglist_window.dispose
    @elementlist_window.dispose
  end
#class Scene_VisibleDebug#def update()
  def update
    super
    update_menu_background
    @help_window.update
    @mainlist_window.update
    @debuglist_window.update
    @elementlist_window.update
    if @mainlist_window.active
      update_mainlist
    elsif @debuglist_window.active
      update_debuglist
    elsif @elementlist_window.active
      update_elementlist
    end
  end
#class Scene_VisibleDebug#def update_mainlist()
  def update_mainlist
    if Input.trigger?(Input::
      Sound.play_cancel
      $scene = Scene_Map.new
      return
    elsif Input.trigger?(Input::C)
      Sound.play_decision
      it = @mainlist_window.item
      if it[0] >= 0 # if item's a item:
        if @mainlist_window.enabled?(@mainlist_window.index) # add/remove
          @debuglist_window.add_item(it)
        else
          @debuglist_window.remove_item(it)
        end
        $game_player.sdebug.infos = @debuglist_window.data # update
        @mainlist_window.draw_item(@mainlist_window.index) # redraw
      else # if item's a group:
        process_elementlist_open(it) # open the sub-list
        @mainlist_window.active = false
        @elementlist_window.active = true
      end
    elsif Input.trigger?(Input::R) || Input.trigger?(Input::L)
      Sound.play_cursor
      @mainlist_window.active = false
      @debuglist_window.active = true
    end
  end
#class Scene_VisibleDebug#def update_debuglist()
  def update_debuglist
    if Input.trigger?(Input::
      Sound.play_cancel
      $scene = Scene_Map.new
      return
    elsif Input.trigger?(Input::C)
      Sound.play_decision
      @debuglist_window.remove(@debuglist_window.index) # remove the item
      $game_player.sdebug.infos = @debuglist_window.data # update
      @mainlist_window.refresh # redraw
    elsif Input.trigger?(Input::R) || Input.trigger?(Input::L)
      Sound.play_cursor
      @mainlist_window.active = true
      @debuglist_window.active = false
    end
  end
#class Scene_VisibleDebug#def update_elementlist()
  def update_elementlist
    if Input.trigger?(Input::
      Sound.play_cancel
      @elementlist_window.active = false
      @mainlist_window.active = true
      @elementlist_window.close
    elsif Input.trigger?(Input::C)
      Sound.play_decision
      it = @elementlist_window.item
      if @elementlist_window.enabled?(@elementlist_window.index) # add/remove
        @debuglist_window.add_item(it)
      else
        @debuglist_window.remove_item(it)
      end
      $game_player.sdebug.infos = @debuglist_window.data # update
      @elementlist_window.draw_item(@elementlist_window.index) # redraw
    end
  end
#class Scene_VisibleDebug#def process_elementlist_open(it)
  def process_elementlist_open(it) # it contains the type and the size
    # collect elements of the group
    vals = []
    for d in 1..it[1] # starting from 1, because there aren't IDs 0 
      vals << [it[0]*-1,d] # the type must be positive
    end
    # and let the window appears
    @elementlist_window.set_list(vals)
    @elementlist_window.index = 0
    @elementlist_window.visible = true
    @elementlist_window.open
  end
end