[VXAce] CSCA AutoSave Plus - Wersja do druku

Spoiler: (Otwórz)
Kod:

=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