[RMXP] Dépasser la limite de sauvegarde

#===============================================================================
# *** MODULE SAVE_MAX
#-------------------------------------------------------------------------------
# Auteur  : Mikltov / Rutsuku Fushin / Cantarelle
#-------------------------------------------------------------------------------
# Ce module permet de définir le nombre d'emplacement de sauvegarde dans votre
# projet
#===============================================================================

module SAVESLOTS
  NB_SAVE_SLOTS = 6 # permet de definir le nombre d'emplacement de sauvegarde
end

#===============================================================================
# *** Scene_SaveMax
#-------------------------------------------------------------------------------
# Auteur  : Mikltov / Rutsuku Fushin / Cantarelle
#-------------------------------------------------------------------------------
# Le Model qui permet de depasser la limite du nombre de sauvegarde, d'une
# manière nettement plus propre et plus ordonnee que le script diffuse sur
# Internet.
# Ici, vous aurez le Model, mais aussi le Control.
# Merci a Avygeil de m'avoir aide a corriger les fautes.
#===============================================================================


#===============================================================================
# class Scene_File
#  C'est elle qui gere la sauvegarde dans un fichier
#===============================================================================
class Scene_File
 
  include SAVESLOTS

  #-----------------------------------------------------------------------------
  # def initialize
  #    * help_text : permet d'afficher une fenêtre d'aide
  #-----------------------------------------------------------------------------
  def initialize(help_text)
    @help_text = help_text
  end
 
  #-----------------------------------------------------------------------------
  # def main
  #-----------------------------------------------------------------------------
  def main
    @help_window = Window_Help.new
    @help_window.set_text(@help_text)
    @savefile_windows = []
    for i in 0..3
      @savefile_windows.push(Window_SaveFile.new(i, make_filename(i)))
    end
    @file_index = $game_temp.last_file_index
    @save_range = self.initial_save_range(@file_index)
    @savefile_windows[@file_index-@save_range.first].selected = true
    Graphics.transition
    loop do
      Graphics.update
      Input.update
      update
      if $scene != self
        break
      end
    end
    Graphics.freeze
    @help_window.dispose
    for savefile_window in @savefile_windows
      savefile_window.dispose
    end 
  end
 
  def initial_save_range(file_index)
    if (file_index+3) > NB_SAVE_SLOTS
      return (NB_SAVE_SLOTS-4)...(NB_SAVE_SLOTS)
    end
    return (file_index)...(file_index+4)
  end
 
  #-----------------------------------------------------------------------------
  # def update
  #-----------------------------------------------------------------------------
  def update
    @help_window.update
    for savefile_window in @savefile_windows
      savefile_window.update
    end
 
    if Input.trigger?(Input::C)
      on_decision(make_filename(@file_index))
      $game_temp.last_file_index = @file_index
      return
    end
 
    if Input.trigger?(Input::B)
      on_cancel
      return
    end
 
    if Input.repeat?(Input::DOWN)
      if Input.trigger?(Input::DOWN) or @file_index < NB_SAVE_SLOTS-1
        $game_system.se_play($data_system.cursor_se)
        @file_index = (@file_index + 1) % NB_SAVE_SLOTS
        return
      end
    end
 
    if Input.repeat?(Input::UP)
      if Input.trigger?(Input::UP) or @file_index > 0
        $game_system.se_play($data_system.cursor_se)
        @file_index = (@file_index - 1) % NB_SAVE_SLOTS
        return
      end
    end
 
    if    @file_index < @save_range.first
      @save_range = (@file_index)..(@file_index+3)
    elsif @file_index > @save_range.last
      @save_range = (@file_index-3)..(@file_index)
    end
 
    for i in 0..3
      @savefile_windows[i].file_index = @save_range.to_a[i]
      if @save_range.to_a[i] == @file_index
        @savefile_windows[i].selected = true
      else
        @savefile_windows[i].selected = false
      end
    end
 
  end

  #-----------------------------------------------------------------------------
  # def make_filename
  #  * file_index : renvoit un fichier Save.rxdata
  #-----------------------------------------------------------------------------
  def make_filename(file_index)
    return "Save#{file_index + 1}.rxdata"
  end

#-------------------------------------------------------------------------------
# Fin de class
#-------------------------------------------------------------------------------
end



#===============================================================================
# class Scene_Save < Scene_File
#-------------------------------------------------------------------------------
#  Cette classe permet de gerer la sauvegarde.
#  C'est une classe derivee de Scene_File
#===============================================================================
class Scene_Save < Scene_File
 
  #-----------------------------------------------------------------------------
  # def initialize
  #-----------------------------------------------------------------------------
  def initialize
    super("Voulez vous sauvegarder la partie ?")
  end
 
  #--------------------------------------------------------------------------
  # def on_decision
  #--------------------------------------------------------------------------
  def on_decision(filename)
    $game_system.se_play($data_system.save_se)
    file = File.open(filename, "wb")
    write_save_data(file)
    file.close
    if $game_temp.save_calling
      $game_temp.save_calling = false
      $scene = Scene_Map.new
      return
    end
    $scene = Scene_Menu.new(4)
  end
 
  #--------------------------------------------------------------------------
  # def on_cancel
  #--------------------------------------------------------------------------
  def on_cancel
    $game_system.se_play($data_system.cancel_se)
    if $game_temp.save_calling
      $game_temp.save_calling = false
      $scene = Scene_Map.new
      return
    end
    $scene = Scene_Menu.new(4)
  end
 
  #--------------------------------------------------------------------------
  # def write_save_data
  #  file :
  #--------------------------------------------------------------------------
  def write_save_data(file)
    # on cree un tableau pour mettre les personnages de l'equipe dedans
    characters = []
    for i in 0...$game_party.actors.size
      actor = $game_party.actors[i]
      characters.push([actor.character_name, actor.character_hue])
    end
    Marshal.dump(characters, file)
    Marshal.dump(Graphics.frame_count, file)
    $game_system.save_count += 1
    Marshal.dump($game_system, file)
    Marshal.dump($game_switches, file)
    Marshal.dump($game_variables, file)
    Marshal.dump($game_self_switches, file)
    Marshal.dump($game_screen, file)
    Marshal.dump($game_actors, file)
    Marshal.dump($game_party, file)
    Marshal.dump($game_troop, file)
    Marshal.dump($game_map, file)
    Marshal.dump($game_player, file)
  end

#-------------------------------------------------------------------------------
# Fin de class
#-------------------------------------------------------------------------------
end




#===============================================================================
# class Scene_Load < Scene_File
#-------------------------------------------------------------------------------
#  Cette classe permet de charger la sauvegarde.
#  C'est une classe derivee de Scene_File
#===============================================================================
class Scene_Load < Scene_File
 
  #--------------------------------------------------------------------------
  # def initialize
  #--------------------------------------------------------------------------
  def initialize
    # objet provisoire
    $game_temp = Game_Temp.new
    $game_temp.last_file_index = 0
    latest_time = Time.at(0)
    for i in 0...NB_SAVE_SLOTS
      filename = make_filename(i)
      if FileTest.exist?(filename)
        file = File.open(filename, "r")
        if file.mtime > latest_time
          latest_time = file.mtime
          $game_temp.last_file_index = i
        end
        file.close
      end
    end
    super("Charger quelle partie?")
  end
 
  #--------------------------------------------------------------------------
  # def on_decision
  #--------------------------------------------------------------------------
  def on_decision(filename)
    # Si le fichier n'existe pas
    unless FileTest.exist?(filename)
      $game_system.se_play($data_system.buzzer_se)
      return
    end
    $game_system.se_play($data_system.load_se)
    file = File.open(filename, "rb")
    read_save_data(file)
    file.close
    $game_system.bgm_play($game_system.playing_bgm)
    $game_system.bgs_play($game_system.playing_bgs)
    $game_map.update
    $scene = Scene_Map.new
  end

  #--------------------------------------------------------------------------
  # def on_cancel
  #--------------------------------------------------------------------------
  def on_cancel
    $game_system.se_play($data_system.cancel_se)
    $scene = Scene_Title.new
  end
 
  #--------------------------------------------------------------------------
  # def read_save_data
  #  file : fichier de sauvegarde
  #--------------------------------------------------------------------------
  def read_save_data(file)
    # Read character data for drawing save file
    characters = Marshal.load(file)
    # Read frame count for measuring play time
    Graphics.frame_count = Marshal.load(file)
    # Read each type of game object
    $game_system        = Marshal.load(file)
    $game_switches      = Marshal.load(file)
    $game_variables    = Marshal.load(file)
    $game_self_switches = Marshal.load(file)
    $game_screen        = Marshal.load(file)
    $game_actors        = Marshal.load(file)
    $game_party        = Marshal.load(file)
    $game_troop        = Marshal.load(file)
    $game_map          = Marshal.load(file)
    $game_player        = Marshal.load(file)
    $game_party.refresh
  end

#-------------------------------------------------------------------------------
# Fin de class
#-------------------------------------------------------------------------------
end

===============================================================================
# *** Window_SaveMax
#-------------------------------------------------------------------------------
# Auteur  : Mikltov / Rutsuku Fushin / Cantarelle
#-------------------------------------------------------------------------------
# La View qui permet de depasser la limite du nombre de sauvegarde, d'une
# manière nettement plus propre et plus ordonnee que le script diffuse sur
# Internet.
# Ici, vous pourrez modifier tout ce qui est en relation avec le graphisme.
#===============================================================================

class Window_SaveFile < Window_Base
 
  #-----------------------------------------------------------------------------
  # * Public Instance Variables
  #-----------------------------------------------------------------------------
  attr_reader  :filename                # file name
  attr_reader  :selected                # selected
  attr_writer  :file_index             
 
  #-----------------------------------------------------------------------------
  # * Object Initialization
  #    file_index : save file index (0-3)
  #    filename  : file name
  #-----------------------------------------------------------------------------
  def initialize(file_index, filename)
    super(0, 64 + file_index % 4 * 104, 640, 104)
    self.contents = Bitmap.new(width - 32, height - 32)
    @file_index = file_index
    @old_file_index = @file_index
    refresh
    @selected = false
  end
 
  def update
    super
    if @file_index != @old_file_index
      @old_file_index = @file_index
      refresh
    end
  end
 
  #--------------------------------------------------------------------------
  # * Refresh
  #--------------------------------------------------------------------------
  def refresh
    @filename = "Save#{@file_index + 1}.rxdata"
    @time_stamp = Time.at(0)
    @file_exist = FileTest.exist?(@filename)
    if @file_exist
      file = File.open(@filename, "r")
      @time_stamp = file.mtime
      @characters = Marshal.load(file)
      @frame_count = Marshal.load(file)
      @game_system = Marshal.load(file)
      @game_switches = Marshal.load(file)
      @game_variables = Marshal.load(file)
      @total_sec = @frame_count / Graphics.frame_rate
      file.close
    end
    self.contents.clear
    # Draw file number
    self.contents.font.color = normal_color
    name = "Fichier #{@file_index + 1}"
    self.contents.draw_text(4, 0, 600, 32, name)
    @name_width = contents.text_size(name).width
    # If save file exists
    if @file_exist
      # Draw character
      for i in 0...@characters.size
        bitmap = RPG::Cache.character(@characters[i][0], @characters[i][1])
        cw = bitmap.rect.width / 4
        ch = bitmap.rect.height / 4
        src_rect = Rect.new(0, 0, cw, ch)
        x = 300 - @characters.size * 32 + i * 64 - cw / 2
        self.contents.blt(x, 68 - ch, bitmap, src_rect)
      end
      # Draw play time
      hour = @total_sec / 60 / 60
      min = @total_sec / 60 % 60
      sec = @total_sec % 60
      time_string = sprintf("%02d:%02d:%02d", hour, min, sec)
      self.contents.font.color = normal_color
      self.contents.draw_text(4, 8, 600, 32, time_string, 2)
      # Draw timestamp
      self.contents.font.color = normal_color
      time_string = @time_stamp.strftime("%Y/%m/%d %H:%M")
      self.contents.draw_text(4, 40, 600, 32, time_string, 2)
    end
  end
 
  #--------------------------------------------------------------------------
  # * Set Selected
  #    selected : new selected (true = selected, false = unselected)
  #--------------------------------------------------------------------------
  def selected=(selected)
    @selected = selected
    update_cursor_rect
  end
 
  #--------------------------------------------------------------------------
  # * Cursor Rectangle Update
  #--------------------------------------------------------------------------
  def update_cursor_rect
    if @selected
      self.cursor_rect.set(0, 0, @name_width + 8, 32)
    else
      self.cursor_rect.empty
    end
  end
 
#-------------------------------------------------------------------------------
# * Fin de classe
#-------------------------------------------------------------------------------
end

include SAVESLOTS

for i in 0..3
      if FileTest.exist?("Save#{i+1}.rxdata")
        @continue_enabled = true
      end
    end

for i in 0...NB_SAVE_SLOTS
      if FileTest.exist?("Save#{i+1}.rxdata")
        @continue_enabled = true
      end
    end

#==============================================================================
# ** Scene_File
#------------------------------------------------------------------------------
#  This is a superclass for the save screen and load screen.
#==============================================================================

SE_NB_SAVE = 8

class Window_SaveFile < Window_Base
  #--------------------------------------------------------------------------
  # * Public Instance Variables
  #--------------------------------------------------------------------------
  attr_reader  :filename                # file name
  attr_reader  :selected                # selected
  #--------------------------------------------------------------------------
  # * Object Initialization
  #    file_index : save file index
  #    filename  : file name
  #--------------------------------------------------------------------------
  def initialize(file_index, filename)
    super(0, 64 + file_index * 104, 640, 104)
    self.contents = Bitmap.new(width - 32, height - 32)
    @file_index = file_index
    @filename = "Save#{@file_index + 1}.rxdata"
    @time_stamp = Time.at(0)
    @file_exist = FileTest.exist?(@filename)
    if @file_exist
      file = File.open(@filename, "r")
      @time_stamp = file.mtime
      @characters = Marshal.load(file)
      @frame_count = Marshal.load(file)
      @game_system = Marshal.load(file)
      @game_switches = Marshal.load(file)
      @game_variables = Marshal.load(file)
      @total_sec = @frame_count / Graphics.frame_rate
      file.close
    end
    refresh
    @selected = false
  end
end

class Scene_File
  #--------------------------------------------------------------------------
  # * Object Initialization
  #    help_text : text string shown in the help window
  #--------------------------------------------------------------------------
  def initialize(help_text)
    @help_text = help_text
    @idx_top_save = 0
  end
  #--------------------------------------------------------------------------
  # * Main Processing
  #--------------------------------------------------------------------------
  def main
    # Make help window
    @help_window = Window_Help.new
    @help_window.set_text(@help_text)
    # Make save file window
    @savefile_windows = []
    for i in 0...SE_NB_SAVE
      @savefile_windows.push(Window_SaveFile.new(i, make_filename(i)))
    end
    # Select last file to be operated
    @file_index = $game_temp.last_file_index
    @savefile_windows[@file_index].selected = true
    move_save
    # Execute transition
    Graphics.transition
    # Main loop
    loop do
      # Update game screen
      Graphics.update
      # Update input information
      Input.update
      # Frame update
      update
      # Abort loop if screen is changed
      if $scene != self
        break
      end
    end
    # Prepare for transition
    Graphics.freeze
    # Dispose of windows
    @help_window.dispose
    for i in @savefile_windows
      i.dispose
    end
  end
  #--------------------------------------------------------------------------
  # * Frame Update
  #--------------------------------------------------------------------------
  def update
    # Update windows
    @help_window.update
    for i in @savefile_windows
      i.update
    end
    # If C button was pressed
    if Input.trigger?(Input::C)
      # Call method: on_decision (defined by the subclasses)
      on_decision(make_filename(@file_index))
      $game_temp.last_file_index = @file_index
      return
    end
    # If B button was pressed
    if Input.trigger?(Input::B)
      # Call method: on_cancel (defined by the subclasses)
      on_cancel
      return
    end
    # If the down directional button was pressed
    if Input.repeat?(Input::DOWN)
      # If the down directional button pressed down is not a repeat,
      # or cursor position is more in front than 3
      if Input.trigger?(Input::DOWN) or @file_index < 3
        # Play cursor SE
        $game_system.se_play($data_system.cursor_se)
        # Move cursor down
        @savefile_windows[@file_index].selected = false
        @file_index = (@file_index + 1) % SE_NB_SAVE
        @savefile_windows[@file_index].selected = true
        move_save
        return
      end
    end
    # If the up directional button was pressed
    if Input.repeat?(Input::UP)
      # If the up directional button pressed down is not a repeat、
      # or cursor position is more in back than 0
      if Input.trigger?(Input::UP) or @file_index > 0
        # Play cursor SE
        $game_system.se_play($data_system.cursor_se)
        # Move cursor up
        @savefile_windows[@file_index].selected = false
        @file_index = (@file_index + (SE_NB_SAVE - 1)) % SE_NB_SAVE
        @savefile_windows[@file_index].selected = true
        move_save
        return
      end
    end
  end
 
 
  def move_save
    if SE_NB_SAVE > 0
      save_idx_top_save = @idx_top_save
     
      if @file_index < @idx_top_save
        @idx_top_save = @file_index
      elsif @file_index > @idx_top_save + 3
        @idx_top_save = @file_index - 3

      end
     
      hh = @help_window.height
      hs = @savefile_windows[0].height
     
      if save_idx_top_save != @idx_top_save
        for i in 0...SE_NB_SAVE
          @savefile_windows[i].visible = (i >= @idx_top_save and i < (@idx_top_save + 4))
          @savefile_windows[i].y = hh + ((i - @idx_top_save) * hs )
         
        end
      end
    end
  end
 
  #--------------------------------------------------------------------------
  # * Make File Name
  #    file_index : save file index (0-3)
  #--------------------------------------------------------------------------
  def make_filename(file_index)
    return "Save#{file_index + 1}.rxdata"
  end
end