#==============================================================================
# ** Silentwalker's SWScreenhunter
#------------------------------------------------------------------------------
# * Version - 1.1
# * Fecha - 21/07/10 (DD/MM/YY)
#
# swsilentwalker.wordpress.com
#==============================================================================
 
  #--------------------------------------------------------------------------
  # * Configuracion
  #--------------------------------------------------------------------------
  SWSCREENSHOT_DATA = 
  [
    # Nombre del directorio donde se guardan las capturas
    'Capturas de Pantalla/',
    # Mensaje que se muestra al guardar con exito
    'Captura guardada con exito',
    # Tiempo de permanencia del mensaje en pantalla
    32,
    # 0 = BMP, 1 = JPG, 2 = PNG
    2
  ]
 
#==============================================================================
# ** Graphics
#------------------------------------------------------------------------------
# - Cuerpo principal
#==============================================================================
 
module Graphics ; iniaccess = 'GetPrivateProfileStringA'
  SWScreen = Win32API.new('screenshot', 'Screenshot', %w(l l l l p l l), '')
  SWReadIni = Win32API.new('kernel32', iniaccess, %w(p p p p l p), 'l')
  SWFindSWWindow = Win32API.new('user32', 'FindWindowA', %w(p p), 'l')
  SWGetKeyState = Win32API.new("user32","GetAsyncKeyState",['i'],'i')
  SWac_win = "\0" * 256
  SWReadIni.call('Game', 'Title', '', SWac_win, 255, ".\\Game.ini")
  SWac_win.delete!("\0")
  SWWindow = SWFindSWWindow.call('RGSS Player', SWac_win)
  class << self
    @@_swshot_count = SWSCREENSHOT_DATA[2]
    @@_swshot_sprite = Sprite.new ; @@_swshot_sprite.z = 9999999
    @@_swshot_sprite.bitmap = Bitmap.new(640, 64)
    alias swsshot_update update
    #--------------------------------------------------------------------------
    # * Update
    #--------------------------------------------------------------------------
    def update(*args)
      swsshot_update(*args)
      if SWGetKeyState.call(0x2C) & 0x01 == 1
        @@_swshot_count = SWSCREENSHOT_DATA[2] ; self.freeze
        @@_swshot_sprite.bitmap.clear ; self.transition ; sleep(0.1)
        timestring = Time.now.strftime("%H hs - %Mm - %Ss - (%d-%b-%Y)")
        case SWSCREENSHOT_DATA[3]
        when 0 then ts = '.bmp'
        when 1 then ts = '.jpg'
        when 2 then ts = '.png'
        end
        filename = SWSCREENSHOT_DATA[0] + timestring + ts
        return if FileTest.exist?(filename)
        SWScreen.call(0, 0, 640, 480, filename, SWWindow, SWSCREENSHOT_DATA[3])
        @@_swshot_sprite.bitmap.draw_text(0, 0, 640, 32, SWSCREENSHOT_DATA[1])
        @@_swshot_count -= 1
      end
      if @@_swshot_count != SWSCREENSHOT_DATA[2] && @@_swshot_count > 0
        @@_swshot_count -= 1
      elsif @@_swshot_count <= 0 && @@_swshot_count != SWSCREENSHOT_DATA[2]
        self.freeze ; @@_swshot_sprite.bitmap.clear
        @@_swshot_count = SWSCREENSHOT_DATA[2] ; self.transition
      end
    end
  end
end

#==============================================================================
# ** Silentwalker's Simple Screensaver
#------------------------------------------------------------------------------
# * Version - 1.0
# * Fecha - 16/07/10 (DD/MM/YY)
#
# swsilentwalker.wordpress.com
#==============================================================================
 
  #--------------------------------------------------------------------------
  # * Scenes sin screensaver
  #--------------------------------------------------------------------------
  SWSSEXCL = [Scene_Title, Scene_Menu]
  #--------------------------------------------------------------------------
  # * Efecto, 0 = Imagen, 1 = Personalizado | Nombre del archivo
  #--------------------------------------------------------------------------
  SWSSSEFF = [1, 'Spacetravel']
  #--------------------------------------------------------------------------
  # * Numero de sprites a crear en el efecto personalizado
  #--------------------------------------------------------------------------
  SWSSSNUM = 120
  #--------------------------------------------------------------------------
  # * Cantidad de segundos a esperar antes de screensavear
  #--------------------------------------------------------------------------
  SWSSTIME = 5
 
#==============================================================================
# ** Module Graphics
#------------------------------------------------------------------------------
# - Clase principal
#==============================================================================
 
module Graphics
  @swscreen_max, @swscreen_count = (SWSSTIME * 40) / Graphics.frame_rate, 0
  @sw_screensave, @sw_screensave_set = false, [false, false]
  @stop, @swss_active = false, true
  #--------------------------------------------------------------------------
  # * Active?
  #--------------------------------------------------------------------------
  def self.swss_active=(v) ; @swss_active = v ; return ; end
  #--------------------------------------------------------------------------
  # * Alias to update & freeze
  #--------------------------------------------------------------------------
  class << self ; alias swss_update update ; alias swss_freeze freeze ; end
  #--------------------------------------------------------------------------
  # * Update Alias
  #--------------------------------------------------------------------------
  def self.update(*args) ; swss_update(*args)
    if @swss_active == true ; self.swscreen ; end
  end
  #--------------------------------------------------------------------------
  # * Freeze Alias
  #--------------------------------------------------------------------------
  def self.freeze(*args) ; swss_freeze(*args)
    if SWSSSEFF[0] == 0
      if @swss_spritesmate != nil
        @swss_spritesmate.dispose if !@swss_spritesmate.disposed? 
      end
    end
    if @swss_sprites != nil
      @swss_spritesmate.dispose if !@swss_spritesmate.disposed? 
      @swss_sprites.dispose if @swss_sprites.is_a?(Sprite)
      if @swss_sprites.is_a?(Array) && @swss_sprites.size > 0
        for sprite in @swss_sprites ; sprite.dispose ; end
        return
      end
    end
  end
  #--------------------------------------------------------------------------
  # * Screensaver
  #--------------------------------------------------------------------------
  def self.swscreen
    if SWSSEXCL != nil && SWSSEXCL.is_a?(Array)
      for exclude in SWSSEXCL ; return if $scene.is_a?(exclude) ; end
    end
    self.sw_screensave if @sw_screensave == true && @stop == false
    for key in Input.constants
      check = Input.const_get(key)
      if Input.trigger?(check) || Input.press?(check)
        @swscreen_count = 0
        if @stop == false
          @stop = true
          @sw_screensave_set[0], @sw_screensave_set[1] = false, false
          self.freeze
          self.transition
          return
        end
      end
    end
    @swscreen_count += 1
    if @swscreen_count / Graphics.frame_rate >= @swscreen_max
      @swscreen_count, @sw_screensave = 0, true
      @stop = false if @stop == true
      return
    end
  end
  #--------------------------------------------------------------------------
  # * Animated Image Method
  #--------------------------------------------------------------------------
  def self.swimage_mate
    if @sw_screensave_set[1] == false
      @swss_spritesmate = Sprite.new
      @swss_spritesmate.bitmap = RPG::Cache.picture('Screensaver')
      @swss_spritesmate.z = 999999
      @swss_spritesmate.opacity = 0
      @swss_blink, @sw_screensave_set[1] = true, true
    end
    return if @swss_spritesmate.disposed?
    if @swss_spritesmate.opacity > 0 && @swss_blink == false
      @swss_spritesmate.opacity -= 5
    elsif @swss_spritesmate.opacity <= 0
      @swss_blink = true
    end
    if @swss_spritesmate.opacity < 255 && @swss_blink == true
      @swss_spritesmate.opacity += 5
    elsif @swss_spritesmate.opacity >= 255
      @swss_blink = false
    end
  end
  #--------------------------------------------------------------------------
  # * Picks the right effect
  #--------------------------------------------------------------------------
  def self.sw_screensave
    return if @stop == true
    if SWSSSEFF[0] == 1
      code = IO.read('Data/' + SWSSSEFF[1] + '.rxdata')
      eval(code)
      self.swimage_mate
    elsif SWSSSEFF[0] == 0
      self.swimage_mate
    end
  end
end

#==============================================================================
# ** Silentwalker's Simple Drawing Pad
#------------------------------------------------------------------------------
# * Version - 1.0
# * Fecha - 12/07/10 (DD/MM/YY)
#
# swsilentwalker.wordpress.com
#==============================================================================
  #--------------------------------------------------------------------------
  # * Texto para la ventana de ayuda
  #--------------------------------------------------------------------------
  SWSD_HELPTXT = [
 
  'F5 -> Cambiar a lapiz, D -> Usar',
 
  'F6 -> Cambiar a goma borradora, D -> Usar',
 
  'F7 -> Cambiar color, vuelta en orden',
 
  'F8 -> Cambiar tamaño, vuelta en orden',
 
  'F9 -> Pintar fondo con color seleccionado',
 
  'A -> Crear una nueva pagina',
 
  'Ctrl + Z -> Lienzo blanco',
 
  'ESC -> Guardar y salir']
  #--------------------------------------------------------------------------
  # * Scene al salir
  #--------------------------------------------------------------------------
  SWSD_SCENETO = Scene_Map.new
  #--------------------------------------------------------------------------
  # * 0 = Windowskin, 1 = Picture | Nombre de la Picture
  #--------------------------------------------------------------------------
  SWSD_BACKTPE = [0, 'pergamino']
  #--------------------------------------------------------------------------
  # * true = texto sombreado, false = texto con borde, nil = texto comun
  #--------------------------------------------------------------------------
  SWSD_TXTSHAD = true
  #--------------------------------------------------------------------------
  # * true = bordes continuos, false = borde impasable
  #--------------------------------------------------------------------------
  SWSD_APLACE = true
  #--------------------------------------------------------------------------
  # * Colores disponibles, en orden, hasta 28.
  #--------------------------------------------------------------------------
  SWSD_DCOLOR = [
 
  Color.new(0, 0, 0, 255),
 
  Color.new(190, 190, 190, 255),
 
  Color.new(165, 42, 42, 255),
 
  Color.new(184, 134, 11, 255),
 
  Color.new(46, 139, 87, 255),
 
  Color.new(32, 178, 170, 255),
 
  Color.new(25, 25, 112, 255),
 
  Color.new(148, 0, 211, 255),
 
  Color.new(218, 165, 32, 255),
 
  Color.new(0, 100, 0, 255),
 
  Color.new(0, 191, 255, 255),
 
  Color.new(0, 0, 205, 255),
 
  Color.new(106, 90, 205, 255),
 
  Color.new(255, 165, 0, 255),
 
  Color.new(255, 255, 255, 255),
 
  Color.new(211, 211, 211, 255),
 
  Color.new(255, 33, 33, 255),
 
  Color.new(255, 255, 0, 255),
 
  Color.new(127, 255, 0, 255),
 
  Color.new(0, 255, 255, 255),
 
  Color.new(0, 0, 255, 255),
 
  Color.new(255, 20, 147, 255),
 
  Color.new(238, 221, 130, 255),
 
  Color.new(0, 250, 154, 255),
 
  Color.new(127, 255, 212, 255),
 
 
  Color.new(100, 149, 237, 255), 
 
  Color.new(255, 99, 71, 255),
 
  Color.new(244, 164, 96, 255),
 
  Color.new(255, 255, 255, 255)]
 
#==============================================================================
# ** Game_System
#------------------------------------------------------------------------------
# - Agregados
#==============================================================================
 
class Game_System
  #--------------------------------------------------------------------------
  # * alias to initialize
  #--------------------------------------------------------------------------
  alias swsdraw initialize
  #--------------------------------------------------------------------------
  # * Public
  #--------------------------------------------------------------------------
  attr_accessor :swdraw
  #--------------------------------------------------------------------------
  # * Initialize
  #--------------------------------------------------------------------------
  def initialize ; @swdraw = [] ; swsdraw ; end
end
 
#==============================================================================
# ** SWDrawing
#------------------------------------------------------------------------------
# - Claes Principal
#==============================================================================
 
class SWDrawing
  #--------------------------------------------------------------------------
  # * Initialize
  #--------------------------------------------------------------------------
  def initialize(index = 0, clear = false) ; @index, @clear = index, clear ; end
  #--------------------------------------------------------------------------
  # * Draw Text
  #--------------------------------------------------------------------------
  def draw_text(x, y, width, height, string, align = 0, shad = SWSD_TXTSHAD)
    d = @sb.bitmap.font.color
    @oldco = Color.new(d.red, d.green, d.blue, d.alpha)
    @sb.bitmap.font.color = Color.new(0, 0, 0, 255)
    if shad == true
      @sb.bitmap.draw_text(x + 2, y + 2, width, height, string, align)
    elsif shad == false
      @sb.bitmap.draw_text(x, y, width, height, string, align)
      @sb.bitmap.draw_text(x - 2, y, width, height, string, align)
      @sb.bitmap.draw_text(x + 2, y, width, height, string, align)
      @sb.bitmap.draw_text(x, y + 2, width, height, string, align)
      @sb.bitmap.draw_text(x, y - 2, width, height, string, align)
    end
    @sb.bitmap.font.color = @oldco
    @sb.bitmap.draw_text(x, y, width, height, string, align)
  end
  #--------------------------------------------------------------------------
  # * Main Processing
  #--------------------------------------------------------------------------
  def main
    @helpwin = Window_Base.new(120, 90, 400, 300) ; @helpwin.z = 9999999
    @helpwin.contents = Bitmap.new(400 - 32, 300 - 32)
    @helpwin.visible = false
    @helpwin.contents.font.size = 18
    @helpwin.contents.font.name = 'Tahoma'
    (0...8).each {|i|
    @helpwin.contents.draw_text(16, 8 + 32 * i, 400 - 32, 32, SWSD_HELPTXT[i])}    
    @change, @set, @gc, @sz, @sp, @bc = false, 0, 0, 1, 2, Color.new(0, 0, 0)
    if SWSD_BACKTPE[0] == 1
      @bb = Sprite.new ; @bb.bitmap = RPG::Cache.picture('pergamino')
    elsif SWSD_BACKTPE[0] == 0
      @bb = Window_Base.new(0, 0, 640, 480)
      @bb.z = 0
    end
    @bs = Sprite.new ; @bs.bitmap = Bitmap.new(412, 312)
    @bs.x, @bs.y = 114, 84
    @bs.bitmap.fill_rect(0, 0, 412, 312, Color.new(0, 0, 0, 255))
    @bs.bitmap.fill_rect(2, 2, 408, 308, Color.new(255, 255, 255, 255))
    @bs.bitmap.fill_rect(4, 4, 404, 304, Color.new(0, 0, 0, 255))
    @sb = Sprite.new ; @sb.bitmap = Bitmap.new(640, 480)
    @sb.bitmap.fill_rect(120, 90, 400, 300, Color.new(255, 255, 255, 255))
    load(@index) if !$game_system.swdraw.empty? && !@clear
    if @clear
      @sb.bitmap.fill_rect(120, 90, 400, 300, Color.new(0, 0, 0, 0))
      @sb.bitmap.fill_rect(120, 90, 400, 300, Color.new(255, 255, 255, 255))
    end
    save
    @cr = Sprite.new ; @cr.x, @cr.y = 120, 90
    @cr.bitmap = RPG::Cache.picture('SWDraw/swdr0.png')
    @sb.bitmap.font.size = 18
    (0..2).each {|i|
    bit = RPG::Cache.picture('SWDraw/tb' + i.to_s)
    rect = Rect.new(0, 0, bit.width, bit.height)
    x, y = 580 - bit.width / 2, (240 - (((bit.height + 32) * 3) / 2)) + 48 * i
    @sb.bitmap.blt(x, (y + 16) + i * 32, bit, rect)
    draw_text(x, y + 48, 48, 32, 'ESC', 1) if i == 2
    draw_text(x, y + 16, 48, 32, 'Enter', 1) if i == 1
    draw_text(x, y - 16, 48, 32, 'A', 1) if i == 0}
    iz = RPG::Cache.picture('SWDraw/izquierda')
    @sb.bitmap.blt(120, 86 - iz.height, iz, Rect.new(0, 0, iz.width, iz.height))
    dr = RPG::Cache.picture('SWDraw/derecha')
    dw, dh = dr.width, dr.height
    @sb.bitmap.blt(520 - dw, 86 - dh, dr, Rect.new(0, 0, dw, dh))
    (0..5).each {|i|
    str = 'F' + (i + 5).to_s
    str = 'CtrlZ' if i == 5
    b = RPG::Cache.picture('SWDraw/swdr' + i.to_s)
    r = Rect.new(0, 0, b.width, b.height)
    x, y = (24 + 32) * (i % 2), 150 + (80 * (i / 2))
    draw_text(24 + x, y - 28, 32, 32, str, 1)
    @sb.bitmap.blt(24 + x, y, b, r)}
    stringer = (@index + 1).to_s + ' / ' + $game_system.swdraw.size.to_s
    @sb.bitmap.draw_text(0, 48, 640, 32, stringer, 1)
    (0..SWSD_DCOLOR.size - 2).each {|i|
    x, y = 128 + 28 * (i % 14), 408 + (28 * (i / 14))
    @sb.bitmap.fill_rect(x, y, 20, 20, SWSD_DCOLOR[i])}
    @sc = Sprite.new ; @sc.bitmap = Bitmap.new(28, 28)
    @sc.bitmap.fill_rect(0, 0, 24, 24, Color.new(255, 255, 255, 255))
    @sc.bitmap.fill_rect(2, 2, 20, 20, Color.new(0, 0, 0, 0))
    @sc.x, @sc.y = 126, 406 ; @sb.bitmap.font.size = 24
    draw_text(0, 16, 640, 32, 'Bloc de Dibujos', 1, false)
    size = @sb.bitmap.text_size('Bloc de Dibujos').width / 2
    @sb.bitmap.fill_rect(320 - size, 44, size * 2, 2, Color.new(255, 255, 255))
    @sb.bitmap.fill_rect(322 - size, 46, size * 2, 2, Color.new(0, 0, 0))
    draw_text(120, 86 - iz.height, 48, 32, 'Q', 1, false)
    draw_text(520 - dw / 2, 86 - dh, 48, 32, 'W', 1, false)
    Graphics.transition
    loop {Graphics.update ; Input.update
    if @helpwin.visible == false
      update_movement ; update_input; keep_coordrate
    else
      if Input.trigger?(Input::C) || Input.trigger?(Input::B)
        $game_system.se_play($data_system.decision_se)
        @helpwin.visible = false
      end
    end
    @sc.x, @sc.y = 126 + 28 * (@gc % 14), 406 + (28 * (@gc / 14))
    break if $scene != self}
    Graphics.freeze
    @sb.dispose ; @cr.dispose ; @bb.dispose ; @sc.dispose ; @bs.dispose
    @helpwin.dispose
  end
  #--------------------------------------------------------------------------
  # * Keep Coord Rate
  #--------------------------------------------------------------------------
  def keep_coordrate
    case @set
    when 0
      @compareup = 90 - @cr.bitmap.height ; @compareri = 520 - @sz
      @comparele = 120  ; @comparedo = (390 - @sz) - @cr.bitmap.height
    when 1
      @compareup = 92 ; @compareri = 518 - @cr.bitmap.width
      @comparele = 122 ; @comparedo = (389 - @sz) - @cr.bitmap.height
    end
    if @cr.x > @compareri
      @cr.x = 120 + @sz if SWSD_APLACE == true && @set != 1
      @cr.x = 520 - @sz if SWSD_APLACE == false && @set != 1
      @cr.x = 122 if SWSD_APLACE == true && @set != 0
      @cr.x = 518 - @cr.bitmap.width if SWSD_APLACE == false && @set != 0
    elsif @cr.x < @comparele
      @cr.x = 520 - @sz if SWSD_APLACE == true && @set != 1
      @cr.x = 120 if SWSD_APLACE == false && @set != 1
      @cr.x = 518 - @cr.bitmap.width if SWSD_APLACE == true && @set != 0
      @cr.x = 122 if SWSD_APLACE == false && @set != 0
    end
    if @cr.y > @comparedo
      @cr.y = (90 - @cr.bitmap.height) + @sz if SWSD_APLACE == true && @set != 1
      @cr.y = (390 - @sz) - @cr.bitmap.height if SWSD_APLACE == false && @set != 1
      @cr.y = 92 if SWSD_APLACE == true && @set != 0
      @cr.y = (389 - @sz) - @cr.bitmap.height if SWSD_APLACE == false && @set != 0
    elsif @cr.y < @compareup
      @cr.y = 390 - @cr.bitmap.height - @sz if SWSD_APLACE == true && @set != 1
      @cr.y = 90 - @cr.bitmap.height if SWSD_APLACE == false && @set != 1
      @cr.y = (389 - @sz) - @cr.bitmap.height if SWSD_APLACE == true && @set != 0
      @cr.y = 92 if SWSD_APLACE == false && @set != 0
    end
  end
  #--------------------------------------------------------------------------
  # * Load
  #--------------------------------------------------------------------------
  def load(f = $game_system.swdraw.size - 1)
    cont = $game_system.swdraw[f]
    (0..400).each {|w| (0..300).each {|h|
    @sb.bitmap.set_pixel(120 + w, 90 + h, cont[w][h])}}
    return
  end
  #--------------------------------------------------------------------------
  # * Save
  #--------------------------------------------------------------------------
  def save(new_slot = false)
    cont = []
    (0..400).each {|w| cont[w] = [] ; (0..300).each {|h|
    cont[w].push(@sb.bitmap.get_pixel(120 + w, 90 + h))}}
    if $game_system.swdraw[@index] != nil
      $game_system.swdraw[@index] = cont
    elsif $game_system.swdraw[@index] == nil
      $game_system.swdraw.push(cont)
    end
    $game_system.swdraw.push(cont) if new_slot == true
    return
  end
  #--------------------------------------------------------------------------
  # * Main Processing
  #--------------------------------------------------------------------------
  def update_movement
    if Input.trigger?(Input::L)
      save if @change
      $game_system.se_play($data_system.cursor_se)
      @index += $game_system.swdraw.size - 1
      @index %= $game_system.swdraw.size
      $scene = SWDrawing.new(@index)
      return
    end
    if Input.trigger?(Input::R)
      save if @change
      $game_system.se_play($data_system.cursor_se)
      @index += 1
      @index %= $game_system.swdraw.size
      $scene = SWDrawing.new(@index)
      return
    end
    case Input.dir8
    when 1 ; @cr.y += @sp ; @cr.x -= @sp
    when 2 ; @cr.y += @sp
    when 3 ; @cr.x += @sp ; @cr.y += @sp
    when 4 ; @cr.x -= @sp
    when 6 ; @cr.x += @sp
    when 7 ; @cr.x -= @sp ; @cr.y -= @sp
    when 8 ; @cr.y -= @sp
    when 9 ; @cr.y -= @sp ; @cr.x += @sp
    end   
    if Input.press?(Input::Z)
      @change, @slow, @sp = true, true, 1
      if @set == 0
        @gx, @gy = 120 + @cr.x - 120, 90 + (@cr.y + @cr.bitmap.height) - 90
        @gw, @gh = @sz, @sz
      elsif @set == 1
        @gx, @gy = 120 + @cr.x - 120, 90 + @cr.y - 90
        @gw, @gh = @bit.width, @bit.height   
      end
      @sb.bitmap.fill_rect(@gx, @gy, @gw, @gh, @bc)
    else
      if @slow == true
        @slow, @sp = false, 2
        return
      end
    end
  end
  #--------------------------------------------------------------------------
  # * Main Processing
  #--------------------------------------------------------------------------
  def update_input
    if Input.trigger?(Input::C)
      $game_system.se_play($data_system.decision_se)
      @helpwin.visible = true
      Graphics.transition
      return
    end
    if Input.trigger?(Input::B)
      save
      $game_system.se_play($data_system.decision_se)
      $scene = SWSD_SCENETO
      return
    end
    if Input.trigger?(Input::X)
      save(true)
      $scene = SWDrawing.new($game_system.swdraw.size - 1, true)
      return
    end
    if Input.trigger?(Input::F7)
      if @set != 1
        if @gc < SWSD_DCOLOR.size - 2 ; @gc += 1
        elsif @gc >= SWSD_DCOLOR.size - 2 ; @gc = 0
        end ; @bc = SWSD_DCOLOR[@gc]
      else
        $game_system.se_play($data_system.buzzer_se)
      end
      return
    elsif Input.trigger?(Input::F8)
      if @sz < 16 ; @sz += 1 ; elsif @sz >= 16 ; @sz = 1 ; end
      Graphics.transition
      return
    elsif Input.trigger?(Input::F5)
      @bc = SWSD_DCOLOR[@gc]
      @set = 0
      @cr.bitmap = RPG::Cache.picture('SWDraw/swdr0.png')
      Graphics.transition
      return
    elsif Input.trigger?(Input::F6)
      @bc = SWSD_DCOLOR[SWSD_DCOLOR.size - 1]
      @set = 1
      @bit = RPG::Cache.picture('SWDraw/swdr1.png')
      @cr.bitmap = @bit
      Graphics.transition
      return
    elsif Input.trigger?(Input::F9)
      @change = true
      @sb.bitmap.fill_rect(120, 90, 400, 300, Color.new(0, 0, 0, 0))
      @sb.bitmap.fill_rect(120, 90, 400, 300, @bc)
      Graphics.transition
      return
    end
    if Input.press?(Input::CTRL) && Input.trigger?(Input::A)
      @change = true
      @sb.bitmap.fill_rect(120, 90, 400, 300, Color.new(0, 0, 0, 0))
      @sb.bitmap.fill_rect(120, 90, 400, 300, Color.new(255, 255, 255, 255))
      Graphics.transition
      return
    end
  end
end