[VXAce] CSCA AutoSave Plus

[ReetzO]

~ CSCA AutoSave Plus ~

Krótki opis:
Skrypt pozwala na autozapis manualny, a także:
- przy przechodzeniu na inną mapę
- po walce
- przy zdobywaniu złota,przedmiotów,broni,pancerza
- po pewnej ilości kroków

Każdą opcję można dowolnie edytować, tak samo jak nazwę pliku autosave oraz okna z autosave.
AutoSave Plus nie zastępuje klasycznego Wczytaj Grę.
GŁÓWNE INFORMACJE MOŻNA ZNALEŹĆ W SKRYPCIE!!!

Autor:
Casper Gaming ( http://www.caspergaming.com/index.html )

Tłumaczenie:
ReetzO

Skrypt:

Spoiler: (Otwórz)

Kod: (Zaznacz wszystko)

=begin
CSCA AutoSave Plus
Wersja: 1.1 (Stworzone: August 20th, 2012)
Twórca: Casper Gaming (http://www.caspergaming.com/)
Tłumaczył: ReetzO
Tłumaczenie z: www.forum.ultimateam.pl
------------------------------------------------
Kompatybilność:
Stworzone dla RPGVXAce
WAŻNE: Wszystkie skrypty CSCA powinny ze sobą działać bez zarzutów, jeśli nie,
jest to powiedziane!

NIE KOMPATYBILNE Z: CSCA Game Over Options
(Jendnak ten skrypt utrzymuje funkcjonalność tamtego).
------------------------------------------------
HISTORIA AKTUALIZACJI:
Wersja 1.0
-oryginalny skrypt

Wersja 1.1
-O automatycznym zapisywaniu informuje nas wyskakujący na mapie tekst
-Dodano automatyczny zapis po przejściu określonej liczby kroków
------------------------------------------------
WSTĘP:
Ten skrypt dodaje do gry automatyczny zapis, który aktywuje się, gdy gracz:
przeniesie się na inną mapę, zakończy walkę, otrzyma złoto/ekwpipunek/przedmiot/
broń (tylko dzieki komendom w zdarzeniach), każdą opcję można wyłączyć/włączyć.
Automatyczny zapis nie nadmienia standardowego zapisu.
------------------------------------------------
CO OFERUJE SKRYPT:
-Automatyczny zapis gry przy specjalnych okolicznościach określonych przez ciebie
-Możliwość wczytania automatycznego zapisu z menu, scene_end lub gameovera.
-Możliwość zmiany muzyki/obrazka z gameovera za pomocą komendy w grze.
------------------------------------------------
USTAWIENIA SKRYPTU:
Ustawienia skryptu można zmienić poniżej.

================================================================================​
Aby samemu stworzyć autosave należy użyć komendy Skrypt z kodem:
DataManager.csca_autosave(:save)

Aby samemu wczytać autosave należy użyć komendy Skrypt z kodem:
DataManager.csca_autosave(:load)
UWAGA: Używaj z rozwagą, pojawi się błąd, jeśli autosave nie istniał!
================================================================================​

CREDITSY:
Można bez oporów użyawć w niekomercyjnych grach jeśli w credistach będzie:
         Casper Gaming (http://www.caspergaming.com/)
Co łaska, proszę także umieścić tłumacza:
         ReetzO

Aby korzystać ze skryptu w grach komercyjnych należy zakupić licencję tutaj:
http://www.caspergaming.com/licenses.html

ZASADY UŻYWANIA:
http://www.caspergaming.com/terms_of_use.html
=end
module CSCA # <- NIE DOTYKAĆ
  module AUTOSAVE # <- NIE DOTYKAĆ
    #============================ Opcje Autosave =============================#
    #===== Wpisz true jeśli zatwierdzasz daną opcję lub false jeśli nie. =====#    
    TRANSFER = true # Autosave przy przejściu na inną mapę?
    BATTLE = true   # Autosave po każdej walce?
    #========== Następne opcje dotyczą tylko komend w zdarzeniach ============#
    GOLD = true     # Autosave przy zmianie aktualnego złota?
    ITEM = true     # Autosave przy dodaniu/usunięciu przedmiotu?
    WEAPON = true   # Autosave przy dodaniu/usunięciu broni?
    ARMOR = true    # Autosave przy dodaniu/usunięciu pancerza?
    #=================== Liczba kroków określana poniżej =====================#
    STEPS = false   # Autosave po konkretnej liczbie kroków?
    
    DISABLE_SWITCH = 1 # ID przełącznika. Gdy przełącznik ten będzie włączony
                       # autosave będzie działać tylko przy użyciu komend
                       # manualnie. Używaj go, gdy nie chcesz by na przykład
                       # przechodzenie między mapami w Intro zapisywało grę.
    
    STEP_COUNT = 50 # Liczba kroków potrzebna do autosave (jeśli włączone)
    #=========================== Opcje Game Over =============================#
    # Ustawienie zmiennych
    IMAGEVAR = 1 # ID zmiennej. Określa, który obrazek gameover użyć. Przykład:
                 # Ta zmienna jest ustawiona na 1, a więc wykorzystany zostanie
                 # obrazek Graphics/System/GameOver1
    MUSICVAR = 2 # ID zmiennej. Określa, które ME użyć do gameover'a. Przykład:
                 # Ta zmienna jest ustawiona na 1, a więc wykorzystane zostanie
                 # ME Audio/ME/GameOver1

    # Ustawienie tekstu
    CONTINUE = "Kontynuuj" # Tekst dla wczytywania autosave.
    LOAD = "Wczytaj grę" # Tekst dla wczytywania zwykłego zapisu gry.
    TITLE = "Do menu" # Tekst dla opcji 'Powrót do menu głównego'
    SHUTDOWN = "Wyjdź z gry" # Tekst dla opcji 'Wyjdź z gry'
    AUTOSAVING = "Zapisywanie..." # Tekst wyświetlany na mapie podczas autosave'a
  end # AUTOSAVE
end # CSCA
#############
# Zmiana nazwy pliku autosave #
#############
$imported = {} if $imported.nil?
$imported["CSCA-Autosave"] = true # Zmień 'Autosave' na twoją nazwę pliku.
#==============================================================================
# ** DataManager
#------------------------------------------------------------------------------
#  Wykorzystwyane do usuwania i tworzenia autosave.
# W skrócie: Rozpoczęcie nowej gry a autosave.
#==============================================================================
module DataManager
  #--------------------------------------------------------------------------
  # * Wczytywanie, czy zapis?
  #--------------------------------------------------------------------------
  def self.csca_autosave(symbol)
    case symbol
    when :save; make_autosave
    when :load; load_autosave
    end
  end
  #--------------------------------------------------------------------------
  # * Czy autosave istnieje?
  #--------------------------------------------------------------------------
  # Jeśli zmieniłeś wcześniej nazwę pliku tu także musisz.
  #--------------------------------------------------------------------------
  def self.autosave_exists?
    !Dir.glob('Autosave.rvdata2').empty?
  end
  #--------------------------------------------------------------------------
  # * Usuwanie autosave
  #--------------------------------------------------------------------------
  # Jeśli zmieniłeś wcześniej nazwę pliku tu także musisz.
  #--------------------------------------------------------------------------
  def self.delete_autosave
    File.delete('Autosave.rvdata2') rescue nil
  end
  #--------------------------------------------------------------------------
  # * Zapisywanie metodą autosave  
  #--------------------------------------------------------------------------
  def self.make_autosave
    begin
      autosave_without_rescue
    rescue
      delete_autosave
      false
    end
    $game_map.autosaving = true
  end
  #--------------------------------------------------------------------------
  # * Wczytywania metodą kontynuuj grę
  #--------------------------------------------------------------------------
  def self.load_autosave
    load_autosave_without_rescue rescue false
  end
  #--------------------------------------------------------------------------
  # * Wykonywanie zapisu gry
  #--------------------------------------------------------------------------
  # Jeśli zmieniłeś wcześniej nazwę pliku tu także musisz.
  #--------------------------------------------------------------------------
  def self.autosave_without_rescue
    File.open('Autosave.rvdata2', "wb") do |file|
      $game_system.on_before_autosave
      Marshal.dump(make_save_header, file)
      Marshal.dump(make_save_contents, file)
    end
    return true
  end
  #--------------------------------------------------------------------------
  # * Wykonywanie kontynuowania gry
  #--------------------------------------------------------------------------
  # Jeśli zmieniłeś wcześniej nazwę pliku tu także musisz.
  #--------------------------------------------------------------------------
  def self.load_autosave_without_rescue
    File.open('Autosave.rvdata2', "rb") do |file|
      Marshal.load(file)
      extract_save_contents(Marshal.load(file))
      reload_map_if_updated
    end
    return true
  end
  #--------------------------------------------------------------------------
  # * Skrócona metoda
  #--------------------------------------------------------------------------
  class << self; alias csca_autosave_new_game setup_new_game; end
  def self.setup_new_game
    csca_autosave_new_game
    delete_autosave if autosave_exists?
  end
end # DataManager
#==============================================================================
# ** Game_System
#------------------------------------------------------------------------------
#  Formuje działanie przed autosave i po wczytaniu autosave
#==============================================================================
class Game_System
  #--------------------------------------------------------------------------
  # * Działanie przed autosave
  #--------------------------------------------------------------------------
  def on_before_autosave
    @version_id = $data_system.version_id
    @frames_on_autosave = Graphics.frame_count
    @bgm_on_autosave = RPG::BGM.last
    @bgs_on_autosave = RPG::BGS.last
  end
  #--------------------------------------------------------------------------
  # * Działanie po wczytaniu autosave
  #--------------------------------------------------------------------------
  def on_after_autosave_load
    Graphics.frame_count = @frames_on_autosave
    @bgm_on_autosave.play
    @bgs_on_autosave.play
  end
  #--------------------------------------------------------------------------
  # * Autosave aktywny?
  #--------------------------------------------------------------------------
  def csca_autosave_allowed?(situation)
    return false if $game_switches[CSCA::AUTOSAVE::DISABLE_SWITCH] || $BTEST ||
      $game_party.in_battle
    case situation
    when :transfer; CSCA::AUTOSAVE::TRANSFER
    when :battle; CSCA::AUTOSAVE::BATTLE
    when :gold; CSCA::AUTOSAVE::GOLD
    when :item; CSCA::AUTOSAVE::ITEM
    when :weapon; CSCA::AUTOSAVE::WEAPON
    when :armor; CSCA::AUTOSAVE::ARMOR
    when :steps; CSCA::AUTOSAVE::STEPS
    end
  end
end # Game_System
#==============================================================================
# ** Scene_Load
#------------------------------------------------------------------------------
#  Usuwa stary plik autosave, podczas wczytywania nowego pliku.
# W skrócie: on_load_succes
#==============================================================================
class Scene_Load < Scene_File
  #--------------------------------------------------------------------------
  # * Skrócona metoda  #--------------------------------------------------------------------------
  alias csca_delete_autosave on_load_success
  def on_load_success
    csca_delete_autosave
    DataManager.delete_autosave if DataManager.autosave_exists?
  end
end # Scene_Load
#==============================================================================
# ** Scene_Gameover
#------------------------------------------------------------------------------
#  Dodawanie nowego okna i zależnych od zmiennych grafik/ME przy gameoverze.
# W skrócie: start, play_gameover_music, create_background
# W przeciwnym razie: update
#==============================================================================
class Scene_Gameover < Scene_Base
  #--------------------------------------------------------------------------
  # * Skrócona metoda - start
  #--------------------------------------------------------------------------
  alias csca_gameover_start start
  def start
    csca_gameover_start
    create_command_window
  end
  #--------------------------------------------------------------------------
  # * Metoda 'W przeciwnym razie'
  #--------------------------------------------------------------------------
  def update
    super
  end
  #--------------------------------------------------------------------------
  # * Skrócona metoda - ME
  # Możesz tutaj zmienić pierwszy człon pliku do ME wykorzystywanego w gameover
  # i zależnego od zmiennej.
  #--------------------------------------------------------------------------
  alias csca_gameover_music play_gameover_music
  def play_gameover_music
    RPG::BGM.stop
    RPG::BGS.stop
    $game_variables[CSCA::AUTOSAVE::MUSICVAR] == 0 ? csca_gameover_music :
      Audio.me_play("Audio/ME/Gameover"+$game_variables[CSCA::AUTOSAVE::MUSICVAR].to_s,100,100)
  end
  #--------------------------------------------------------------------------
  # * Skrócona metoda - obrazek
  # Możesz tutaj zmienić pierwszy człon pliku do obrazka wykorzystywanego w
  # gameoer i zależnego od zmiennej.
  #--------------------------------------------------------------------------
  alias csca_gameover_background create_background
  def create_background
    @sprite = Sprite.new
    $game_variables[CSCA::AUTOSAVE::IMAGEVAR] == 0 ? csca_gameover_background :
      @sprite.bitmap = Cache.system("GameOver" + $game_variables[CSCA::AUTOSAVE::IMAGEVAR].to_s)
  end
  #--------------------------------------------------------------------------
  # * Komendy w gameover
  #--------------------------------------------------------------------------
  def create_command_window
    @command_window = CSCA_Window_GameoverCommand.new
    @command_window.set_handler(:continue, method(:load_autosave))
    @command_window.set_handler(:load, method(:goto_file_selection))
    @command_window.set_handler(:title, method(:goto_title))
    @command_window.set_handler(:shutdown, method(:goto_shutdown))
  end
  #--------------------------------------------------------------------------
  # * Wyjdź z gry
  #--------------------------------------------------------------------------
  def goto_shutdown
    close_command_window
    fadeout_all
    SceneManager.exit
  end
  #--------------------------------------------------------------------------
  # * Wczytaj zapisaną grę
  #--------------------------------------------------------------------------
  def goto_file_selection
    close_command_window
    SceneManager.call(Scene_Load)
  end
  #--------------------------------------------------------------------------
  # * Kontynuuj grę (autosave)
  #--------------------------------------------------------------------------
  def load_autosave
    DataManager.csca_autosave(:load)
    fadeout_all
    $game_system.on_after_autosave_load
    SceneManager.goto(Scene_Map)
  end
  #--------------------------------------------------------------------------
  # * Zamknij okno
  #--------------------------------------------------------------------------
  def close_command_window
    @command_window.close
    update until @command_window.close?
  end
end # Scene_Gameover
#==============================================================================
# ** CSCA_Window_GameoverCommand
#------------------------------------------------------------------------------
#  Tu jest ustalane okno do komend na ekranie gameover
#==============================================================================
class CSCA_Window_GameoverCommand < Window_Command
  #--------------------------------------------------------------------------
  # * Inicjalizacja
  #--------------------------------------------------------------------------
  def initialize
    super(0,0)
    self.x = (Graphics.width - width) / 2
    self.y = (Graphics.height * 1.6 - height) / 2
    self.openness = 0
    open
  end
  #--------------------------------------------------------------------------
  # * Tworzenie komend
  #--------------------------------------------------------------------------
  def make_command_list
    add_command(CSCA::AUTOSAVE::CONTINUE, :continue, continue_enabled)
    add_command(CSCA::AUTOSAVE::LOAD, :load, load_enabled)
    add_command(CSCA::AUTOSAVE::TITLE, :title)
    add_command(CSCA::AUTOSAVE::SHUTDOWN, :shutdown)
  end
  #--------------------------------------------------------------------------
  # * Autosave istnieje?
  #--------------------------------------------------------------------------
  def continue_enabled
    DataManager.autosave_exists?
  end
  #--------------------------------------------------------------------------
  # * Zapisana gra istnieje?
  #--------------------------------------------------------------------------
  def load_enabled
    DataManager.save_file_exists?
  end
end # CSCA_Window_GameoverCommand
#==============================================================================
# ** Window_GameEnd
#------------------------------------------------------------------------------
#  Wczytywanie gry w: Koniec gry
# W skrócie: make_command_list
#==============================================================================
class Window_GameEnd < Window_Command
  #--------------------------------------------------------------------------
  # * Skrócona metoda
  #--------------------------------------------------------------------------
  alias csca_autosave make_command_list
  def make_command_list
    add_command(CSCA::AUTOSAVE::CONTINUE, :autosave, autosave_enabled)
    csca_autosave
  end
  #--------------------------------------------------------------------------
  # * Autosave istnieje?
  #--------------------------------------------------------------------------
  def autosave_enabled
    DataManager.autosave_exists?
  end
end # Window_GameEnd
#==============================================================================
# ** Scene_End
#------------------------------------------------------------------------------
#  Wczytywanie ostaniego zapisu z: Scene_End
# W skrócie: create_command_window
#==============================================================================
class Scene_End < Scene_MenuBase
  #--------------------------------------------------------------------------
  # * Skrócona metoda
  #--------------------------------------------------------------------------
  alias csca_autosave_option create_command_window
  def create_command_window
    csca_autosave_option
    @command_window.set_handler(:autosave, method(:load_autosave))
  end
  #--------------------------------------------------------------------------
  # * Wczytywanie autosave
  #--------------------------------------------------------------------------
  def load_autosave
    DataManager.csca_autosave(:load)
    fadeout_all
    $game_system.on_after_autosave_load
    SceneManager.goto(Scene_Map)
  end
end # Scene_End
#==============================================================================
# ** Window_TitleCommand
#------------------------------------------------------------------------------
#  Wczytywanie autosave z menu głównego
# W skrócie: make_command_list
#==============================================================================
class Window_TitleCommand < Window_Command
  #--------------------------------------------------------------------------
  # * Metoda 'W przeciwnym razie'
  #--------------------------------------------------------------------------
  def make_command_list
    add_command(Vocab::new_game, :new_game)
    add_command(Vocab::continue, :continue, continue_enabled)
    add_command(CSCA::AUTOSAVE::CONTINUE, :autosave, autosave_enabled)
    add_command(Vocab::shutdown, :shutdown)
  end
  #--------------------------------------------------------------------------
  # * Autosave istinieje?
  #--------------------------------------------------------------------------
  def autosave_enabled
    DataManager.autosave_exists?
  end
end # Window_TitleCommand
#==============================================================================
# ** Scene_Title
#------------------------------------------------------------------------------
#  Wczytywanie autosave z menu głównego w tworzonym oknie
# W skrócie: create_command_window
#==============================================================================
class Scene_Title < Scene_Base
  #--------------------------------------------------------------------------
  # * Skrócona metoda
  #--------------------------------------------------------------------------
  alias csca_autosave_add create_command_window
  def create_command_window
    csca_autosave_add
    @command_window.set_handler(:autosave, method(:command_autosave))
  end
  #--------------------------------------------------------------------------
  # * Wczytywanie autosave
  #--------------------------------------------------------------------------
  def command_autosave
    DataManager.csca_autosave(:load)
    close_command_window
    fadeout_all
    $game_system.on_after_autosave_load
    SceneManager.goto(Scene_Map)
  end
end # Scene_Title
#==============================================================================
# ** Scene_Map
#------------------------------------------------------------------------------
#  Autosave przy przenoszeniu się na inną mapę. Tworzenie okien autosave.
# W skrócie: post_transfer, create_all_windows, pre_transfer, update
#==============================================================================
class Scene_Map < Scene_Base
  #--------------------------------------------------------------------------
  # * Skrócona metoda - przenoszenie
  #--------------------------------------------------------------------------
  alias csca_autosave_transfer post_transfer
  def post_transfer
    csca_autosave_transfer
    DataManager.csca_autosave(:save) if $game_system.csca_autosave_allowed?(:transfer)
  end
  #--------------------------------------------------------------------------
  # * Skrócona metoda - tworzenie okien
  #--------------------------------------------------------------------------
  alias csca_autosave_create_windows create_all_windows
  def create_all_windows
    csca_autosave_create_windows
    csca_create_autosave_window
  end
  #--------------------------------------------------------------------------
  # * Tworzenie okna autosave
  #--------------------------------------------------------------------------
  def csca_create_autosave_window
    @autosave_window = CSCA_Window_Autosaving.new
  end
  #--------------------------------------------------------------------------
  # * Skrócona metoda - przed przeniesieniem
  #--------------------------------------------------------------------------
  alias csca_autosave_pre_transfer pre_transfer
  def pre_transfer
    @autosave_window.close
    csca_autosave_pre_transfer
  end
  #--------------------------------------------------------------------------
  # * Skrócona metoda - aktualizacja autosave
  #--------------------------------------------------------------------------
  alias csca_autosave_update update
  def update
    csca_autosave_update
    @autosave_window.open if $game_map.autosaving
  end
end # Game_Map
#==============================================================================
# ** Battle Manager
#------------------------------------------------------------------------------
#  Autosaves na koniec walki
# W skrócie: battle_end
#==============================================================================
module BattleManager
  class <<self; alias csca_autosave_battle battle_end; end
  def self.battle_end(result)
    csca_autosave_battle(result)
    DataManager.csca_autosave(:save) if $game_system.csca_autosave_allowed?(:battle)
  end
end # BattleManager
#==============================================================================
# ** Game_Interpreter
#------------------------------------------------------------------------------
#  Autosaves przy zdobyciu/zmianie przedmiotu, broni, złota, pancerza, drużyny.
# W skrócie:: command_125, command_126, command_127, command_128, command_129
#==============================================================================
class Game_Interpreter
  #--------------------------------------------------------------------------
  # * Skrócona metoda - 125
  #--------------------------------------------------------------------------
  alias csca_autosave_125 command_125
  def command_125
    csca_autosave_125
    DataManager.csca_autosave(:save) if $game_system.csca_autosave_allowed?(:gold)
  end
  #--------------------------------------------------------------------------
  # * Skrocona metoda - 126
  #--------------------------------------------------------------------------
  alias csca_autosave_126 command_126
  def command_126
    csca_autosave_126
    DataManager.csca_autosave(:save) if $game_system.csca_autosave_allowed?(:item)
  end
  #--------------------------------------------------------------------------
  # * Skrócona metoda - 127
  #--------------------------------------------------------------------------
  alias csca_autosave_127 command_127
  def command_127
    csca_autosave_127
    DataManager.csca_autosave(:save) if $game_system.csca_autosave_allowed?(:weapon)
  end
  #--------------------------------------------------------------------------
  # * Skrócona metoda - 128
  #--------------------------------------------------------------------------
  alias csca_autosave_128 command_128
  def command_128
    csca_autosave_128
    DataManager.csca_autosave(:save) if $game_system.csca_autosave_allowed?(:armor)
  end
end
#==============================================================================
# ** Game_Player
#------------------------------------------------------------------------------
#  Autosave po określonej liczbie kroków.
# W skrócie: update, initialize
#==============================================================================
class Game_Player < Game_Character
  #--------------------------------------------------------------------------
  # * Skrócona metoda - inicjalizacja autosave
  #--------------------------------------------------------------------------
  alias csca_autosave_init initialize
  def initialize
    csca_autosave_init
    @csca_autosave_steps = 0
  end
  #--------------------------------------------------------------------------
  # * Skrócona metoda - aktualizacja liczby króków, a autosave
  #--------------------------------------------------------------------------
  alias csca_autosave_steps update
  def update
    csca_autosave_steps
    csca_check_autosave_step_count
  end
  #--------------------------------------------------------------------------
  # * Sprawdzanie liczby kroków do autosave
  #--------------------------------------------------------------------------
  def csca_check_autosave_step_count
    if $game_party.steps % CSCA::AUTOSAVE::STEP_COUNT == 0 && $game_system.csca_autosave_allowed?(:steps) &&
        @steps != $game_party.steps
      DataManager.csca_autosave(:save)
      @csca_autosave_steps = $game_party.steps
    end
  end
end
#==============================================================================
# ** CSCA_Window_Autosaving
#------------------------------------------------------------------------------
#  Okno z tekstem 'Zapisywanie...
#==============================================================================
class CSCA_Window_Autosaving < Window_Base
  #--------------------------------------------------------------------------
  # * Inicjalizacja
  #--------------------------------------------------------------------------
  def initialize
    super(0,Graphics.height-fitting_height(1),window_width,fitting_height(1))
    self.opacity = 0
    self.contents_opacity = 0
    @show_count = 0
    refresh
  end
  #--------------------------------------------------------------------------
  # * Szerokość okna
  #--------------------------------------------------------------------------
  def window_width
    return 240
  end
  #--------------------------------------------------------------------------
  # * Aktualizacja ramki
  #--------------------------------------------------------------------------
  def update
    super
    if @show_count > 0
      update_fadein
      @show_count -= 1
    else
      update_fadeout
    end
  end
  #--------------------------------------------------------------------------
  # * Aktualizacja fadein
  #--------------------------------------------------------------------------
  def update_fadein
    self.contents_opacity += 16
  end
  #--------------------------------------------------------------------------
  # * Aktualizacja fadeout
  #--------------------------------------------------------------------------
  def update_fadeout
    self.contents_opacity -= 16
  end
  #--------------------------------------------------------------------------
  # * Pojawianie się okna
  #--------------------------------------------------------------------------
  def open
    $game_map.autosaving = false
    @show_count = 60
    self.contents_opacity = 0
    self
  end
  #--------------------------------------------------------------------------
  # * Znikanie okna
  #--------------------------------------------------------------------------
  def close
    @show_count = 0
    self
  end
  #--------------------------------------------------------------------------
  # * Odświeżanie
  #--------------------------------------------------------------------------
  def refresh
    contents.clear
    contents.font.size = 18
    draw_text(0,0,contents.width,line_height,CSCA::AUTOSAVE::AUTOSAVING)
    contents.font.size = 24
  end
end
#==============================================================================
# ** Game_Map
#------------------------------------------------------------------------------
# Automatyczne zapisywanie?
#==============================================================================
class Game_Map
  attr_accessor :autosaving
end

Screenshots:

Spoiler: (Otwórz)

Spoiler: (Otwórz)

Spoiler: (Otwórz)

Demo:


Dodatkowe informacje:
- Kompatybilny z innymi skryptami CSCA, nie licząc Gameover options, aczkolwiek te opcje zawiera także skrypt AutoSave Plus.
- Aby wykorzystać w grze komercyjnej należy zakupić licencję od autora!
- Jeśli ktoś chciałby wersje tego skryptu TYLKO z 'Kontynuj' w Menu itp. to taką posiadam w swoim projekcie i chętnie użyczę.
- Creditsy wymagane dla autora, polecane dla tłumacza ;P