Extreme Save-Load

#=============================================================================
# * Mundo RPG Maker Extreme Save Load
#---------------------------------------------------------------------------
# Autor: Gab!
# Data:  24/01/14
#---------------------------------------------------------------------------
# Créditos:
#   * Tweening:
#     - Robert Penner
#     - UziMonkey
#--------------------------------------------------------------------------
# Instruções de instalação:
#   - Cole abaixo do script "Extreme Menu".
#=============================================================================

# Remove cenas anteriores antes de modificar
[:Scene_File, :Scene_Load, :Scene_Save].each{|scene|
  Object.send(:remove_const, scene)
}

#==============================================================================
# ** Menu_SaveFile_Window
#------------------------------------------------------------------------------
#  Mostra a informação de save e criação de novo jogo
#==============================================================================

class SaveLoad_SaveFile_Window < Menu_SaveFile_Window
  #-------------------------------------------------------------------------
  # * Redesenha atores
  #-------------------------------------------------------------------------
  def redraw_chars
    y = 86 + line_height * 7
    contents.clear_rect(0, y, contents_width, contents_height - y)
    if @data
      space = (contents_width / @data[:characters].size)
      @data[:characters].each_with_index{|data, index|
        draw_character(data[0], data[1], (index + 0.5) * space, y)
      }
    else
      return
      chars = $game_party.battle_members
      space = (contents_width / chars.size)

      chars.each_with_index{|char, index|
        draw_character(char.character_name, char.character_index, (index + 0.5) * space, y)
      }
    end
  end

  #-------------------------------------------------------------------------
  # * Redesenha janela
  #   complete : Redesenho completo?
  #-------------------------------------------------------------------------
  def refresh(complete = false)
    if complete
      contents.clear

      if @data
        contents.blt(0, line_height, @preview, @preview.rect)
        @previewRect.y = 86 + 4 * line_height
        draw_text(@previewRect, @data[:playtime_s], 1)
      else
        change_color(system_color)
        draw_text(@previewRect, Vocab[:FreeSlot], 1)
        change_color(normal_color)
        @previewRect.y += line_height
        draw_text(@previewRect, Vocab[:NewSave], 1)
      end

      change_color(system_color)
      @previewRect.y = 86 + 3 * line_height
      draw_text(@previewRect, Vocab[:PlayTime], 1)
      @previewRect.y = 86 + 6 * line_height
      draw_text(@previewRect, Vocab[:Party], 1)
      change_color(normal_color)
    elsif !@data
      @previewRect.y = 86 + 4 * line_height
      contents.clear_rect(@previewRect)
      draw_text(@previewRect, $game_system.playtime_s, 1)
    end

    redraw_chars
  end
end

#==============================================================================
# ** Scene_File
#------------------------------------------------------------------------------
#  Esta classe executa o processamento da tela de salvar e carregar.
#==============================================================================
class Scene_File < Scene_Base
  #--------------------------------------------------------------------------
  # * Inicialização do processo
  #--------------------------------------------------------------------------
  def start
    super
    @index = self.first_savefile_index

    process_move_data
    create_background
    create_savefile_windows
    show_save_windows
    init_selection
  end
  #-------------------------------------------------------------------------
  # * Processa informação de movimento
  #-------------------------------------------------------------------------
  def process_move_data
    [
      [:SaveEnter, :@saveEnter],
      [:SaveMove,  :@saveMove ],
    ].each{|key, var|
      data  = MRM::ExtremeMenu::Animation[key]
      moveData = {
        :style => Tween::EASERS[data[0]] || Tween::Linear,
        :time  => data[1]
      }
      moveData[:off] = data[2] if data[2]
      self.instance_variable_set(var, moveData)
    }
  end
  #--------------------------------------------------------------------------
  # * Criação do plano de fundo
  #--------------------------------------------------------------------------
  def create_background
    @background_sprite = Sprite.new
    @background_sprite.bitmap = SceneManager.background_bitmap
    @background_sprite.color.set(16, 16, 16, 128)
  end
  #--------------------------------------------------------------------------
  # * Disposição do plano de fundo
  #--------------------------------------------------------------------------
  def dispose_background
    @background_sprite.dispose
  end
  #--------------------------------------------------------------------------
  # * Finalização do processo
  #--------------------------------------------------------------------------
  def terminate
    super
    dispose_background
    @saveWindows.each(&:dispose)
  end
  #--------------------------------------------------------------------------
  # * Atualização da tela
  #--------------------------------------------------------------------------
  def update
    super
    Tween.update
    @saveWindows.each(&:update)
    update_savefile_selection
  end
  #--------------------------------------------------------------------------
  # * Criação das janelas dos arquivos salvos [+]
  #--------------------------------------------------------------------------
  def create_savefile_windows
    @saveWindows = []
    index, continue = self.createFeed
    x, y, w, h   = Graphics.width, 0, Graphics.width/3, Graphics.height

    begin
      @saveWindows << SaveLoad_SaveFile_Window.new(x, y, w, h, index, continue)
      @saveWindows.last.contents_opacity = 0
      continue = DataManager.load_header(index += 1)
    end until not continue or index >= DataManager.savefile_max

    @saveWindows.shift.dispose if @saveWindows.size == DataManager.savefile_max + 1
  end

  #-------------------------------------------------------------------------
  # * Material para criação das janelas de save
  #-------------------------------------------------------------------------
  def createFeed
    return [-1, false]
  end

  #-------------------------------------------------------------------------
  # * Mostra janelas de save
  #-------------------------------------------------------------------------
  def show_save_windows
    baseX = (Graphics.width - @saveWindows.first.width) / 2

    @saveWindows.each_with_index{|window, index|
      Tween.start(window, @saveEnter[:style], @saveEnter[:time], @saveEnter[:off] * index,
        :x => baseX - ((@index - index) * window.width),
        :contents_opacity => 255
      )
    }
  end
  #-------------------------------------------------------------------------
  # * Move janelas de save
  #-------------------------------------------------------------------------
  def move_save_windows
    baseX = (Graphics.width - @saveWindows.first.width) / 2

    @saveWindows.each_with_index{|window, index|
      Tween.start(window, @saveMove[:style], @saveMove[:time],
        :x => baseX - ((@index - index) * window.width)
      )
    }
  end
  #--------------------------------------------------------------------------
  # * Inicialização da seleção
  #--------------------------------------------------------------------------
  def init_selection
    @saveWindows[@index].active = true
  end
  #--------------------------------------------------------------------------
  # * Atualização da seleção dos arquivos salvos
  #--------------------------------------------------------------------------
  def update_savefile_selection
    return on_savefile_ok     if Input.trigger?(:C)
    return on_savefile_cancel if Input.trigger?(:B)
    update_cursor
  end
  #--------------------------------------------------------------------------
  # * Salvando o arquivo [Confirmação]
  #--------------------------------------------------------------------------
  def on_savefile_ok
  end
  #--------------------------------------------------------------------------
  # * Salvando o arquivo [Cancelamento]
  #--------------------------------------------------------------------------
  def on_savefile_cancel
    Sound.play_cancel
    return_scene
  end
  #--------------------------------------------------------------------------
  # * Atualização do cursor
  #--------------------------------------------------------------------------
  def update_cursor
    last_index = @index

    if    Input.repeat?(:LEFT)
      @index -= 1
    elsif Input.repeat?(:RIGHT)
      @index += 1
    end

    @index %= @saveWindows.size

    if @index != last_index
      Sound.play_cursor
      move_save_windows
      @saveWindows[last_index].active = false
      @saveWindows[@index].active     = true
    end
  end
end

#==============================================================================
# ** Scene_Load
#------------------------------------------------------------------------------
#  Esta classe executa o processamento da tela de carregar.
#==============================================================================

class Scene_Load < Scene_File
  #--------------------------------------------------------------------------
  # * Aquisição do índice do primeiro arquivo selecionado
  #--------------------------------------------------------------------------
  def first_savefile_index
    DataManager.latest_savefile_index
  end
  #--------------------------------------------------------------------------
  # * Definição de arquivo salvo
  #--------------------------------------------------------------------------
  def on_savefile_ok
    super
    DataManager.load_game(@index) ? on_load_success : Sound.play_buzzer
  end
  #--------------------------------------------------------------------------
  # * Processo de carregamento aquivo bem sucedido
  #--------------------------------------------------------------------------
  def on_load_success
    Sound.play_load
    fadeout_all
    $game_system.on_after_load
    SceneManager.goto(Scene_Map)
  end

  #-------------------------------------------------------------------------
  # * Material para criação das janelas de save
  #-------------------------------------------------------------------------
  def createFeed
    return [0, DataManager.load_header(0)]
  end
end

#==============================================================================
# ** Scene_Save
#------------------------------------------------------------------------------
#  Esta classe executa o processamento da tela de salvar.
#==============================================================================

class Scene_Save < Scene_File
  #--------------------------------------------------------------------------
  # * Aquisição do índice do primeiro arquivo selecionado
  #--------------------------------------------------------------------------
  def first_savefile_index
    DataManager.last_savefile_index
  end
  #--------------------------------------------------------------------------
  # * Definição de arquivo salvo
  #--------------------------------------------------------------------------
  def on_savefile_ok
    super
    i = @index.zero? ? @saveWindows.size : @index
    DataManager.save_game(i - 1) ? on_save_success : Sound.play_buzzer
  end
  #--------------------------------------------------------------------------
  # * Processo de salvar aquivo bem sucedido
  #--------------------------------------------------------------------------
  def on_save_success
    Sound.play_save
    return_scene
  end
end