DebugEx

################################################################################
#                          DebugEx : Mejoras del DEBUG                         #
#                                Autor : Bezier                                #
#                                                                              #
# Este script mejora algunas funciones del menú del DEBUG para agilizar su uso #
################################################################################

# Muestra los paneles necesarios para buscar en un listado de comandos
# commands  = Lista de comandos que se muestran en el listado
# lister    = Clase de tipo XXXLister que genera los comandos
# viewport  = Viewport donde se muestra el listado
# inputs    = Array con los inputs que se usan para la selección
def showSearchWindow(commands,lister,viewport,inputs=nil)
  # Sprite con el título
  title=Window_UnformattedTextPokemon.new("Escribe el texto a buscar\n -> ENTER: Confirma\n -> ESC: Cancela")
  title.x=0
  title.y=Graphics.height-title.height-64
  title.viewport=viewport
  title.z=999
  # Sprite para la entrada de texto por teclado
  search_win=Window_TextEntry_Keyboard.new("",0,Graphics.height-64,250,64)
  search_win.viewport=viewport
  search_win.maxlength=50
  search_win.z=999
  # Bucle para la búsqueda de candidatos
  candidates=[]
  indexes=[]
  selected=0
  loop do
    Graphics.update
    Input.update
    search_win.update
    if Input.triggerex?(0x1B) # Escape
      selected=-2
      break
    elsif Input.triggerex?(0x0D) # Enter
      filter=search_win.text[0..-2].downcase
      if filter!=""
        for i in 0...commands.length
          cmd=commands[i]
          if cmd.is_a?(Array)
            for item in cmd
              if item.to_s.downcase.include?(filter)
                candidates << cmd
                indexes << i
                break
              end
            end
          elsif cmd.to_s.downcase.include?(filter)
            candidates << cmd
            indexes << i
          end
        end
      end
      break
    end
  end
  title.dispose
  search_win.dispose
  # Si hay candidatos, muestra un listado con los elementos filtrados
  if candidates.length > 0
    lister.refresh(indexes[0])
    if candidates.length>0
      list=pbListWindow([],256)
      list.viewport=viewport
      list.z=999
      list.commands=candidates
      list.index=0
      loop do
        Graphics.update
        Input.update
        list.update
        if list.index!=selected
          lister.refresh(indexes[list.index])
          selected=list.index
        end
        if Input.trigger?(Input::C) ||
           (list.doubleclick? rescue false) ||
           (inputs && inputs.any? {|key| Input.trigger?(key) })
          selected=indexes[selected]
          break
        elsif Input.trigger?(Input::B)
          selected=-1
          break
        end
      end
      list.dispose
    end
  else
    selected=-1
  end
  return selected
end

################################################################################
# Lists (Debug)
################################################################################

# Redefine esta función para:
# - Mostrar una lista con sprite en vez de la lista simple
# - Usar las funciones de búsqueda
def pbChooseSpeciesOrdered(default)
  specie=pbListScreen(_INTL("AGREGAR POKÉMON"), PokemonLister.new(0))
  specie=0 if specie<0
  return specie
end

################################################################################
# Core lister script (Editor)
################################################################################

# Amplia la función para incluir la opción de búsqueda
def pbListScreen(title,lister)
  viewport=Viewport.new(0,0,Graphics.width,Graphics.height)
  viewport.z=99999
  list=pbListWindow([],256)
  list.viewport=viewport
  list.z=2
  # Añade el texto de búsqueda en el menú
  title+="\n D: Buscar"
  title=Window_UnformattedTextPokemon.new(title)
  title.x=256
  title.y=0
  title.width=Graphics.width-256
  title.viewport=viewport
  title.z=2
  lister.setViewport(viewport)
  selected=-1
  commands=lister.commands
  selindex=lister.startIndex
  if commands.length==0
    value=lister.value(-1)
    lister.dispose
    return value
  end
  list.commands=commands
  list.index=selindex
  loop do
    Graphics.update
    Input.update
    list.update
    if list.index!=selected
      lister.refresh(list.index)
      selected=list.index
    end
    if Input.trigger?(Input::C) || (list.doubleclick? rescue false)
      break
    elsif Input.trigger?(Input::B)
      selected=-1
      break
    elsif Input.trigger?(Input::Z) # D: Buscar
      selected=showSearchWindow(commands,lister,viewport)
      break if selected!=-1
    end
  end
  value=lister.value(selected)
  lister.dispose
  title.dispose
  list.dispose
  Input.update
  return value
end

def pbListScreenBlock(title,lister)
  viewport=Viewport.new(0,0,Graphics.width,Graphics.height)
  viewport.z=99999
  list=pbListWindow([],256)
  list.viewport=viewport
  list.z=2
  # Añade el texto de búsqueda en el menú
  title+="\n D: Buscar"
  title=Window_UnformattedTextPokemon.new(title)
  title.x=256
  title.y=0
  title.width=Graphics.width-256
  title.viewport=viewport
  title.z=2
  lister.setViewport(viewport)
  selected=-1
  commands=lister.commands
  selindex=lister.startIndex
  if commands.length==0
    value=lister.value(-1)
    lister.dispose
    return value
  end
  list.commands=commands
  list.index=selindex
  loop do
    Graphics.update
    Input.update
    list.update
    if list.index!=selected
      lister.refresh(list.index)
      selected=list.index
    end
    if Input.trigger?(Input::Z) # D: Buscar con inputs
      selected=showSearchWindow(commands,lister,viewport,[Input::C,Input::A])
    end
    if Input.trigger?(Input::A)
      yield(Input::A, lister.value(selected))
      list.commands=lister.commands
      if list.index==list.commands.length
        list.index=list.commands.length
      end
      lister.refresh(list.index)
    elsif Input.trigger?(Input::C) || (list.doubleclick? rescue false)
      yield(Input::C, lister.value(selected))
      list.commands=lister.commands
      if list.index==list.commands.length
        list.index=list.commands.length
      end
      lister.refresh(list.index)
    elsif Input.trigger?(Input::B)
      break
    end
  end
  lister.dispose
  title.dispose
  list.dispose
  Input.update
end

################################################################################
# General listers (Editor)
################################################################################

# Lista los Pokémon ordenados alfabéticamente y los devuelve como comandos para selección
class PokemonLister
  def initialize(selection)
    @sprite=PokemonSprite.new(@viewport)
    @sprite.z=2
    @selection=selection
    @commands=[]
    @species=[]
    @index=0
  end

  def setViewport(viewport)
    @sprite.viewport=viewport
  end

  def startIndex
    return @index
  end

  def value(index)
    return (index<0) ? -1 : @species[index]
  end

  def dispose
    @sprite.bitmap.dispose if @sprite.bitmap
    @sprite.dispose
  end

  def commands   # Ordenados alfabéticamente
    @commands.clear
    cmds=[]
    for i in 1..PBSpecies.maxValue
      cname=getConstantName(PBSpecies,i) rescue nil
      cmds.push([i,PBSpecies.getName(i)]) if cname
    end
    cmds.sort! {|a,b| a[1]<=>b[1]}
    for c in cmds
      @commands.push(_ISPRINTF("{1:03d}: {2:s}",c[0],c[1]))
      @species.push(c[0])
    end
    @index=@selection
    @index=@commands.length-1 if @index>=@commands.length
    @index=0 if @index<0
    return @commands
  end

  def refresh(index)
    @sprite.bitmap.dispose if @sprite.bitmap
    return if index<0
    @sprite.setSpeciesBitmap(@species[index])
    if @sprite.bitmap
      @sprite.x=(Graphics.width-((Graphics.width-256)/2))-(@sprite.bitmap.width/2)
      @sprite.y=(Graphics.height-((Graphics.height-64)/2))-(@sprite.bitmap.height/2)
    end
  end
end

#===============================================================================
# Edits the terrain tags of tiles in tilesets.
#===============================================================================
# [ Actualizado por Bezier ]
# Cambios:
#   Autotag:    Pulsar A para cambiar el valor del tag que será aplicado con la
#               tecla C sin tener que asignar el valor cada vez
#   Selección:  Pulsar S para seleccionar un área y aplicar el autotag
#===============================================================================
begin

def pbTilesetWrapper
  return PokemonDataWrapper.new(
     "Data/Tilesets.rxdata",
     "Data/TilesetsTemp.rxdata",
     Proc.new{
        Kernel.pbMessage(_INTL("El editor ha detectado que los datos del tileset fueron editados recientemente en RPG Maker XP."))
        next !Kernel.pbConfirmMessage(_INTL("¿Quieres cargar estos cambios recientes?"))
     }
  )
end



class PokemonTilesetScene

  # Obtiene las coordenadas y dimensión de la selección actual
  def getSelectionValues
    return [@x,@y,@x,@y,1,1] if @selection.size==0
    x0=[@selection[0][0],@selection[1][0]].min
    y0=[@selection[0][1],@selection[1][1]].min
    x1=[@selection[0][0],@selection[1][0]].max
    y1=[@selection[0][1],@selection[1][1]].max
    w=x1-x0+28
    h=y1-y0+28
    return [x0,y0,x1,y1,w,h]
  end

  def pbUpdateTileset
    @sprites["overlay"].bitmap.clear
    textpos=[]
    @sprites["tileset"].src_rect=Rect.new(0,@topy,256,Graphics.height)
    tilesize=@tileset.terrain_tags.xsize
    for yy in 0...(Graphics.height)/32
      ypos=(yy+(@topy/32))*8+384
      next if ypos>=tilesize
      for xx in 0...8
        terr=ypos<384 ? @tileset.terrain_tags[xx*48] : @tileset.terrain_tags[ypos+xx]
        if ypos<384
          @tilehelper.bltTile(@sprites["overlay"].bitmap,xx*32,yy*32,xx*48)
        end
        textpos.push(["#{terr}",xx*32+16,yy*32,2,Color.new(80,80,80),Color.new(192,192,192)])
      end
    end
    # Pinta la selección en vez de la celda actual [@x,@y]
    if @selectionMode && @selection.size>0
      x0,y0,x1,y1,w,h=getSelectionValues
      @sprites["overlay"].bitmap.fill_rect(x0,y0-@topy,w,4,Color.new(255,0,0))
      @sprites["overlay"].bitmap.fill_rect(x0,y0-@topy,4,h,Color.new(255,0,0))
      @sprites["overlay"].bitmap.fill_rect(x0,y1-@topy+28,w,4,Color.new(255,0,0))
      @sprites["overlay"].bitmap.fill_rect(x1+28,y0-@topy,4,h,Color.new(255,0,0))
    else
      @sprites["overlay"].bitmap.fill_rect(@x,@y-@topy,32,4,Color.new(255,0,0))
      @sprites["overlay"].bitmap.fill_rect(@x,@y-@topy,4,32,Color.new(255,0,0))
      @sprites["overlay"].bitmap.fill_rect(@x,@y-@topy+28,32,4,Color.new(255,0,0))
      @sprites["overlay"].bitmap.fill_rect(@x+28,@y-@topy,4,32,Color.new(255,0,0))
    end
    pbDrawTextPositions(@sprites["overlay"].bitmap,textpos)
  end

  def pbGetSelected(x,y)
    if y<0
      return 48*(x/32)
    else
      return (y/32)*8+384+(x/32)
    end
  end

  def pbSetSelected(i,value)
    if i<384
      for j in 0...48
        @tileset.terrain_tags[i+j]=value
      end
    else
      @tileset.terrain_tags[i]=value
    end
  end

  def pbChooseTileset
    commands=[]
    for i in 1...@tilesetwrapper.data.length
      commands.push(sprintf("%03d %s",i,@tilesetwrapper.data[i].name))
    end
    ret=Kernel.pbShowCommands(nil,commands,-1)
    if ret>=0
      @tileset=@tilesetwrapper.data[ret+1]
      @tilehelper.dispose
      @tilehelper=TileDrawingHelper.fromTileset(@tileset)
      @sprites["tileset"].setBitmap("Graphics/Tilesets/#{@tileset.tileset_name}")
      @x=0
      @y=-32
      @topy=-32
      pbUpdateTileset
    end
  end

  # Actualiza el sprite que muestra el menú
  def updateMenu
    txt=getTittleText
    @sprites["title"].text=txt
    @sprites["title"].resizeToFit(txt)
    @sprites["title"].width=Graphics.width-256
  end

  # Texto del menú dependiendo del estado actual del editor de Tileset
  def getTittleText
    txt = "Tileset Editor\nQ/W: Desplaza\n    Z: Menú\n    A: Autotag [ " + @autotag.to_s + " ]\n    S: Selección"
    if @selectionMode
      txt += " [ON]"
      txt += "\n    C: [ " + @autotag.to_s + " ] -> selección"
    end
    return txt
  end

  # Actualiza el rectángulo de selección con las coordenadas actuales
  def setSelectionRect
    if @selection.size==0
      @selection[0]=[@x,@y]
    end
    @selection[1]=[@x,@y]
  end

  # Se ha cambiado un poco el interfaz para mostrar el nuevo menú a la derecha,
  # el tileset ajustado arriba a la izquierda y gestionar los nuevos inputs
  def pbStartScene
    @viewport=Viewport.new(0,0,Graphics.width,Graphics.height)
    @viewport.z=99999
    @tilesetwrapper=pbTilesetWrapper
    @tileset=@tilesetwrapper.data[1]
    @tilehelper=TileDrawingHelper.fromTileset(@tileset)
    @sprites={}
    @autotag=0
    @selectionMode=false
    @selection=[]
    @sprites["title"]=Window_UnformattedTextPokemon.new(getTittleText)
    @sprites["title"].viewport=@viewport
    @sprites["title"].x=260
    @sprites["title"].y=0
    @sprites["title"].width=Graphics.width-256
    @sprites["tileset"]=IconSprite.new(0,0,@viewport)
    @sprites["tileset"].setBitmap("Graphics/Tilesets/#{@tileset.tileset_name}")
    @sprites["tileset"].src_rect=Rect.new(0,0,256,Graphics.height)
    @sprites["overlay"]=BitmapSprite.new(256,Graphics.height,@viewport)
    @sprites["overlay"].x=0
    @sprites["overlay"].y=0
    pbSetSystemFont(@sprites["overlay"].bitmap)
    @sprites["title"].visible=true
    @sprites["tileset"].visible=true
    @sprites["overlay"].visible=true
    @x=0
    @y=-32
    @topy=-32
    pbUpdateTileset
    pbFadeInAndShow(@sprites)
    height=@sprites["tileset"].bitmap.height
    ########
    loop do
      Graphics.update
      Input.update
      if Input.repeat?(Input::UP)
        @y-=32
        @y=-32 if @y<-32
        @topy=@y if @y<@topy
        setSelectionRect if @selectionMode
        pbUpdateTileset
      elsif Input.repeat?(Input::DOWN)
        @y+=32
        @y=@sprites["tileset"].bitmap.height-32 if @y>=@sprites["tileset"].bitmap.height-32
        @topy=@y-(Graphics.height)+32 if @y-@topy>=Graphics.height
        setSelectionRect if @selectionMode
        pbUpdateTileset
      elsif Input.repeat?(Input::LEFT)
        @x-=32
        @x=0 if @x<0
        setSelectionRect if @selectionMode
        pbUpdateTileset
      elsif Input.repeat?(Input::RIGHT)
        @x+=32
        @x=256-32 if @x>=256-32
        setSelectionRect if @selectionMode
        pbUpdateTileset
      elsif Input.repeat?(Input::L)
        @y-=((Graphics.height)/32)*32
        @topy-=((Graphics.height)/32)*32
        @y=-32 if @y<-32
        @topy=@y if @y<@topy
        @topy=-32 if @topy<-32
        setSelectionRect if @selectionMode
        pbUpdateTileset
      elsif Input.repeat?(Input::R)
        @y+=((Graphics.height)/32)*32
        @topy+=((Graphics.height)/32)*32
        @y=@sprites["tileset"].bitmap.height-32 if @y>=@sprites["tileset"].bitmap.height-32
        @topy=@y-(Graphics.height)+32 if @y-@topy>=Graphics.height
        @topy=@sprites["tileset"].bitmap.height-(Graphics.height) if @topy>=@sprites["tileset"].bitmap.height-(Graphics.height)
        setSelectionRect if @selectionMode
        pbUpdateTileset

      elsif Input.trigger?(Input::X) # Autotag
        params=ChooseNumberParams.new
        params.setRange(0,99)
        @autotag=Kernel.pbMessageChooseNumber(_INTL("Cambiar autotag."),params)
        updateMenu

      elsif Input.trigger?(Input::Y) # Selección
        if @selectionMode
          @selectionMode=false
          @selection=[]
        else
          @selectionMode=true
          setSelectionRect
        end
        updateMenu
        pbUpdateTileset

      elsif Input.trigger?(Input::A)
        commands=[
           _INTL("Ir abajo"),
           _INTL("Ir arriba"),
           _INTL("Cambiar tileset"),
           _INTL("Salir")
        ]
        ret=Kernel.pbShowCommands(nil,commands,-1)
        case ret
        when 0
          @y=@sprites["tileset"].bitmap.height-32
          @topy=@y-(Graphics.height)+32 if @y-@topy>=Graphics.height
          pbUpdateTileset
        when 1
          @y=-32
          @topy=@y if @y<@topy
          pbUpdateTileset
        when 2
          pbChooseTileset
        end
      elsif Input.trigger?(Input::B)
        if Kernel.pbConfirmMessage(_INTL("¿Guardar los cambios?"))
          @tilesetwrapper.save
          $data_tilesets=@tilesetwrapper.data
          if $game_map && $MapFactory
            $MapFactory.setup($game_map.map_id)
            $game_player.center($game_player.x,$game_player.y)
            if $scene.is_a?(Scene_Map)
              $scene.disposeSpritesets
              $scene.createSpritesets
            end
          end
          Kernel.pbMessage(_INTL("Para asegurar que los cambios se mantengan, cierre y vuelva a abrir RPG Maker XP."))
        end
        break if Kernel.pbConfirmMessage(_INTL("¿Salir del editor?"))
      elsif Input.trigger?(Input::C)
        if @selectionMode
          x0,y0,x1,y1,w,h=getSelectionValues
          for ix in x0..x1
            for iy in y0..y1
              selected=pbGetSelected(ix,iy)
              pbSetSelected(selected,@autotag)
            end
          end
          @selectionMode=false
          @selection=[]
          updateMenu
          pbUpdateTileset
        else
          selected=pbGetSelected(@x,@y)
          pbSetSelected(selected,@autotag)
          pbUpdateTileset
        end
      end
    end
    ########
    pbFadeOutAndHide(@sprites)
    pbDisposeSpriteHash(@sprites)
    @viewport.dispose
    @tilehelper.dispose
  end
end



def pbTilesetScreen
  pbFadeOutIn(99999){
     scene=PokemonTilesetScene.new
     scene.pbStartScene
  }
end



rescue Exception
  if $!.is_a?(SystemExit) || "#{$!.class}"=="Reset"
    raise $!
  end
end