Menu Armonía v2

#===============================================================================
#                           Script : PokemonMenu_Scene
#                         Bezier - Privado Pokémon Armonia v2
#-------------------------------------------------------------------------------
#                 Creado para RPG Maker XP con base Essentials
#                           Compatible : versión 16.2
#===============================================================================

class PokemonMenu_Scene

  # --- VALORES MODIFICABLES ---

  TEXTCOLOR = Color.new(255, 255, 255)  # Color del texto
  SHADOWCOLOR = Color.new(0, 2, 22, 60) # Color de la sombra

  # Velocidades de movimiento de los paneles del menú
  ACCELERATION = [10, 6, 3]

  # --- CONSTANTES (NO MODIFICABLES) ---

  MENU_PATH = "Graphics/Pictures/Menu/"

  # Posiciones de los pokemon en el panel izquierdo
  POKEMON_Y = [ -5, 43, 91, 139, 187, 235 ]

  # Posiciones de los botones del panel derecho
  BT_Y = [ 0, 48, 96, 144, 192, 240, 288, 336 ]
  ICON_OFFSET_X = 42
  ICON_OFFSET_Y = 26

  # --- FUNCIONES ---

  # Añade los botones del menú derecho.
  # Para cambiar el orden, tan solo hay que mover las líneas addButton
  def addButtons()
    @buttons.clear()
    addButton("pokedex", "Pokédex") if $Trainer.pokedex
    addButton("pokemon", "Pokémon") if $Trainer.party.size > 0
    addButton("mochila", "Mochila")
    addButton("trainer", $Trainer.name)
    addButton("pc", "PC")
    addButton("album", "Álbum")
    addButton("guardar", "Guardar")
    addButton("ajustes", "Ajustes")
  end

  # Añade un sprite de pokémon i-esimo (animado) en la posición correspondiente
  # del menú izquierdo. Si ya existe un sprite para ese pokémon,
  # lo borra y lo reemplaza por uno nuevo, actualizando la vista
  def addPokemonSprite(i)
    return if !$Trainer

    menuIFrame = $Trainer.party.size == 0 ? 0 : @sprites["menuI"].bitmap.width / 2
    @sprites["menuI"].src_rect.set(menuIFrame, 0, @sprites["menuI"].bitmap.width / 2, @sprites["menuI"].bitmap.height)

    if i >= 0 && i < $Trainer.party.length
      poke = $Trainer.party[i]
      if @sprites["pk#{i}"]
        @sprites["pk#{i}"].dispose
        @sprites["pk#{i}"] = nil
      end

      pk = PokemonIconSprite.new(poke, @viewport)
      pk.x = @sprites["menuI"].x
      pk.y = POKEMON_Y[i]
      pk.z = 99999
      pk.mirror = true
      pk.active = true
      @sprites["pk#{i}"] = pk
    end
  end

  # Inicia la escena
  def pbStartScene
    pbSEPlay("menu",60)

    # Tiempo inicial para el refresco del menú cuando se avanza en el tiempo
    @initialTime = Graphics.frame_count / Graphics.frame_rate

    @sprites = {}     # Todos los sprites

    @selectedBtn = -1 # Índice del botón seleccionado

    pbSetViableDexes

    @viewport=Viewport.new(0,0,Graphics.width,Graphics.height)
    @viewport.z = 99999

    # Panel de la izquierda
    menuI = addSprite("menuI", -160, 0)
    menuIFrame = $Trainer.party.size == 0 ? 0 : menuI.bitmap.width / 2
    menuI.src_rect.set(menuIFrame, 0, menuI.bitmap.width / 2, menuI.bitmap.height)

    # Panel de la derecha
    menuD = addSprite("menuD", 512, 0)
    menuD.src_rect.set(0,0,menuD.bitmap.width/8,menuD.bitmap.height)

    # Botones de la derecha
    @buttons = []
    addButtons()

    # Imágenes de los estados alterados
    @statuses = AnimatedBitmap.new(_INTL("Graphics/Pictures/statuses"))

    # Añade los pokemon al panel izquierdo
    for i in 0...$Trainer.party.size
      addPokemonSprite(i)
    end

    # Bitmaps sobre los que se pintarán textos y otros elementos
    @sprites["overlayI"] = BitmapSprite.new(menuI.bitmap.width/2, menuI.bitmap.height, @viewport)
    @sprites["overlayI"].x = -160
    @sprites["overlayI"].z = 99999
    pbSetSystemFont(@sprites["overlayI"].bitmap)

    @sprites["overlayD"] = BitmapSprite.new(menuD.bitmap.width/8, menuD.bitmap.height, @viewport)
    @sprites["overlayD"].x = 512
    @sprites["overlayD"].z = 99999
    pbSetSystemFont(@sprites["overlayD"].bitmap)

    # Pinta los textos fuera de panalla para que estén visibles con la animación de entrada
    pbMenuTexts


    selectButton(0)   # Por defecto selecciona el primer botón

    speed = ACCELERATION[0] # Velocidad inicial de entrada del menú

    # Posisión máxima para el desplazamiento del panel derecho
    rightlimit = Graphics.width - menuD.bitmap.width / 8

    # Los paneles entran desde fuera de la ventana
    while menuI.x < 0 || menuD.x > rightlimit
      menuI.x += speed
      menuI.x = 0 if menuI.x > 0
      @sprites["overlayI"].x += speed
      @sprites["overlayI"].x = 0 if @sprites["overlayI"].x > 0

      for i in 0...$Trainer.party.size
        @sprites["pk#{i}"].x += speed
        @sprites["pk#{i}"].x = 0 if @sprites["pk#{i}"].x > 0
      end

      menuD.x -= speed
      menuD.x = rightlimit if menuD.x < rightlimit

      for i in 0...@buttons.size
        bt = @buttons[i]
        @sprites[bt[0]].x -= speed
        if i == @selectedBtn
          @sprites[bt[0]].x = 376 if @sprites[bt[0]].x < 376
        else
          @sprites[bt[0]].x = 394 if @sprites[bt[0]].x < 394
        end
      end

      @sprites["overlayD"].x -= speed
      @sprites["overlayD"].x = rightlimit if @sprites["overlayD"].x < rightlimit

      speed = ACCELERATION[1] if menuI.x >= -100
      speed = ACCELERATION[2] if menuI.x >= -20
      pbWait(1)
    end

    # Inicia el bucle del menú
    pbMenuLoop
  end # def pbStartScene

  # Añade un botón, con un identificador y el texto a mostrar
  def addButton(id, text)
    icon = addSprite(id, 512 + ICON_OFFSET_X, BT_Y[@buttons.size] + ICON_OFFSET_Y)
    icon.ox = icon.bitmap.width / 4
    icon.oy = icon.bitmap.height / 2
    icon.src_rect.set(0, 0, icon.bitmap.width / 2, icon.bitmap.height)
    @buttons << [id, text]
  end

  # Añade un sprite a la lista con unos valores concretos
  def addSprite(id, x, y, opacity=255, resource=nil)
    if !resource; resource = MENU_PATH + id; end
    @sprites[id] = Sprite.new(@viewport)
    @sprites[id].z = 99999
    @sprites[id].x = x
    @sprites[id].y = y
    @sprites[id].opacity = opacity
    @sprites[id].bitmap = BitmapCache.load_bitmap(resource)
    return @sprites[id]
  end

  # Selecciona un botón del panel derecho
  def selectButton(index)
    if @selectedBtn >= 0 && @selectedBtn != index
      @sprites[@buttons[@selectedBtn][0]].x += 18
      @sprites[@buttons[@selectedBtn][0]].src_rect.x = 0
    end
    @sprites["menuD"].src_rect.x = (@sprites["menuD"].bitmap.width / 8) * index
    @sprites[@buttons[index][0]].x -= 18
    @sprites[@buttons[index][0]].src_rect.x = 36
    @selectedBtn = index
    pbSEPlay("Select",60)
    pbMenuTexts
  end # def selectButton(index)

  # Actualiza la escena
  def update
    Graphics.update
    Input.update

    # Anima los pokemon
    for i in 0...$Trainer.party.size
      @sprites["pk#{i}"].update if @sprites["pk#{i}"]
    end

    # Gestiona el paso del tiempo para repintar el menu
    inimin = @initialTime / 60 % 60
    totalsec = Graphics.frame_count / Graphics.frame_rate
    min = totalsec / 60 % 60
    if min != inimin
      pbMenuTexts
      @initialTime = totalsec
    end
  end

  # Pinta los textos y los extras de los pokemon
  def pbMenuTexts
    bmpI = @sprites["overlayI"].bitmap
    bmpI.clear
    pbSetSystemFont(bmpI)
    bmpI.font.size -= 4
    textsI = []

    if $Trainer.party.size > 0
      for i in 0...$Trainer.party.size
        poke = $Trainer.party[i]
        lvl = _INTL("Lvl. {1}", poke.level)
        textsI << [lvl, 65, POKEMON_Y[i] + 20, 0, TEXTCOLOR, SHADOWCOLOR]

        backcolor = poke.hp == 0 ? Color.new(0, 0, 0) : Color.new(255, 255, 255)
        bmpI.fill_rect(65, POKEMON_Y[i] + 52, 60, 8, backcolor)

        if poke.hp > 0
          hpgauge = poke.hp * 60 / poke.totalhp
          hpgauge = 1 if hpgauge <= 0

          hpcolors=[
             PokeBattle_SceneConstants::HPCOLORGREENDARK,
             PokeBattle_SceneConstants::HPCOLORGREEN,
             PokeBattle_SceneConstants::HPCOLORYELLOWDARK,
             PokeBattle_SceneConstants::HPCOLORYELLOW,
             PokeBattle_SceneConstants::HPCOLORREDDARK,
             PokeBattle_SceneConstants::HPCOLORRED
          ]

          hpzone=0
          hpzone=1 if poke.hp<=(poke.totalhp/8*7).floor
          hpzone=2 if poke.hp<=(poke.totalhp/8*6).floor
          hpzone=3 if poke.hp<=(poke.totalhp/2).floor
          hpzone=4 if poke.hp<=(poke.totalhp/4).floor
          hpzone=5 if poke.hp<=(poke.totalhp/8).floor

          bmpI.fill_rect(65, POKEMON_Y[i] + 52,hpgauge,8,hpcolors[hpzone])
        end

        if poke.hp == 0 || poke.status > 0
          status = (poke.hp == 0) ? 5 : poke.status - 1
          bmpI.blt(12, POKEMON_Y[i] + 48, @statuses.bitmap,
                   Rect.new(0, status * 16, 44, 16))
        end
      end
    end

    totalsec = Graphics.frame_count / Graphics.frame_rate
    hour = totalsec / 60 / 60
    min = totalsec / 60 % 60

    textsI << [_INTL("Medallas: {1}",$Trainer.numbadges), 3, 302, 0, TEXTCOLOR, SHADOWCOLOR]
    textsI << [_ISPRINTF("Juego: {1:02d}:{2:02d}",hour,min), 3, 329, 0, TEXTCOLOR, SHADOWCOLOR]
    textsI << [_INTL("Dinero: ${1}",$Trainer.money), 3, 356, 0, TEXTCOLOR, SHADOWCOLOR]

    pbDrawTextPositions(bmpI, textsI)


    bmpD = @sprites["overlayD"].bitmap
    bmpD.clear
    textsD = []
    for i in 0...@buttons.size
      bt = @buttons[i]
      x = i == @selectedBtn ? 50 : 68
      textsD << [bt[1], x, BT_Y[i] + 10, 0, TEXTCOLOR, SHADOWCOLOR]
    end
    pbDrawTextPositions(bmpD, textsD)
  end

  # Bucle principal del menú
  def pbMenuLoop
    loop do
      self.update # Actualiza los elementos que tengan animaciones permanentes
      result = self.pbMenuInput # Captura los inputs y devuelve el resultado

      # Si el resultado del input es -1, cierra el menú
      if result == -1
        pbEndScene
        break
      end
    end
  end

  # Gestiona las teclas pulsadas
  def pbMenuInput
    # Selección de botón
    if Input.trigger?(Input::UP)
      if @selectedBtn > 0
        selectButton(@selectedBtn - 1)
      else
        selectButton(@buttons.size - 1)
      end
    elsif Input.trigger?(Input::DOWN)
      if @selectedBtn < @buttons.size - 1
        selectButton(@selectedBtn + 1)
      else
        selectButton(0)
      end
    end

    if Input.trigger?(Input::B)
      return -1
    end
     if Input.trigger?(Input::C)
      bt = @buttons[@selectedBtn][0]
      case bt
      when "mochila"
        self.bag
      when "pokemon"
        if $Trainer.party.length > 0
         self.pokemonParty
        end
      when "guardar"
        self.save
      when "trainer"
        self.trainerCard
      when "pc"
          self.pc
      when "pokedex"
        if $Trainer.pokedex
          self.pokeDex
        end
      when "album"
        self.album
      when "ajustes"
        self.options
      end
    end

    return 0
  end # def pbMenuInput

  # Cierra el menú. Destruye todos los elementos y vuelve al juego
  def pbEndScene
    pbSEPlay("menu",60)

    speed = ACCELERATION[2]
    while @sprites["menuI"].x > -160 || @sprites["menuD"].x < 512
      @sprites["menuI"].x -= speed
      @sprites["overlayI"].x -= speed
      for i in 0...$Trainer.party.size
        @sprites["pk#{i}"].x -= speed
      end
      @sprites["menuD"].x += speed
      for i in 0...@buttons.size
        bt = @buttons[i]
        @sprites[bt[0]].x += speed
      end
      @sprites["overlayD"].x += speed

      speed = ACCELERATION[1] if @sprites["menuI"].x <= -20
      speed = ACCELERATION[0] if @sprites["menuI"].x <= -100
      pbWait(1)
    end

    pbDisposeSpriteHash(@sprites)
    @viewport.dispose
  end

  # --- MENU WINDOWS ---

  def bag
    pbSEPlay("Choose")
    item=0
    scene=PokemonBag_Scene.new
    screen=PokemonBagScreen.new(scene,$PokemonBag)
    pbFadeOutIn(99999) {
      item=screen.pbStartScreen
      if item>0
        pbEndScene
      else
        pbRefresh
      end
    }
    if item>0
      Kernel.pbUseKeyItemInField(item)
      return
    end
  end

  def pokemonParty
    pbSEPlay("Choose")
    sscene=PokemonScreen_Scene.new
    sscreen=PokemonScreen.new(sscene,$Trainer.party)
    hiddenmove=nil
    pbFadeOutIn(99999) {
    hiddenmove=sscreen.pbPokemonScreen
    updateMenus
    if hiddenmove
      pbEndScene
    end
    }
    if hiddenmove
      Kernel.pbUseHiddenMove(hiddenmove[0],hiddenmove[1])
      return
    end

  end

  def updateMenus
    for i in 0...6
      if i < $Trainer.party.size
        addPokemonSprite(i) # if !@sprites["pk#{i}"]
        @sprites["pk#{i}"].update
      else
        @sprites["pk#{i}"].visible = false if @sprites["pk#{i}"]
      end
    end
    pbMenuTexts
  end

  def pc
    pbSEPlay("computeropen")
    Kernel.pbMessage(_INTL("Acceso al Sistema de Almacenamiento de Pokémon concedido."))
    scene=PokemonStorageScene.new
    screen=PokemonStorageScreen.new(scene,$PokemonStorage)
    screen.pbStartScreen(2) # Es 2 porque es para mover
    updateMenus
    pbSEPlay("computerclose")
  end

  def pokeDex
    pbSEPlay("Choose")
    if DEXDEPENDSONLOCATION
          pbFadeOutIn(99999) {
             scene=PokemonPokedexScene.new
             screen=PokemonPokedex.new(scene)
             screen.pbStartScreen
             @scene.pbRefresh
          }
    else
      if $PokemonGlobal.pokedexViable.length==1
            $PokemonGlobal.pokedexDex=$PokemonGlobal.pokedexViable[0]
            $PokemonGlobal.pokedexDex=-1 if $PokemonGlobal.pokedexDex==$PokemonGlobal.pokedexUnlocked.length-1
            pbFadeOutIn(99999) {
            scene=PokemonPokedexScene.new
            screen=PokemonPokedex.new(scene)
            screen.pbStartScreen
        }
      else
        pbLoadRpgxpScene(Scene_PokedexMenu.new)
      end
    end
  end

  def trainerCard
    pbSEPlay("Choose")
    PBDebug.logonerr {
      scene=PokemonTrainerCardScene.new
      screen=PokemonTrainerCard.new(scene)
      pbFadeOutIn(99999) {
        screen.pbStartScreen
      }
    }
  end

  def save
    pbSEPlay("Choose")
    scene=PokemonSaveScene.new
    screen=PokemonSave.new(scene)
    screen.pbSaveScreen
  end

  def album
    pbSEPlay("Choose")
    pbFadeOutIn(99999) {
      AlbumScene.new.pbPage1
      pbUpdateSceneMap
    }
  end

  def options
    pbSEPlay("Choose")
    scene=PokemonOptionScene.new
      screen=PokemonOption.new(scene)
      pbFadeOutIn(99999) {
      screen.pbStartScreen

      pbMenuTexts

      pbUpdateSceneMap
      }
  end
end

class PokemonMenu
  def pbShowMenu
    @scene.pbShowMenu
  end

  def pbStartPokemonMenu
    @scene.pbStartScene
  end
end