# =============================================== ==============================
#
# ------------------------------------------------- ------------------------------
# ------------------------------------------------- ------------------------------
# Script: Multiple Games 5.0
# by JessWishes
# ------------------------------------------------- ------------------------------
# ------------------------------------------------- ------------------------------
# Created for RPG Maker XP with Essentials base
# Compatible: version 17
# Not tested with 16 or less.
# ------------------------------------------------- ------------------------------
#
# ------------------------------------------------- ------------------------------
# DevianArt:
# https://www.deviantart.com/jesswshs
#
# Twitter:
# https://twitter.com/JessWishes
#
# Resource Page
# https://jesswishesdev.weebly.com
#
# ------------------------------------------------- ------------------------------
#
# ------------------------------------------------- ------------------------------
# This has taken time and effort to design, although it is free to use,
# credit is appreciated.
#
# ------------------------------------------------- ------------------------------
#
# ------------------------------------------------- ------------------------------
# How to use
#
# Copy and paste in a new script above the one called Main.
#
# 1.-Once the first game is saved, the folder that will contain
# the files
#
# 2.-When starting a new game, the first time it is saved, it will be done in a
# new file and when saving again, it will ask you if you want that
# file is overwritten, otherwise a new one will be created.
#
# 3.-When you reach the maximum number of games, you will get the message to
# notify the player.
#
# 4.-Being on the loading screen, you can delete the selected game
# by pressing the Z key (Input :: A).
#
# 5.-To avoid performance reduction, only the item selected in the
# The loading screen will show the character image and the icons of the
# team.
#
# 6.-To force the game to be saved automatically, use the
# next function: pbJessAutoSave
# You can return the result; true if saved or false if not saved
# could save.
#
# ------------------------------------------------- ------------------------------
# Global Variables
# ------------------------------------------------- ------------------------------
# Name of the files to save.
PARTNAME = "Partida_JessWishes"

# Name of the folder that will contain the files to save.
DIR_PARTIDA = "Save"

# Maximum number of games
N_MX_PARTIDA = 10

# When starting a new game it will let you select a different language.
LENG_JESS = false

# List of available languages.
# the LANGUAGES variable in the Settings section should not be used to avoid
# possible errors with the compiler.
LANGUAGES = [
  ["Spanish", "messages.dat"],
 ["English", "leng-2.dat"]
]
# ------------------------------------------------- ------------------------------
#
# ------------------------------------------------- ------------------------------
#
# ------------------------------------------------- ------------------------------
#
# ------------------------------------------------- ------------------------------
#
# ------------------------------------------------- ------------------------------
#
# ------------------------------------------------- ------------------------------
#
# ------------------------------------------------- ------------------------------
#
# ------------------------------------------------- ------------------------------
# Address where the games will be saved.
# ------------------------------------------------- ------------------------------
RTP module

  def self.getSaveFileName (fileName)
    Dir.mkdir (DEPARTMENT DIR) unless File.exists? (DEPARTMENT DIR)
    return DEPART_DIR + "/" + fileName
  end

end
# ------------------------------------------------- ------------------------------
# Temporal variable in which the name of the current game will be saved.
# ------------------------------------------------- ------------------------------
class Game_Temp
  attr_accessor: saved file
end
# ------------------------------------------------- ------------------------------
# Save Game (s).
# ------------------------------------------------- ------------------------------

#Autosave
def pbJessAutoSave
  Kernel.pbMessage (_INTL ("Saving Game ... \\ wtnp [10]"))
  mx = false
  for i in 1..N_MX_PARTIDA
    sv = "# {PARTNAME} # {i}"; sv2 = sv + ". rxdata"
    break if! safeExists? (RTP.getSaveFileName (sv2))
    mx = true if i == N_MX_GAME &&! $ game_temp.savedfile
  end
  $ game_temp.savedfile = sv if! $ game_temp.savedfile && mx == false
  if mx == true
    Kernel.pbMessage (_INTL ("You have reached your save game limit \ nYou won't be able to save a new game"))
    return false
  else
    pbSave (false, $ game_temp.savedfile)
    Kernel.pbMessage (_INTL ("\\ me [GUI save game] The current game has been saved"))
    return true
  end
end


def pbSave (safesave = false, file = PARTYNAME)
  $ Trainer.metaID = $ PokemonGlobal.playerID
  begin
    File.open (RTP.getSaveFileName ("# {file} .rxdata"), "wb") {| f |
       Marshal.dump ($ Trainer, f)
       Marshal.dump (Graphics.frame_count, f)
       if $ data_system.respond_to? ("magic_number")
         $ game_system.magic_number = $ data_system.magic_number
       else
         $ game_system.magic_number = $ data_system.version_id
       end
       $ game_system.save_count + = 1
       Marshal.dump ($ game_system, f)
       Marshal.dump ($ PokemonSystem, f)
       Marshal.dump ($ game_map.map_id, f)
       Marshal.dump ($ game_switches, f)
       Marshal.dump ($ game_variables, f)
       Marshal.dump ($ game_self_switches, f)
       Marshal.dump ($ game_screen, f)
       Marshal.dump ($ MapFactory, f)
       Marshal.dump ($ game_player, f)
       $ PokemonGlobal.safesave = safesave
       Marshal.dump ($ PokemonGlobal, f)
       Marshal.dump ($ PokemonMap, f)
       Marshal.dump ($ PokemonBag, f)
       Marshal.dump ($ PokemonStorage, f)
    }
    Graphics.frame_reset
  rescue
    return false
  end
  return true
end

# ------------------------------------------------- ------------------------------
# In case of error it will save the current game in the Backup file.rxdata
# ------------------------------------------------- ------------------------------
def pbEmergencySave
  oldscene = $ scene
  $ scene = nil
  Kernel.pbMessage (_INTL ("The script is taking a long time, the game will restart."))
  return if! $ Trainer
  if safeExists? (RTP.getSaveFileName ("Backup.rxdata"))
    File.open (RTP.getSaveFileName ("Backup.rxdata"), 'rb') {| r |
      File.open (RTP.getSaveFileName ("Backup.rxdata.bak"), 'wb') {| w |
        while s = r.read (4096)
          w.write s
        end
      }
    }
  end
  if pbSave (false, "Backup")
    Kernel.pbMessage (_INTL ("The game has been saved as Backup.rxdata. \\ me [GUI save game] \\ wtnp [30]"))
  else
    Kernel.pbMessage (_INTL ("\\ se [] There was an error saving the file ... \\ wtnp [30]"))
  end
  $ scene = oldscene
end

# ------------------------------------------------- ------------------------------
# Save screen
# ------------------------------------------------- ------------------------------
class PokemonSaveScreen

 def pbSaveScreen
    ret = false
    result = 0 # New Game
    files = []
    n = 0
    for i in 1..N_MX_PARTIDA
      files.push ("# {PARTNAME} # {i}") if safeExists? (RTP.getSaveFileName ("# {PARTNAME} # {i} .rxdata"))
      next if n> 0
      n = i if! safeExists? (RTP.getSaveFileName ("# {PARTNAME} # {i} .rxdata"))
    end
    @ scene.pbStartScreen
    if Kernel.pbConfirmMessage (_INTL ("Would you like to save the game?"))
       #See if there is a saved game

       if files.size> 0 &&! $ PokemonTemp.begunNewGame
          result = 1 # is not a new item
          Kernel.pbMessage (_INTL ("A saved game already exists!"))
            if Kernel.pbConfirmMessage (_INTL ("Overwrite current game?"))
                result = 2 #Overwrite
            end
        end
        $ PokemonTemp.begunNewGame = false
        if files.size == N_MX_PARTIDA && results! = 2
          Kernel.pbMessage (_INTL ("You have reached the maximum number of saved games!"))
          Kernel.pbMessage (_INTL ("\\ se [] Could not save. \\ wtnp [30]"))
        else
          save = "# {PARTNAME} # {n}" #New file
          save = $ game_temp.file saved if result == 2 #Current file
          if pbSave (false, save)
            Kernel.pbMessage (_INTL ("The game has been saved. \\ me [GUI save game] \\ wtnp [30]")) if results == 0
            Kernel.pbMessage (_INTL ("Saved in a new game. \\ me [GUI save game] \\ wtnp [30]")) if results == 1
            Kernel.pbMessage (_INTL ("Game was overwritten. \\ me [GUI save game] \\ wtnp [30]")) if result == 2
            if files.size == N_MX_PARTIDA && results! = 2
              Kernel.pbMessage (_INTL ("You have reached the maximum number of saved games, you will be able to overwrite existing ones but you will not be able to save new ones until you delete any of the previous ones."))
            end
            ret = true
            $ game_temp.archivoguardado = save #Define current file
          else
            Kernel.pbMessage (_INTL ("\\ se [] Could not save. \\ wtnp [30]"))
            ret = false
          end
        end
    end
    @ scene.pbEndScreen
    return ret
  end

end

# ------------------------------------------------- ------------------------------
# Load game (s)
# ------------------------------------------------- ------------------------------
class PokemonLoadScreen

  #Removing the Essentials method to delete games.
  def pbStartDeleteScreen; end


  def pbReadinfosave (savefile)
      trainer = nil
      framecount = 0
      mapid = 0
      @haveBackup = false
     begin
     trainer, framecount, $ game_system, $ PokemonSystem, mapid = pbTryLoadFile (savefile)
     rescue
     if safeExists? (savefile + ". bak")
       begin
       trainer, framecount, $ game_system, $ PokemonSystem, mapid = pbTryLoadFile (savefile + ". bak")
       @haveBackup = true
       rescue
       end
     end
     if @haveBackup
       Kernel.pbMessage (_INTL ("The save file is corrupt. The previous save file will be loaded."))
     else
      Kernel.pbMessage (_INTL ("The save file is corrupt, or is incompatible with this game."))
      if! Kernel.pbConfirmMessageSerious (_INTL ("Do you want to delete the save file and start anew?"))
        $ scene = nil
        return
      end
      begin; File.delete (savefile); rescue; end
      begin; File.delete (savefile + ". Bak"); rescue; end
      $ game_system = Game_System.new
      $ PokemonSystem = PokemonSystem.new if! $ PokemonSystem
      Kernel.pbMessage (_INTL ("The save file was deleted."))
     end
   end
   return [trainer, framecount, $ game_system, $ PokemonSystem, mapid]
  end

  def pbcarga ()
    files = []
    savefile = []
    for i in 1..N_MX_PARTIDA
      files.push ("# {PARTNAME} # {i}") if safeExists? (RTP.getSaveFileName ("# {PARTNAME} # {i} .rxdata"))
      savefile.push (RTP.getSaveFileName ("# {PARTNAME} # {i} .rxdata")) if safeExists? (RTP.getSaveFileName ("# {PARTNAME} # {i} .rxdata"))
    end
    return [files, savefile]
  end

  def pbStartLoadScreen
    $ PokemonTemp = PokemonTemp.new
    $ game_temp = Game_Temp.new
    $ game_system = Game_System.new
    $ PokemonSystem = PokemonSystem.new if! $ PokemonSystem

    data = pbcarga
    files = data [0]
    savefile = data [1]

    FontInstaller.install

    data_system = pbLoadRxData ("Data / System")
    mapfile = ($ RPGVX)? sprintf ("Data / Map% 03d.rvdata", data_system.start_map_id):
                         sprintf ("Data / Map% 03d.rxdata", data_system.start_map_id)
    if data_system.start_map_id == 0 || ! pbRgssExists? (mapfile)
      Kernel.pbMessage (_INTL ("No starting position was set in the map editor. \ 1"))
      Kernel.pbMessage (_INTL ("The game cannot continue."))
      @ scene.pbEndScene
      $ scene = nil
      return
    end

    commands = []
    cmdContinue = []
    command = []

    for i in 0..savefile.size-1
      cmd Continue [i] = -1
      command.push ("cmdContinue # {i}")
    end

    cmdNewGame = -1
    cmdOption = -1
    cmdMysteryGift = -1
    cmdDebug = -1
    cmdQuit = -1

    showContinue = []
    showContinue.push (false)

    for i in 1..N_MX_PARTIDA
      showContinue.push (true) if safeExists? (RTP.getSaveFileName ("# {PARTNAME} # {i} .rxdata"))
    end

    if savefile.size> 0
      data = pbLeerinfosave (savefile [0])
      trainer = data [0]; framecount = data [1]; $ game_system = data [2]; $ PokemonSystem = data [3]; mapid = data [4]
      showContinue [0] = true if trainer
      if showContinue [0] == true
        if! @haveBackup
          begin; File.delete (savefile [0] + ". Bak"); rescue; end
        end
      end
      for i in 0..cmdContinue.size-1
         commands [command [i] = commands.length] = _INTL ("Item # {i + 1}") if showContinue [i] == true
      end
    end
    commands [cmdNewGame = commands.length] = _INTL ("New Game")
    commands [cmdMysteryGift = commands.length] = _INTL ("Mystery Gift") if (trainer.mysterygiftaccess rescue false)
    commands [cmdOption = commands.length] = _INTL ("Options")
    commands [cmdDebug = commands.length] = _INTL ("Debug") if $ DEBUG
    commands [cmdQuit = commands.length] = _INTL ("Close Game")

    trainerlist = []
    framelist = []
    maplist = []
    for k in 0 ... files.size
      datatt = pbLeerinfosave (savefile [k])
      trainerlist.push (datatt [0])
      framelist.push (datatt [1])
      maplist.push (datatt [4])
    end

    @ scene.pbStartScene (commands, showContinue [0], trainer, framecount, mapid, cmdContinuar.size, trainerlist, framelist, maplist)
    @ scene.pbSetParty (trainer) if showContinue [0]
    @ scene.pbStartScene2
    $ ItemData = readItemList ("Data / items.dat")
    loop do
      command2 = @ scene.pbChoose (commands)
      command = command2 [0]

       if (command2 [1] == "upd" || command2 [1] == "dwd")
         @ scene.pbSetParty (trainer, false)
         if command <files.size
            data = pbLeerinfosave (savefile [command])
            trainer = data [0]; framecount = data [1]; $ game_system = data [2]; $ PokemonSystem = data [3]; mapid = data [4]
            @ scene.pbSetParty (trainer) if showContinue [command]

         end

      elsif command2 [1] == "delete"
        if command <files.size
        if safeExists? (savefile [command]) && command.include? (command)
           if Kernel.pbConfirmMessage (_INTL ("Delete this heading?"))
              Kernel.pbMessage (_INTL ("If you delete it, all the information in it will be lost."))
              if Kernel.pbConfirmMessage (_INTL ("Delete anyway?"))
                 begin; File.delete (savefile [command]); rescue; end
                 begin; File.delete (savefile [command] + ". Bak"); rescue; end
                 Kernel.pbMessage (_INTL ("This game has been removed."))
                 files.delete_at (command)
                 command.delete_at (command)
                 @ scene.pbEndScene
                 sscene = PokemonLoad_Scene.new
                 sscreen = PokemonLoadScreen.new (sscene)
                 sscreen.pbStartLoadScreen
                 break
              end
            end
          end
        end
      elsif command.include? (command)
        for i in 0..savefile.size-1
          savefile2 = savefile [i] if command == command [i]
          n = i + 1 if command == command [i]
        end

       # Determine the name of this game
        nmb_j = (files [n-1] == PARTNAME)? "# {PARTNAME} # {n}": files [n-1]
        $ game_temp.savedfile = nmb_j
       #
        unless safeExists? (savefile2)
          pbPlayBuzzerSE
          next
        end
        @ scene.pbEndScene
        metadata = nil
       File.open (savefile2) {| f |
          $ Trainer = Marshal.load (f) # Trainer already loaded
          Graphics.frame_count = Marshal.load (f)
          $ game_system = Marshal.load (f)
          $ PokemonSystem = Marshal.load (f)
          Marshal.load (f) # Current map id no longer needed
          $ game_switches = Marshal.load (f)
          $ game_variables = Marshal.load (f)
          $ game_self_switches = Marshal.load (f)
          $ game_screen = Marshal.load (f)
          $ MapFactory = Marshal.load (f)
          $ game_map = $ MapFactory.map
          $ game_player = Marshal.load (f)
          $ PokemonGlobal = Marshal.load (f)
          metadata = Marshal.load (f)
          $ PokemonBag = Marshal.load (f)
          $ PokemonStorage = Marshal.load (f)
          magicNumberMatches = false
          if $ data_system.respond_to? ("magic_number")
            magicNumberMatches = ($ game_system.magic_number == $ data_system.magic_number)
          else
            magicNumberMatches = ($ game_system.magic_number == $ data_system.version_id)
          end
          if! magicNumberMatches || $ PokemonGlobal.safesave
            if pbMapInterpreterRunning?
              pbMapInterpreter.setup (nil, 0)
            end
            begin
              $ MapFactory.setup ($ game_map.map_id) # calls setMapChanged
            rescue Errno :: ENOENT
              if $ DEBUG
                Kernel.pbMessage (_INTL ("Map {1} was not found.", $ Game_map.map_id))
                map = pbWarpToMap
                if map
                  $ MapFactory.setup (map [0])
                  $ game_player.moveto (map [1], map [2])
                else
                  $ game_map = nil
                  $ scene = nil
                  return
                end
              else
                $ game_map = nil
                $ scene = nil
                Kernel.pbMessage (_INTL ("The map was not found. The game cannot continue."))
              end
            end
            $ game_player.center ($ game_player.x, $ game_player.y)
          else
            $ MapFactory.setMapChanged ($ game_map.map_id)
          end
        }
        if! $ game_map.events # Map wasn't set up
          $ game_map = nil
          $ scene = nil
          Kernel.pbMessage (_INTL ("The map is corrupt. The game cannot continue."))
          return
        end
        $ PokemonMap = metadata
        $ PokemonEncounters = PokemonEncounters.new
        $ PokemonEncounters.setup ($ game_map.map_id)
        pbAutoplayOnSave
        $ game_map.update
        $ PokemonMap.updateMap
        $ scene = Scene_Map.new

        $ PokemonSystem.language = 0 if $ PokemonSystem.language> LANGUAGES.size-1

        pbLoadMessages ("Data /" + LANGUAGES [$ PokemonSystem.language] [1]) if LENG_JESS

        return
      elsif cmdNewGame> = 0 && command == cmdNewGame
        @ scene.pbEndScene

        if LENG_JESS
          $ PokemonSystem.language = pbChooseLanguage
          pbLoadMessages ("Data /" + LANGUAGES [$ PokemonSystem.language] [1])
        end

        if $ game_map && $ game_map.events
          for event in $ game_map.events.values
            event.clear_starting
          end
        end
        $ game_temp.common_event_id = 0 if $ game_temp
        $ scene = Scene_Map.new
        Graphics.frame_count = 0
        $ game_system = Game_System.new
        $ game_switches = Game_Switches.new
        $ game_variables = Game_Variables.new
        $ game_self_switches = Game_SelfSwitches.new
        $ game_screen = Game_Screen.new
        $ game_player = Game_Player.new
        $ PokemonMap = PokemonMapMetadata.new
        $ PokemonGlobal = PokemonGlobalMetadata.new
        $ PokemonStorage = PokemonStorage.new
        $ PokemonEncounters = PokemonEncounters.new
        $ PokemonTemp.begunNewGame = true
        $ data_system = pbLoadRxData ("Data / System")
        $ MapFactory = PokemonMapFactory.new ($ data_system.start_map_id) # calls setMapChanged
        $ game_player.moveto ($ data_system.start_x, $ data_system.start_y)
        $ game_player.refresh
        $ game_map.autoplay
        $ game_map.update
        return
      elsif cmdMysteryGift> = 0 && command == cmdMysteryGift
        pbFadeOutIn (99999) {
          trainer = pbDownloadMysteryGift (trainer)
        }
      elsif cmdOption> = 0 && command == cmdOption
        pbFadeOutIn (99999) {
          scene = PokemonOption_Scene.new
          screen = PokemonOptionScreen.new (scene)
          screen.pbStartScreen (true)
        }
      elsif cmdDebug> = 0 && command == cmdDebug
        pbFadeOutIn (99999) {pbDebugMenu (false)}
      elsif cmdQuit> = 0 && command == cmdQuit
        @ scene.pbEndScene
        $ scene = nil
        return
      end
    end
    @ scene.pbEndScene
    return
  end
end

# ------------------------------------------------- ------------------------------
# Loading screen (visual)
# ------------------------------------------------- ------------------------------
class PokemonLoad_Scene

  def pbUpdate
    oldi = @sprites ["cmdwindow"]. index rescue 0
    pbUpdateSpriteHash (@sprites)
    newi = @sprites ["cmdwindow"]. index rescue 0
    if oldi! = newi
      @sprites ["panel # {oldi}"]. selected = false
      @sprites ["panel # {oldi}"]. pbRefresh
      @sprites ["panel # {newi}"]. selected = true
      @sprites ["panel # {newi}"]. pbRefresh

      sy = @ sprites ["panel # {newi}"]. bitmap.height + 2
      mov = (newi> oldi)
      fv = (@ mxpartidas * sy)

      for i in 0 ... @ commands.length
        if newi == 0
          @sprites ["panel # {i}"]. y = @ bsy [i]
        elsif newi> oldi && newi! = oldi + 1
          @sprites ["panel # {i}"]. y- = fv
        else
         @sprites ["panel # {i}"]. y- = sy if mov && newi <@ mxpartidas + 1
         @sprites ["panel # {i}"]. y + = sy if! mov && newi <@mxpartidas
        end
      end
    end
  end

  def pbSetParty (trainer, val = true)
    @sprites ["player"]. dispose if @sprites ["player"]
    for i in 0..6; @sprites ["party # {i}"]. dispose if @sprites ["party # {i}"]; end
    return if! trainer || ! trainer.party || val == false
    meta = pbGetMetadata (0, MetadataPlayerA + trainer.metaID)
    if meta
      filename = pbGetPlayerCharset (meta, 1, trainer)
      @sprites ["player"] = TrainerWalkingCharSprite.new (filename, @ viewport)
      charwidth = @sprites ["player"]. bitmap.width
      charheight = @sprites ["player"]. bitmap.height
      @sprites ["player"]. x = 56 * 2-charwidth / 8
      @sprites ["player"]. y = 56 * 2-charheight / 8
      @sprites ["player"]. src_rect = Rect.new (0,0, charwidth / 4, charheight / 4)
    end
    for i in 0 ... trainer.party.length
      @sprites ["party # {i}"] = PokemonIconSprite.new (trainer.party [i], @ viewport)
      @sprites ["party # {i}"]. x = 151 * 2 + 33 * 2 * (i & 1)
      @sprites ["party # {i}"]. y = 36 * 2 + 25 * 2 * (i / 2)
      @sprites ["party # {i}"]. z = 99999
    end
  end

  def pbStartScene (commands, showContinue, trainer, framecount, mapid, mxpartidas, trainerlist, framelist, maplist)
    @ trainerlist = trainerlist
    @ mxpartidas = mxpartidas
    @commands = commands
    @sprites = {}
    @viewport = Viewport.new (0,0, Graphics.width, Graphics.height)
    @ viewport.z = 99998
    addBackgroundOrColoredPlane (@sprites, "background", "loadbg", Color.new (248,248,248), @ viewport)
    y = 16 * 2
    @ bsy = []
    for i in 0 ... commands.length
      @sprites ["panel # {i}"] = PokemonLoadPanel.new (i, commands [i],
         (showContinue && i <@mxpartidas)? true: false, trainerlist [i], framelist [i], maplist [i], @ viewport)
      @sprites ["panel # {i}"]. x = 24 * 2
      @sprites ["panel # {i}"]. y = y
      @sprites ["panel # {i}"]. pbRefresh
      @ bsy.push (y)
      y + = (showContinue && i <@mxpartidas)? 111 * 2 + 1 * 2: 23 * 2 + 1 * 2
    end
    @sprites ["cmdwindow"] = Window_CommandPokemon.new ([])
    @sprites ["cmdwindow"]. viewport = @viewport
    @sprites ["cmdwindow"]. visible = false
  end

  def pbactu (commands, trainer, framecount, mapid)

    for i in 0 ... commands.length
    @sprites ["panel # {i}"]. pbactu (trainer [i], framecount, mapid)
    end
  end

  def pbChoose (commands)
    @sprites ["cmdwindow"]. commands = commands
    loop do
      Graphics.update
      Input.update
      pbUpdate
      if Input.trigger? (Input :: C)
        return [@sprites ["cmdwindow"]. index, "sel"]
      elsif Input.trigger? (Input :: A)
        return [@sprites ["cmdwindow"]. index, "delete"]
      elsif Input.trigger? (Input :: UP)
        return [@sprites ["cmdwindow"]. index, "upd"]
      elsif Input.trigger? (Input :: DOWN)
        return [@sprites ["cmdwindow"]. index, "dwd"]
      end
    end
  end

end
# ------------------------------------------------- ------------------------------
# Panels
# ------------------------------------------------- ------------------------------
class PokemonLoadPanel <SpriteWrapper
  attr_reader: selected

  def initialize (index, title, isContinue, trainer, framecount, mapid, viewport = nil)
    super (viewport)
    @ viewport = viewport
    @ trainer = trainer
    @index = index
    @title = title
    @isContinue = isContinue
    @trainer = trainer
    @totalsec = (framecount || 0) /Graphics.frame_rate
    @mapid = mapid
    @selected = (index == 0)
    @bgbitmap = AnimatedBitmap.new ("Graphics / Pictures / loadPanels")
    @refreshBitmap = true
    @refreshing = false
    refresh
  end

  def dispose
    @ bgbitmap.dispose
    self.bitmap.dispose
    super
  end

  def selected = (value)
    if @selected! = value
      @selected = value
      @refreshBitmap = true
      refresh
    end
  end

  def pbactu (trainer, framecount, mapid)
    @ trainer = trainer
    @ mapid = mapid
    @totalsec = (framecount || 0) /Graphics.frame_rate
    refresh
  end

  def pbRefresh
    @refreshBitmap = true
    refresh
  end

  def refresh
    return if @refreshing
    return if disposed?
    @refreshing = true
    if! self.bitmap || self.bitmap.disposed?
      self.bitmap = BitmapWrapper.new (@ bgbitmap.width, 111 * 2)
      pbSetSystemFont (self.bitmap)
    end
    if @refreshBitmap
      @refreshBitmap = false
      self.bitmap.clear if self.bitmap

      if @isContinue
        self.bitmap.blt (0,0, @ bgbitmap.bitmap, Rect.new (0, (@ selected)? 111 * 2: 0, @ bgbitmap.width, 111 * 2))
      else
        self.bitmap.blt (0,0, @ bgbitmap.bitmap, Rect.new (0,111 * 2 * 2 + ((@ selected)? 23 * 2: 0), @ bgbitmap.width, 23 * 2))
      end
      textpos = []
      if @isContinue
        textpos.push ([@ title, 16 * 2.5 * 2.0, Color.new (232,232,232), Color.new (136,136,136)])
        textpos.push ([_ INTL ("Medals:"), 16 * 2.56 * 2.0, Color.new (232,232,232), Color.new (136,136,136)])
        textpos.push ([@ trainer.numbadges.to_s, 103 * 2.56 * 2.1, Color.new (232,232,232), Color.new (136,136,136)])
        textpos.push ([_ INTL ("Pokédex:"), 16 * 2.72 * 2.0, Color.new (232,232,232), Color.new (136,136,136)])
        textpos.push ([@ trainer.pokedexSeen.to_s, 103 * 2.72 * 2.1, Color.new (232,232,232), Color.new (136,136,136)])
        textpos.push ([_ INTL ("Time:"), 16 * 2.88 * 2.0, Color.new (232,232,232), Color.new (136,136,136)])
        hour = @totalsec / 60/60
        min = @totalsec / 60% 60
        if hour> 0
          textpos.push ([_ INTL ("{1} h {2} m", hour, min), 103 * 2.88 * 2.1, Color.new (232,232,232), Color.new (136,136,136)])
        else
          textpos.push ([_ INTL ("{1} m", min), 103 * 2.88 * 2.1, Color.new (232,232,232), Color.new (136,136,136)])
        end
        if @ trainer.isMale?
          textpos.push ([@ trainer.name, 56 * 2.32 * 2.0, Color.new (56,160,248), Color.new (56,104,168)])
        else
          textpos.push ([@ trainer.name, 56 * 2.32 * 2.0, Color.new (240,72,88), Color.new (160,64,64)])
        end
        mapname = pbGetMapNameFromId (@mapid)
        mapname.gsub! (/ \\ PN /, @ trainer.name)
        textpos.push ([mapname, 193 * 2.5 * 2.1, Color.new (232,232,232), Color.new (136,136,136)])
      else
        textpos.push ([@ title, 16 * 2.4 * 2.0, Color.new (232,232,232), Color.new (136,136,136)])
      end
      pbDrawTextPositions (self.bitmap, textpos)
    end
    @refreshing = false
  end
end
# ------------------------------------------------- ------------------------------
#
# ------------------------------------------------- ------------------------------
# =============================================== ==============================