Ultima Forum - RGSS3

Napisy Końcowe

Sun, 17 Jun 2018 13:05:52 +0200

~ Napisy Końcowe / Credits ~

Krótki opis:
Wyświetla napisy końcowe (credits). W tle można umieścić dowolną ilość wybranych obrazków.

Autor:
Ayene

Skrypt:

Spoiler: (Otwórz)

Kod:

#============================================================================== 

# Napisy Końcowe [VXAce] / Scene Credits [VXAce]        

#============================================================================== 

# Autor: Ayene 

# www.ultimateam.pl 

# ver. 1.2 [18.01.2012] 

#============================================================================== 

# Skrypt wyświetla napisy końcowe (tzw. Credits). 

# Może zostać wykorzystany również do wyświetlania historii, opisu, itd. 

# Instalacja: Umieść skrypt nad Main. 

#============================================================================== 

# By wywołać napisy wpisz: 

#     SceneManager.call(Scene_Credits) 

#============================================================================== 

module AYENE 

  # Ustawienia czcionki 

  CREDITS_FONT = 'Comic Sans MS'    # nazwa czcionki (folder Fonts) 

  CREDITS_SIZE = 30                 # rozmiar czcionki 

  CREDITS_BOLD = true               # pogrubienie 

  CREDITS_ITALIC = false            # kursywa 

  WLH = 32                          # interlinia 

  # Ustawienia muzyki w tle 

  CREDITS_BGM = ''                  # nazwa pliku z muzyką (folder Audio/BGM) 

  CREDITS_BGM_VOLUME = 100          # głośność 

  # Ustawienia tła obrazkowego (folder Graphics/Pitures)    

  BACKGROUND_IMAGE = ''             # nazwa tła; '' wyłącza tło 

  BACKGROUND_OPACTIY = 255          # przezroczystość tła    

  # Formatowanie tesktu 

  # Poniżej można dodać własne kolory tekstu 

  TEXT_COLOR = { # 'kod' => kolor 

  '' => Color.new(255, 255, 255, 255),  # <- nie usuwać - kolor domyślny 

  '' => Color.new(255, 126, 126, 255), 

  '' => Color.new(255, 253, 92, 255), 

  '' => Color.new(92, 255, 150, 255) 

  } 

  BUTTON_CLOSE = true # włącza możliwość przewinięcia sceny za pomocą przycisku 

  NEXT_SCENE = Scene_Map          # kolejna scena    

  PREVIOUS_SCENE = Scene_Title    # poprzednia scena 

  # Dodawanie obrazków do tekstu 

  # Żeby obrazek nie nachodził na tekst wystarczy - pod linijką z kodem na jego 

  # wyświetlenie - dać większy odstęp. 

  IMAGE = { # 'kod' => nazwa obrazka 

  '' => 'logo', 

  '' => 'ranga',    

  } 

#-------------------------- 

# Tekst 

#-------------------------- 

CREDIT = <<_CREDIT_

Tytuł Gry 

~ Reżyser ~ 

... 

--------------- 

~ Skrypty ~ 

... 

--------------- 

~ Grafika ~ 

... 

--------------- 

~ Dźwięk i muzyka ~ 

... 

--------------- 

~ Mapy ~ 

... 

--------------- 

www.ultimateam.pl 

_CREDIT_

#-------------------------- 

# Koniec tekstu 

#-------------------------- 

end 

#============================================================================== 

# ** Scene_Credits 

#============================================================================== 

class Scene_Credits < Scene_Base 

  include AYENE  

  #-------------------------------------------------------------------------- 

  # * Start 

  #-------------------------------------------------------------------------- 

  def start 

    super    

    if CREDITS_BGM != '' 

      Audio.bgm_play("Audio/BGM/" + CREDITS_BGM, CREDITS_BGM_VOLUME, 100) 

    end 

    create_background 

    create_credits      

  end 

  #-------------------------------------------------------------------------- 

  # * Create Background 

  #-------------------------------------------------------------------------- 

  def create_background 

    if BACKGROUND_IMAGE != '' 

      @background = Sprite.new 

      @background.bitmap = Cache.picture(BACKGROUND_IMAGE) 

      @background.opacity = BACKGROUND_OPACTIY 

    end 

  end  

  #-------------------------------------------------------------------------- 

  # * Create Credits 

  #-------------------------------------------------------------------------- 

  def create_credits 

    color = [] 

    image = [] 

    text = CREDIT.split(/\n/)      

    @credits = Sprite.new 

    @credits.bitmap = Bitmap.new(544, WLH * text.size) 

    @credits.z = 9999 

    @credits.oy = -426      

    text.each_index { |i| 

      color[i] = TEXT_COLOR[0]      

      TEXT_COLOR.each { |st, c| 

        if text[i].include?(st)        

          text[i].sub!(st, '') 

          color[i] = c 

        end          

      } 

      IMAGE.each { |st, im| 

        if text[i].include?(st)        

          text[i].sub!(st, '') 

          image[i] = im 

        end          

      } 

      if image[i] != nil 

        bitmap = Cache.picture(image[i]) 

        cw = bitmap.width 

        ch = bitmap.height 

        src_rect = Rect.new(0, 0, cw, ch) 

        @credits.bitmap.blt((544 - cw) / 2, i*WLH, bitmap, src_rect)          

      end 

      @credits.bitmap.font.name = CREDITS_FONT 

      @credits.bitmap.font.size = CREDITS_SIZE 

      @credits.bitmap.font.bold = CREDITS_BOLD 

      @credits.bitmap.font.italic = CREDITS_ITALIC 

      @credits.bitmap.font.color = color[i] 

      @credits.bitmap.draw_text(0, i*WLH, 544, 32, text[i], 1) 

    } 

  end  

  #-------------------------------------------------------------------------- 

  # * Terminate 

  #-------------------------------------------------------------------------- 

  def terminate 

    super 

    dispose_background 

  end 

  #-------------------------------------------------------------------------- 

  # * Frame Update 

  #-------------------------------------------------------------------------- 

  def update 

    super 

    @credits.oy += 1 

    if BUTTON_CLOSE 

      next_scene if Input.trigger?(Input::C)        

      previous_scene if Input.trigger?(Input::B)                

    end    

    next_scene if @credits.oy >= @credits.bitmap.height 

  end 

  #-------------------------------------------------------------------------- 

  # * Next Scene 

  #-------------------------------------------------------------------------- 

  def next_scene 

    Audio.bgm_fade(1500) if CREDITS_BGM != '' 

    SceneManager.call(NEXT_SCENE) 

  end 

  #-------------------------------------------------------------------------- 

  # * Previous Scene 

  #-------------------------------------------------------------------------- 

  def previous_scene 

    Audio.bgm_fade(1500) if CREDITS_BGM != '' 

    SceneManager.call(PREVIOUS_SCENE) 

  end 

  #-------------------------------------------------------------------------- 

  # * Dispose Background 

  #-------------------------------------------------------------------------- 

  def dispose_background 

    unless @background.nil? 

      @background.bitmap.dispose 

      @background.dispose 

    end 

    @credits.bitmap.dispose 

    @credits.dispose 

  end  

end

Screeny:

Spoiler: (Otwórz)

Dodatkowe informacje:
Skrypt nie zadziała jeżeli po "_CREDIT_" (Linijka 88) jest niepotrzebna spacja.
Skrypt wymaga obrazka logo, którego należy umieścić w folderze "Graphics\Pictures".
Instrukcja jest podana w skrypcie.
Skrypt należy umieścić w edytorze skryptów, pod "Materials".

Przykładowy obrazek logo:

Spoiler: (Otwórz)

Rozdawanie Punktów

Sat, 16 Jun 2018 23:28:55 +0200

~ Rozdawanie punktów co poziom ~

Krótki opis:
Skrypt umożliwia rozwój postaci poprzez zwiększanie jej statystyk dzięki dodatkowym punktom, które otrzymuje po uzyskaniu poziomu.

Autor:
Ayene

Skrypt:

Spoiler: (Otwórz)

Kod:

#============================================================================== 

# Rozdawanie punktów co poziom [VXAce]    

#============================================================================== 

# Autor: Ayene 

# www.ultimateam.pl 

#============================================================================== 

# Skrypt umożliwia rozwój postaci poprzez zwiększanie jej statystyk dzięki 

# dodatkowym punktom, które otrzymuje po uzyskaniu poziomu. 

# Instalacja: Umieść skrypt nad Main. 

#============================================================================== 

# By wywołać okno rozdawania punktów użyj polecenia 'Script' i wpisz: 

#     SceneManager.call(Scene_Upgrade) 

#============================================================================== 

module Ayene 

  POINTS_PER_LEVEL = 5          # liczba punktów co poziom 

  IN_MENU = true                # widoczne w menu 

  COMMAND_UPGRADE = 'Rozdaj'    # nazwa komendy w menu 

end 

#============================================================================== 

# ** Window_Points 

#============================================================================== 

class Window_Points < Window_Selectable 

  #-------------------------------------------------------------------------- 

  # * Object Initialization 

  #     actor : actor 

  #-------------------------------------------------------------------------- 

  def initialize(actor) 

    super(97, 33, 350, 350) 

    @actor = actor 

    refresh 

    activate 

  end 

  #-------------------------------------------------------------------------- 

  # * Actor 

  #-------------------------------------------------------------------------- 

  def actor=(actor) 

    return if @actor == actor 

    @actor = actor 

    refresh 

  end 

  #-------------------------------------------------------------------------- 

  # * Refresh 

  #-------------------------------------------------------------------------- 

  def refresh 

    contents.clear 

    draw_block1   (line_height * 0)    

    draw_horz_line(line_height * 4) 

    draw_block2   (line_height * 5)    

  end 

  #-------------------------------------------------------------------------- 

  # * Draw Block 1 

  #-------------------------------------------------------------------------- 

  def draw_block1(y)    

    draw_actor_face(@actor, 8, y)      

    draw_actor_name(@actor, 150, y + line_height * 0 + 12)    

    draw_actor_level(@actor, 150, y + line_height * 1 + 12) 

    draw_actor_points(@actor, 150, y + line_height * 2 + 12) 

    draw_actor_graphic(@actor, 270, y + line_height * 3) 

  end 

  #-------------------------------------------------------------------------- 

  # * Draw Block 2 

  #-------------------------------------------------------------------------- 

  def draw_block2(y) 

    draw_parameters(32, y) 

  end 

  #-------------------------------------------------------------------------- 

  # * Draw Horizontal Line 

  #-------------------------------------------------------------------------- 

  def draw_horz_line(y) 

    line_y = y + line_height / 2 - 1 

    contents.fill_rect(0, line_y, contents_width, 2, line_color) 

  end 

  #-------------------------------------------------------------------------- 

  # * Line Color 

  #-------------------------------------------------------------------------- 

  def line_color 

    color = normal_color 

    color.alpha = 48 

    color 

  end 

  #-------------------------------------------------------------------------- 

  # * Draw Parameters 

  #     x     : draw spot x-coordinate 

  #     y     : draw spot y-coordinate 

  #-------------------------------------------------------------------------- 

  def draw_parameters(x, y) 

    8.times {|i| draw_actor_param(@actor, x, y + line_height * i, i) } 

  end 

  #-------------------------------------------------------------------------- 

  # * Draw Level 

  #     actor : actor 

  #     x     : draw spot x-coordinate 

  #     y     : draw spot y-coordinate 

  #-------------------------------------------------------------------------- 

  def draw_actor_level(actor, x, y) 

    change_color(system_color) 

    draw_text(x, y, 64, line_height, Vocab::level) 

    change_color(normal_color) 

    draw_text(x + 64, y, 24, line_height, actor.level, 2) 

  end 

  #-------------------------------------------------------------------------- 

  # * Draw Points 

  #     actor : actor 

  #     x     : draw spot x-coordinate 

  #     y     : draw spot y-coordinate 

  #-------------------------------------------------------------------------- 

  def draw_actor_points(actor, x, y) 

    change_color(system_color) 

    draw_text(x, y, 64, line_height, "Punkty") 

    change_color(normal_color) 

    draw_text(x + 64, y, 24, line_height, actor.points, 2) 

  end  

end 

#============================================================================== 

# ** Window_PointsCommand 

#============================================================================== 

class Window_PointsCommand < Window_Command 

  #-------------------------------------------------------------------------- 

  # * Object Initialization 

  #     x : window X coordinate 

  #     y : window Y coordinate 

  #-------------------------------------------------------------------------- 

  def initialize(x, y) 

    super(x, y) 

    @actor = nil 

    self.opacity = 0 

  end 

  #-------------------------------------------------------------------------- 

  # * Actor 

  #-------------------------------------------------------------------------- 

  def actor=(actor) 

    return if @actor == actor 

    @actor = actor 

    refresh 

  end 

  #-------------------------------------------------------------------------- 

  # * Make Command List 

  #-------------------------------------------------------------------------- 

  def make_command_list 

    8.times {|i| add_command('+', :addpoint, commands_enabled)} 

  end  

  #-------------------------------------------------------------------------- 

  # * Commands Enabled 

  #-------------------------------------------------------------------------- 

  def commands_enabled 

    return unless @actor 

    @actor.points > 0 

  end 

  #-------------------------------------------------------------------------- 

  # * Window Width 

  #-------------------------------------------------------------------------- 

  def window_width 

    return 48 

  end 

  #-------------------------------------------------------------------------- 

  # * Alignment 

  #-------------------------------------------------------------------------- 

  def alignment 

    return 1 

  end 

end 

#============================================================================== 

# ** Scene_Upgrade 

#============================================================================== 

class Scene_Upgrade < Scene_MenuBase 

  #-------------------------------------------------------------------------- 

  # * Start processing 

  #-------------------------------------------------------------------------- 

  def start 

    super 

    create_status_window 

    create_command_window 

  end 

  #-------------------------------------------------------------------------- 

  # * Create Status Window 

  #-------------------------------------------------------------------------- 

  def create_status_window 

    @status_window = Window_Points.new(@actor) 

    @status_window.viewport = @viewport 

    @status_window.actor = @actor 

  end 

  #-------------------------------------------------------------------------- 

  # * Create Command Window 

  #-------------------------------------------------------------------------- 

  def create_command_window 

    @command_window = Window_PointsCommand.new(300, 153) 

    @command_window.viewport = @viewport 

    @command_window.actor = @actor 

    @command_window.set_handler(:addpoint, method(:command_add)) 

    @command_window.set_handler(:cancel,   method(:return_scene)) 

    @command_window.set_handler(:pagedown, method(:next_actor)) 

    @command_window.set_handler(:pageup,   method(:prev_actor)) 

  end 

  #-------------------------------------------------------------------------- 

  # * Command Add Points 

  #-------------------------------------------------------------------------- 

  def command_add 

    index = @command_window.index 

    value = index == 0 || index == 1 ? 10 : 1 

    @actor.add_param(index, value) 

    @actor.points -= 1 

    @status_window.refresh 

    @command_window.refresh 

    @command_window.activate 

  end 

  #-------------------------------------------------------------------------- 

  # * On Actor Change 

  #-------------------------------------------------------------------------- 

  def on_actor_change 

    @status_window.actor = @actor 

    @command_window.actor = @actor 

    @command_window.activate 

  end 

end 

#============================================================================== 

# ** Game_Actor 

#============================================================================== 

class Game_Actor < Game_Battler 

  include Ayene 

  #-------------------------------------------------------------------------- 

  # * Public Instance Variables 

  #-------------------------------------------------------------------------- 

  attr_accessor :points  

  #-------------------------------------------------------------------------- 

  # * Setup (alias) 

  #-------------------------------------------------------------------------- 

  alias aye_gamac_setup setup 

  def setup(*args) 

    @points = 0 

    aye_gamac_setup(*args) 

  end 

  #-------------------------------------------------------------------------- 

  # * Level Up (alias) 

  #-------------------------------------------------------------------------- 

  alias aye_gamac_level_up level_up 

  def level_up 

    aye_gamac_level_up 

    @points += POINTS_PER_LEVEL 

  end  

  #-------------------------------------------------------------------------- 

  # * Level Down (alias) 

  #-------------------------------------------------------------------------- 

  alias aye_gamac_level_down level_down 

  def level_down 

    aye_gamac_level_down 

    @points -= [POINTS_PER_LEVEL, @points].min 

  end 

end 

if Ayene::IN_MENU 

#============================================================================== 

# ** Window_MenuCommand 

#============================================================================== 

class Window_MenuCommand < Window_Command 

  #-------------------------------------------------------------------------- 

  # * Add Main Commands (alias) 

  #-------------------------------------------------------------------------- 

  alias aye_wincom_addmaincom add_main_commands 

  def add_main_commands 

    aye_wincom_addmaincom 

    add_command(Ayene::COMMAND_UPGRADE, :upgrade, main_commands_enabled) 

  end 

end 

#============================================================================== 

# ** Scene_Menu 

#============================================================================== 

class Scene_Menu < Scene_MenuBase 

  #-------------------------------------------------------------------------- 

  # * Create Command Window (alias) 

  #-------------------------------------------------------------------------- 

  alias aye_scmen_crcommwin create_command_window 

  def create_command_window 

    aye_scmen_crcommwin 

    @command_window.set_handler(:upgrade,   method(:command_personal))    

  end 

  #-------------------------------------------------------------------------- 

  # * On Personal OK (alias) 

  #-------------------------------------------------------------------------- 

  alias aye_scmen_conperok on_personal_ok 

  def on_personal_ok 

    aye_scmen_conperok 

    case @command_window.current_symbol 

    when :upgrade 

      SceneManager.call(Scene_Upgrade) 

    end 

  end  

end 

end

Screeny:

Spoiler: (Otwórz)

Dodatkowe informacje:
Instrukcja jest podana w skrypcie.
Skrypt należy umieścić w edytorze skryptów, pod "Materials".

Kolor Jakości Przedmiotów

Wed, 13 Jun 2018 13:48:19 +0200

~ Basic Item Quality Colors of Awesome ~

Krótki opis:
Skrypt zmienia kolory nazw wybranych elementów (broni, pancerza, przedmiotu, umiejętności), dzięki czemu możemy podzielić je na epickie, legendarne itp.

Autor:
Leongon

Tłumaczenie:
Shadow

Skrypt:

Spoiler: (Otwórz)

Kod:

module IQC_Configs 

################################################################################​

#                  Basic Item Quality Colors of Awesome VX v1.1                # 

################################################################################​

# Author: Leongon                                                              # 

# Licence: Free for commercial and non-commercial proyects, just credit.       #           

################################################################################​

################################################################################​

# Instrukcje #                                                                 # 

################                                                               # 

#                                                                              # 

# Ustawianie jakości przedmiotu. --------------------------------------------- # 

#                                                                              # 

# Umieść to w notatce w broni,pancerzu,przedmiocie bądź umiejętności:          # 

#                                                                  # 

#  PRZYKŁAD:                                                                   # 

#                                                                    # 

#                                                                              # 

#"jakość" oznacza jakiej jakości jest przedmiot rzadki, epicki czy uber.       # 

#                                                                              # 

# Przypisywanie jakości Przedmiotom   ---------------------------------------- # 

#                                                                              # 

# Poniżej w Obszarze Konfiguracji, znajdziesz liste kolorów od 0 do 31.        # 

# Wprowadź nazwę pomiędzy "" aby stworzyć nowy rodzaj jakości                  # 

#                                                                              # 

################################################################################​

#Obszar konfiguracji # 

###################### 

                     # 

  IQC_quality =      # Nie ruszaj tej lini. 

  {                  # Nie ruszaj tej lini. 

  0 => "",           # 

  1 => "",           # 

  2 => "",           # 

  3 => "",           # 

  4 => "",           # 

  5 => "",           # 

  6 => "",           # 

  7 => "",           # 

  8 => "poor",       # 

  9 => "rare",       # 

  10 => "",          # 

  11 => "",          # 

  12 => "",          # 

  13 => "",          # 

  14 => "",          # 

  15 => "",          # 

  16 => "",          # 

  17 => "",          # 

  18 => "",          # 

  19 => "",          # 

  20 => "legendary", # 

  21 => "",          # 

  22 => "",          # 

  23 => "",          # 

  24 => "uncommon",  # 

  25 => "",          # 

  26 => "",          # 

  27 => "",          # 

  28 => "",          # 

  29 => "",          # 

  30 => "epic",      # 

  31 => ""           # 

  }                  # Nie ruszaj tej lini. 

                     # 

###################### 

#Koniec konfiguracji # 

###################### 

end 

#----------------------------------------------------------------------- 

# Nie edytuj kodu poniżej chyba że wiesz co robisz!                            

#-----------------------------------------------------------------------

module LNR 

  def get_single_for(note_field,tag_name) 

    lines = note_field.split("\n") 

    for line in lines 

      if line[0,1].eql?("<") 

        line2=line.split(/[<> ]/) 

        if line2[1].eql?(tag_name) 

          return line2[2] 

        end 

      end 

    end 

  end 

end 

#-----------------------------------------------------------------------

class Window_Base < Window 

  include LNR 

  include IQC_Configs  

  def draw_item_name(item, x, y, enabled = true, width = 172) 

    return unless item 

    draw_icon(item.icon_index, x, y, enabled) 

    if item.note.include?("
      quality = get_single_for(item.note,"IQC") 

      color = text_color(IQC_quality.index(quality).to_i) 

    else 

      color = normal_color 

    end 

    change_color(color, enabled) 

    draw_text(x + 24, y, width, line_height, item.name) 

  end  

end

Screeny:

Spoiler: (Otwórz)

Dodatkowe informacje:
Kolory które można wykorzystać są powiązane z windowskinem.
Instrukcja jest podana w skrypcie.
Skrypt należy umieścić w edytorze skryptów, pod "Materials".

Postacie z XP do VXA

Sat, 06 Aug 2016 09:36:55 +0200

~ XP Characters on VX/VXAce ~

Krótki opis:
Skrypt pozwala na wczytywanie charsetów z XP do VXA bez użycia conventera wystarczy, że w nazwie charsetu da się symbol "$xp" np "$xpChris".

Autor:
Melosx

Skrypt:

Spoiler: (Otwórz)

Kod:

#==============================================================================

# ** MSX - XP Characters on VX/VXAce

#==============================================================================

# Author: Melosx

# Notes translated by ShinGamix

# http://www.rpgmakervxace.net/index.php?/user/1272-shingamix/

# Version: 1.0

# Compatible with VX and VXAce

#

#==============================================================================

# * Description

# -----------------------------------------------------------------------------

# This script allows you to use xp in vx chara simply inserting the tag

# $ xp

# Before the name of the file.          

# You can then use the normal VX / VXAce along with those of XP.

#

#==============================================================================

# * Instructions

# -----------------------------------------------------------------------------

# Place the script under Materials and above Main. Add to chara of XP

# $ Xp before the tag name.

#

#==============================================================================

#==============================================================================

# ** Sprite_Character

#==============================================================================

class Sprite_Character < Sprite_Base

  def update_bitmap

    if @tile_id != @character.tile_id or

      @character_name != @character.character_name or

      @character_index != @character.character_index

      @tile_id = @character.tile_id

      @character_name = @character.character_name

      @character_index = @character.character_index

      if @tile_id > 0

        sx = (@tile_id / 128 % 2 * 8 + @tile_id % 8) * 32;

        sy = @tile_id % 256 / 8 % 16 * 32;

        self.bitmap = tileset_bitmap(@tile_id)

        self.src_rect.set(sx, sy, 32, 32)

        self.ox = 16

        self.oy = 32

      else

        self.bitmap = Cache.character(@character_name)

        sign = @character_name[/^[!$]./]

        if sign != nil and sign.include?('$')

          @cw = bitmap.width / 3

          @ch = bitmap.height / 4

        else

          @cw = bitmap.width / 12

          @ch = bitmap.height / 8

        end

        if @character_name != nil and @character_name.include?('$xp')

          @cw = bitmap.width / 4

          @ch = bitmap.height / 4

        end

        self.ox = @cw / 2

        self.oy = @ch

      end

    end

  end

  def update_src_rect

    if @character_name != nil and @character_name.include?('$xp')

      if @tile_id == 0

        pattern = @character.pattern > 0 ? @character.pattern - 1 : 3

        sx = pattern * @cw

        sy = (@character.direction - 2) / 2 * @ch

        self.src_rect.set(sx, sy, @cw, @ch)

      end

    else

      if @tile_id == 0

        index = @character.character_index

        pattern = @character.pattern < 3 ? @character.pattern : 1

        sx = (index % 4 * 3 + pattern) * @cw

        sy = (index / 4 * 4 + (@character.direction - 2) / 2) * @ch

        self.src_rect.set(sx, sy, @cw, @ch)

      end

    end

  end

end

#==========================================================================

# ** Window_Base

#==========================================================================

class Window_Base < Window

  def draw_character(character_name, character_index, x, y)

    return if character_name == nil

    bitmap = Cache.character(character_name)

    sign = character_name[/^[!$]./]

    if character_name != nil and character_name.include?('$xp')

      cw = bitmap.width / 4

      ch = bitmap.height / 4

      n = character_index

      src_rect = Rect.new(0, 0, cw, ch)

    else

      if sign != nil and sign.include?('$')

        cw = bitmap.width / 3

        ch = bitmap.height / 4

      else

        cw = bitmap.width / 12

        ch = bitmap.height / 8

      end

      n = character_index

      src_rect = Rect.new((n%4*3+1)*cw, (n/4*4)*ch, cw, ch)

    end

    self.contents.blt(x - cw / 2, y - ch, bitmap, src_rect)

  end

end

Zoom eventów i postaci

Sat, 06 Aug 2016 06:50:44 +0200

~ Character Sprite Zooming ~

Krótki opis:
Skrypt pozwala nam na zmianę zoomu postaci, eventu na skale jaką chcemy począwszy od najmniejszej do do nieskończonej liczby tylko ostrzegam jak się ustawi zoom na 10 to postać potrafi zająć całą mapę proponuję coś koło od 0.500 do 3.

wszystko jest opisane w instrukcji miłej zabawy.

Autor:
Hime

Skrypt:

Spoiler: (Otwórz)

Kod:

=begin

#===============================================================================​

 Title: Character Sprite Zooming

 Author: Hime

 Date: Feb 3, 2015

 URL: http://himeworks.com/2014/12/character-sprite-zooming/

--------------------------------------------------------------------------------

 ** Change log

 Feb 3, 2015

   - modified script to support zoom animations

 Dec 6, 2014

   - Initial release

--------------------------------------------------------------------------------   

 ** Terms of Use

 * Free to use in non-commercial projects

 * Contact me for commercial use

 * No real support. The script is provided as-is

 * Will do bug fixes, but no compatibility patches

 * Features may be requested but no guarantees, especially if it is non-trivial

 * Credits to Hime Works in your project

 * Preserve this header

--------------------------------------------------------------------------------

 ** Description

 This script allows you to control the zoom-level for character sprites, which

 includes the player, followers, events, and the default vehicles.

 Due to the visual nature of this script, while followers are also supported,

 they won't display correctly. This means that your followers will appear to be

 glued to each other and the player because that is how movement works.

 Note that the engine supports many different ways of drawing character

 sprites. This script only supports character *sprites*, rather than character

 images.

--------------------------------------------------------------------------------

 ** Installation

 In the script editor, place this script below Materials and above Main

--------------------------------------------------------------------------------

 ** Usage

 -- Events --

 To change event sprite zooming on the map, use one of the script calls

   zoom_event_sprite(ID, zoom)

   zoom_event_sprite(ID, zoom, duration)

   zoom_event_sprite(ID, zoom, duration, wait)

   zoom_event_sprite(ID, zoom, duration, wait, zoom_y)

   zoom_event_sprite(ID, zoom, duration, wait, zoom_y, duration_y)

 Where the ID is the ID of the event, and the zoom is a percentage. 1 is 100%,

 0.5 is 50% (half size), and 2 is 200% (double size)

 The duration allows you to create a zoom animation over-time. It is

 specified in frames and can be any integer that is 0 or higher.

 If `wait` is true, then the event will stop processing commands until the zoom

 animation is complete. If it is false, it will continue to run even though

 the animation is still going.

 When only one `zoom` value is specified, it assumes both the width and height

 will be zoomed proportionally.

 You can specify separate zoom behavior for each direction by passing in

 additional arguments.

 -- Players and Followers --

 To change player sprite zooming, use one of the script calls

   zoom_player_sprite(zoom)

   zoom_player_sprite(zoom, duration)

   zoom_player_sprite(zoom, duration, wait)

   zoom_player_sprite(zoom, duration, wait, zoom_y)

   zoom_player_sprite(zoom, duration, wait, zoom_y, duration_y)

 -- Vehicles --

 To change player sprite zooming, use one of the script calls

   zoom_vehicle_sprite(type, zoom)

   zoom_vehicle_sprite(type, zoom, duration)

   zoom_vehicle_sprite(type, zoom, duration, wait)

   zoom_vehicle_sprite(type, zoom, duration, wait, zoom_y)

   zoom_vehicle_sprite(type, zoom, duration, wait, zoom_y, duration_y)

 These are the vehicles that are available

   :ship

   :boat

   :airship

--------------------------------------------------------------------------------

 ** Examples

 Zoom event 3 to double the size

   zoom_event_sprite(3, 2)

 Zoom player and followers to half-size, over 60 frames

   zoom_player_sprite(true, 0.5, 60)

 Stretch ship's width by 2 and shrink height to half.

 Width will change in 30 frames, height will change in 60 frames. The

 event will not wait for the animation.

   zoom_vehicle_sprite(:ship, 2, 30, false, 0.5, 60)

#===============================================================================​

=end

$imported = {} if $imported.nil?

$imported[:TH_CharacterSpriteZoom] = true

#===============================================================================​

# ** Rest of script

#===============================================================================​

class Sprite_Character < Sprite_Base

  alias :th_character_sprite_zoom_update_other :update_other

  def update_other

    th_character_sprite_zoom_update_other  

    self.zoom_x = @character.zoom_x

    self.zoom_y = @character.zoom_y

  end  

end

class Game_Character

  attr_reader :zoom_x

  attr_reader :zoom_y

  attr_reader :target_zoom_duration

  attr_reader :target_zoom_duration_y

  alias :th_character_sprite_zoom_init_public_members :init_public_members

  def init_public_members

    th_character_sprite_zoom_init_public_members

    @zoom_x = 1.0

    @zoom_y = 1.0

    @target_zoom_duration = 0

    @target_zoom_duration_y = 0  

    @is_zooming = false

  end

  def setup_zoom(zoom, zoom_duration, zoom_y=nil, zoom_duration_y=nil)    

    @target_zoom = zoom

    @target_zoom_y = zoom_y || zoom

    p @target_zoom_y

    @target_zoom_duration = zoom_duration

    @target_zoom_duration_y = zoom_duration_y || zoom_duration

    @is_zooming = true

  end

  alias :th_character_sprite_zooming_update :update

  def update

    th_character_sprite_zooming_update

    update_zoom

  end

  def update_zoom

    return unless @is_zooming

    dx = @target_zoom_duration

    if @zoom_x == @target_zoom

      @target_zoom_duration = 0

    elsif dx == 0

      @zoom_x = @target_zoom

    elsif dx > 0      

      @zoom_x = (@zoom_x * (dx - 1) + @target_zoom) / dx

      @target_zoom_duration -= 1

    end

    dy = @target_zoom_duration_y

    if @zoom_y == @target_zoom_y

      @target_zoom_duration_y = 0

    elsif dy == 0

      @zoom_y = @target_zoom_y

    elsif dy > 0

      @zoom_y = (@zoom_y * (dy - 1) + @target_zoom_y) / dy

      @target_zoom_duration_y -= 1

    end

    @iz_zooming = false if dx == 0 && dy == 0

  end

end

class Game_Interpreter

  def zoom_character_sprite(chara, zoom_x, duration, wait, zoom_y, duration_y)

    chara.setup_zoom(zoom_x, duration, zoom_y, duration_y)

    Fiber.yield while chara.target_zoom_duration > 0 || chara.target_zoom_duration_y > 0 if wait

  end  

  def zoom_event_sprite(event_id, zoom_x=1.0, duration=0, wait=true, zoom_y=nil, duration_y=nil)

    event = get_character(event_id)

    zoom_character_sprite(event, zoom_x, duration, wait, zoom_y, duration_y)    

  end

  def zoom_player_sprite(zoom_x=1.0, duration=0, wait=true, zoom_y=nil, duration_y=nil)

    zoom_character_sprite($game_player, zoom_x, duration, wait, zoom_y, duration_y)

    $game_player.followers.each do |follower|

      zoom_character_sprite(follower, zoom_x, duration, wait, zoom_y, duration_y)

    end

  end

  def zoom_vehicle_sprite(type, zoom_x=1.0, duration=60, wait=true, zoom_y=nil, duration_y=nil)

    case type

    when :ship

      vehicle = $game_map.ship

    when :boat

      vehicle = $game_map.boat

    when :airship

      vehicle = $game_map.airship

    end

    zoom_character_sprite(vehicle, zoom_x, duration, wait, zoom_y, duration_y)

  end

end

Zmiana rozdzielczości gry !

Thu, 04 Aug 2016 21:36:44 +0200

~ Game resolution for ACE ~

Krótki opis:
Skrypt po dodaniu nad Main dodaje nam możliwość zmiany rozdzielczości ekranu tak aby pasowała dla nas rozdzielczość jaką chcemy osiągnąć jedyny minus jest taki że jeżeli ekran dopasujemy do rozdzielczości 1024 x 728 to musimy też przeskalować tile gdyż będą widoczne czarne marginesy miłej zabawy.

Autor:
Nightcrawler

Tłumaczenie:
Nightcrawler

Skrypt:

Spoiler: (Otwórz)

Kod:

#==============================================================================

# ■ Game_Resolution

#------------------------------------------------------------------------------

# Change the game window to whatever you want!

# Keep the width and height a multiple of 32.

#==============================================================================

module Resolution

  $game_screen_width = 640

  $game_screen_height = 480

  $game_tiles_width = 20

  $game_tiles_height = 15

  #======================================

  # Resize the window

  #======================================

  def self.resize(w,h)

        Graphics.resize_screen(w,h)

        $game_screen_width = w

        $game_screen_height = h

        $game_tiles_width = w / 32

        $game_tiles_height = h / 32

  end

end

#==============================================================================

# ■ Sprite_Timer

#------------------------------------------------------------------------------

# Timer for display sprites. Monitor the $ game_timer, the state of the Sprite

# To change automatically.

#==============================================================================

class Sprite_Timer

  #--------------------------------------------------------------------------

  # ● Initialize

  #--------------------------------------------------------------------------

  def initialize(viewport)

        super(viewport)

        create_bitmap

        update

  end

  #--------------------------------------------------------------------------

  # ● Create bitmap

  #--------------------------------------------------------------------------

  def create_bitmap

        self.bitmap = Bitmap.new(96, 48)

        self.bitmap.font.size = 32

        self.bitmap.font.color.set(255, 255, 255)

  end

   #--------------------------------------------------------------------------

  # ● Update

  #--------------------------------------------------------------------------

  def update

        super

        update_bitmap

        update_position

        update_visibility

  end

  #--------------------------------------------------------------------------

  # ● Update position

  #--------------------------------------------------------------------------

  def update_position

        self.x = $game_screen_width - self.bitmap.width

        self.y = 0

        self.z = 200

  end

end

#==============================================================================

# ■ Game_Map

#------------------------------------------------------------------------------

# A class to handle the map. It has features such as scrolling and passable determining.

# Instance of this class is referenced by $ game_map.

#==============================================================================

class Game_Map

  def update(main = false)

        refresh if @need_refresh

        update_interpreter if main

        update_scroll

        update_events

        update_vehicles

        update_parallax

        @screen.update

  end

  #--------------------------------------------------------------------------

  # ● Setup Scroll

  #--------------------------------------------------------------------------

  def setup_scroll

        @scroll_direction = 2

        @scroll_rest = 0

        @scroll_speed = 4

  end

  #--------------------------------------------------------------------------

  # ● Set display position

  #--------------------------------------------------------------------------

  def set_display_pos(x, y)

        x = [0, [x, $game_screen_width - $game_tiles_width].min].max unless loop_horizontal?

        y = [0, [y, $game_screen_height - $game_tiles_height].min].max unless loop_vertical?

        @display_x = (x + $game_screen_width) % $game_screen_width

        @display_y = (y + $game_screen_height) % $game_screen_height

        @parallax_x = x

        @parallax_y = y

  end

  #--------------------------------------------------------------------------

  # ● Parallax X check

  #--------------------------------------------------------------------------

  def parallax_ox(bitmap)

        if @parallax_loop_x

          @parallax_x * 16

        else

          w1 = [bitmap.width - $game_screen_width, 0].max

          w2 = [$game_screen_width * 32 - $game_screen_width, 1].max

          @parallax_x * 16 * w1 / w2

        end

  end

  #--------------------------------------------------------------------------

  # ● Adjust X

  #--------------------------------------------------------------------------

  def adjust_x(x)

        if loop_horizontal? && x < @display_x - ($game_screen_width - $game_tiles_width) / 2

          x - @display_x + $game_screen_width

        else

          x - @display_x

        end

  end

  #--------------------------------------------------------------------------

  # ● Adjust Y

  #--------------------------------------------------------------------------

  def adjust_y(y)

        if loop_vertical? && y < @display_y - ($game_screen_height - $game_tiles_height) / 2

          y - @display_y + $game_screen_height

        else

          y - @display_y

        end

  end

  #--------------------------------------------------------------------------

  # ● ループ補正後の X 座標計算

  #--------------------------------------------------------------------------

  def round_x(x)

        loop_horizontal? ? (x + $game_screen_width) % $game_screen_width : x

  end

  #--------------------------------------------------------------------------

  # ● ループ補正後の Y 座標計算

  #--------------------------------------------------------------------------

  def round_y(y)

        loop_vertical? ? (y + $game_screen_height) % $game_screen_height : y

  end

  #--------------------------------------------------------------------------

  # ● 上にスクロール

  #--------------------------------------------------------------------------

  def scroll_up(distance)

        if loop_vertical?

          @display_y += @map.height - distance

          @display_y %= @map.height

          @parallax_y -= distance if @parallax_loop_y

        else

          last_y = @display_y

          @display_y = [@display_y - distance, 0].max

          @parallax_y += @display_y - last_y

        end

  end

end

class Game_Player < Game_Character

  #--------------------------------------------------------------------------

  # ● 画面中央の X 座標

  #--------------------------------------------------------------------------

  def center_x

        if $game_screen_width == 640

          ($game_screen_width / 32 - 1) / 1.0

          else

        ($game_screen_width / 32 - 1) / 2.0

        end

  end

  #--------------------------------------------------------------------------

  # ● 画面中央の Y 座標

  #--------------------------------------------------------------------------

  def center_y

        if $game_screen_height == 480

        ($game_screen_height / 32 - 1) / 1.0

  else

        ($game_screen_height / 32 - 1) / 2.0

        end

  end

  #--------------------------------------------------------------------------

  # ● 画面中央に来るようにマップの表示位置を設定

  #--------------------------------------------------------------------------

  def center(x, y)

        $game_map.set_display_pos(x - center_x, y - center_y)

  end

        #--------------------------------------------------------------------------

  # ● フレーム更新

  #--------------------------------------------------------------------------

  def update

        last_real_x = @real_x

        last_real_y = @real_y

        last_moving = moving?

        move_by_input

        super

        update_scroll(last_real_x, last_real_y)

        update_vehicle

        update_nonmoving(last_moving) unless moving?

        @followers.update

  end

end

class Window_Base

  #--------------------------------------------------------------------------

  # ● ステートおよび強化／弱体のアイコンを描画

  #--------------------------------------------------------------------------

  def draw_actor_icons(actor, x, y, width = 96)

        icons = (actor.state_icons + actor.buff_icons)[0, width / 24]

  end

end

Screeny:

Spoiler: (Otwórz)

Demo:

Dodatkowe informacje:
Po dodaniu skryptu wchodzimy w main i dodajemy linijkę "Resolution.resize(W,H)" gdzie W oznacza szerokość, H wysokość np (1024, 723)

Skrypt na 2 graczy

Wed, 27 May 2015 17:31:56 +0200

~ Skrypt dodający drugiego gracza. ~

Krótki opis:
Skrypt dodaje drugiego gracza, wyglądającego tak samo jak gracz nr 1 (nie wiem jak to zmienić )

Autor:
Tsukihime

Tłumaczenie:
krakoman

Skrypt:

Spoiler: (Otwórz)

Kod:

################################################################################​

#                        2 Players Script by Tsukihime                         #

#                           Tłumaczenie PL: krakoman                           #

#                                                                              #

#                              Specjalnie dla http://forum.ultimateam.pl/      #

################################################################################​

# OPIS:                                                                        #

#Skrypt dodaje drugiego gracza, wyglądającego jak gracz pierwszy.              #

#Sterowanie możesz zmienić w linijkach 52-57                                   #

#HAVE FUN                                                                      #

################################################################################​

module DataManager

  class << self

    alias :th_multiplayer_create_game_objects :create_game_objects

    alias :th_multiplayer_make_save_contents :make_save_contents

    alias :th_multiplayer_extract_save_contents :extract_save_contents

  end

  def self.create_game_objects

    th_multiplayer_create_game_objects

    $game_player2 = Game_Multiplayer.new

  end

  def self.make_save_contents

    contents = th_multiplayer_make_save_contents

    contents[:player2] = $game_player2

    contents

  end

  def self.extract_save_contents(contents)

    th_multiplayer_extract_save_contents(contents)

    $game_player2 = contents[:player2]

  end

  def self.setup_new_game

    create_game_objects

    $game_party.setup_starting_members

    $game_map.setup($data_system.start_map_id)

    $game_player.moveto($data_system.start_x, $data_system.start_y)

    $game_player.refresh

    $game_player2.moveto($data_system.start_x, $data_system.start_y)

    $game_player2.refresh

    Graphics.frame_count = 0

  end

end

class Game_Multiplayer < Game_Player

  DOWN = Input::Y # S na klawiaturze (krok w dół)

  LEFT = Input::X # A na klawiaturze (krok w lewo)

  RIGHT = Input::Z # D na klawiaturze (krok w prawo)

  UP = Input::R # W na klawiaturze (krok do góry)

  ENTER = Input::L # Q na klawiaturze (interakcja)

  RUN = Input::A # Shift na klawiaturze (sprint)

  def move_by_input

    return unless movable?

    return if $game_map.interpreter.running?

    if Input.press?(DOWN)

      move_straight(2)

    elsif Input.press?(LEFT)

      move_straight(4)

    elsif Input.press?(RIGHT)

      move_straight(6)

    elsif Input.press?(UP)

      move_straight(8)

    end

  end

  def update_nonmoving(last_moving)

    return if $game_map.interpreter.running?

    if last_moving

      $game_party.on_player_walk

      return if check_touch_event

    end

    if movable? && Input.trigger?(ENTER)

      return if get_on_off_vehicle

      return if check_action_event

    end

    update_encounter if last_moving

  end

end

class Spriteset_Map

  alias :th_multiplayer_create_characters :create_characters

  def create_characters

    th_multiplayer_create_characters

    @character_sprites.push(Sprite_Character.new(@viewport1, $game_player2))

  end

end

class Scene_Map < Scene_Base

  alias :th_multiplayer_map_update :update

  def update

    th_multiplayer_map_update

    $game_player2.update if $game_player2

  end

end

Dodatkowe informacje:
Domyślne sterowanie dla gracza nr 2:
W -krok do góry
A -krok w lewo
S -krok w dół
D -krok w prawo
Q -przycisk akcji
SHIFT- sprint

Gracz 2 pojawia się na spawnie drużyny.
Gracze nie blokują się na mapie.

Dziennik Misji

Sun, 17 May 2015 13:39:23 +0200

~ Quest Journal ~

Krótki opis:
Skrypt dodaje do gry dziennik misji, który pozwala sprawdzać w każdym momencie nasze aktualne, zakończone i nieudane misje. Jest on dość prosty w obsłudze jeśli ktoś choć odrobinę zna angielski. Przetłumaczyłem chwilowo tylko część wyświetlaną, a komentarze postaram się przetłumaczyć w najbliższym czasie. Jeśli ktoś nie będzie umiał ustawić questów, polecam pobrać demo i otworzyć w rpg makerze... Skrypt jest bardzo długi więc daje link. Dodałem tutorial pokazujący jak używać tego skryptu, link w dodatkowych informacjach.

Autor:
Modern Algebra

Skrypt:

Spoiler: (Otwórz)

Screeny:

Spoiler: (Otwórz)

Demo:

Dodatkowe informacje:
Demo nie jest moje, jego autorem jest Brady http://rmrk.net/index.php/topic,45127.ms...#msg528094
Strona skryptu: http://rmrk.net/index.php?topic=45127.0
Link do tutoriala zrobionego przeze mnie: http://forum.ultimateam.pl/Thread-VXAce-...isji--2292

Bestiariusz

Sat, 16 May 2015 23:18:11 +0200

~ Fantasy Bestiary ~

Krótki opis:
Ten skrypt dodaje do gry bestiariusz, czyli taką księgę potworów. Skrypt jest bardzo długi, więc daje link do niego. Jest on w bardzo niewielkim stopniu przetłumaczony przeze mnie. Postaram się przetłumaczyć najważniejsze komentarze, ale dzisiaj już nie mam czasu...

Autor:
Shadowmaster

Skrypt:

Spoiler: (Otwórz)

Screeny:

Spoiler: (Otwórz)

Volume Control in Menu

Fri, 03 Oct 2014 14:01:01 +0200

Krótki opis:
Skrypt dodaje opcje "volume settings" która pozwala na zmianę stopnia głośności BGM BGS SE itd

Autor:
Crisis

Tłumaczenie:
Z japońskiego na angielski Crisis

Skrypt:

Spoiler: (Otwórz)

Kod:

# encoding: utf-8

#===============================================================================​

# �¡ Volume Control For RGSS3

#-------------------------------------------------------------------------------

#�@2011/12/01�@Ru/‚Þ‚Á‚­R

#-------------------------------------------------------------------------------

#�@Adds the ability to change volume control. 

#

#�@�œ The following methods are added to the Audio Module

#�@Audio.volBGM �c�c Maximum BGM volume setting.

#�@Audio.volBGS �c�c Maximum BGS volume setting. 

#�@Audio.volSE  �c�c Maximum SE volume setting. 

#�@Audio.volME  �c�c  Maximum ME volume setting. 

#�@Audio.volBGM=�”’l �c�cSet BGM maximum volume (0-100)

#�@Audio.volBGM=�”’l �c�c Set BGS maximum volume (0-100)

#�@Audio.volSE=�”’l  �c�c Set SE maximum volume (0-100)

#�@Audio.volME=�”’l  �c�c Set ME maximum volume (0-100)

#

#�@�œ Volume control is added to the main menu.

#

#-------------------------------------------------------------------------------

# �yKnown Issues�z

#�@Created before VXAce's official release so unable to properly test. 

#-------------------------------------------------------------------------------

#==============================================================================

# �œ Settings

#==============================================================================

module HZM_VXA

  module AudioVol

    # Display Volume Control on Main Menu?

    # �@true  �c�c Display.

    # �@false �c�c Don't Display.

    MENU_FLAG = true

    # Volume Control Name in Main Menu.

    MENU_NAME        = "Volume Settings" 

    # Volume Control Settings Name.

    CONFIG_BGM_NAME  = "BGM"

    CONFIG_BGS_NAME  = "BGS"

    CONFIG_SE_NAME   = "SE"

    CONFIG_ME_NAME   = "ME"

    CONFIG_EXIT_NAME = "Exit"

    # Volume Change Variation.

    # ADD_VOL_NORMAL �c�c Variation of Left/Right Keys.

    # ADD_VOL_HIGH   �c�c Variation of LR Key. 

    ADD_VOL_NORMAL = 5

    ADD_VOL_HIGH   = 25

  end

end

#==============================================================================

# �ª �@ Settings Above �@ �ª

# �«     Script Below     �«

#==============================================================================

# Additonal Methods.

# class << Audio means we open up the Audio module and all methods defined 

# get defined on self (that is, the Audio module itself)

class << Audio

  def volBGM=(vol)

    @hzmVolBGM = normalize_volume(vol)

  end

  def volBGS=(vol)

    @hzmVolBGS = normalize_volume(vol)

  end

  def volSE=(vol)

    @hzmVolSE = normalize_volume(vol)

  end

  def volME=(vol)

    @hzmVolME = normalize_volume(vol)

  end

  def volBGM

    @hzmVolBGM.nil? ? @hzmVolBGM = 100 : @hzmVolBGM

  end

  def volBGS

    @hzmVolBGS.nil? ? @hzmVolBGS = 100 : @hzmVolBGS

  end

  def volSE

    @hzmVolSE.nil? ? @hzmVolSE = 100 : @hzmVolSE

  end

  def volME

    @hzmVolME.nil? ? @hzmVolME = 100 : @hzmVolME

  end

  # Make sure volume does not go over 100 or under 0.

  def normalize_volume(vol)

    vol = 100 if vol > 100

    vol = 0   if vol < 0

    vol

  end    

  # Playback

  alias hzm_Vol_Audio_bgm_play bgm_play

  def bgm_play(filename, volume=100, pitch=100, pos=0)

    volume = self.volBGM * volume.to_f / 100

    hzm_Vol_Audio_bgm_play(filename, volume, pitch, pos)

  end

  alias hzm_Vol_Audio_bgs_play bgs_play

  def bgs_play(filename, volume=100, pitch=100)

    volume = self.volBGS * volume.to_f / 100

    hzm_Vol_Audio_bgs_play(filename, volume, pitch)

  end

  alias hzm_Vol_Audio_se_play se_play

  def se_play(filename, volume=100, pitch=100)

    volume = self.volSE * volume.to_f / 100

    hzm_Vol_Audio_se_play(filename, volume, pitch)

  end

  alias hzm_Vol_Audio_me_play me_play

  def me_play(filename, volume=100, pitch=100)

    volume = self.volME * volume.to_f / 100

    hzm_Vol_Audio_me_play(filename, volume, pitch)

  end

end

# Add To Menu.

if HZM_VXA::AudioVol::MENU_FLAG

  class Window_MenuCommand

    alias hzm_Vol_Window_MenuCommand_add_original_commands add_original_commands

    def add_original_commands

      hzm_Vol_Window_MenuCommand_add_original_commands

      add_command(HZM_VXA::AudioVol::MENU_NAME, :hzm_vxa_vol)   

    end

  end

  class Scene_Menu

    alias hzm_Vol_create_command_window create_command_window

    def create_command_window

      hzm_Vol_create_command_window

      @command_window.set_handler(:hzm_vxa_vol, method(:hzm_vxa_vol))

    end

    def hzm_vxa_vol

      SceneManager.call(HZM_VXA::AudioVol::Scene_VolConfig)

    end

  end

end

# Volume Change Window

module HZM_VXA

  module AudioVol

    class Window_VolConfig < Window_Command

      def initialize

        super(0, 0)

        self.x = (Graphics.width - self.window_width)/2

        self.y = (Graphics.height - self.window_height)/2

      end

      def make_command_list

        add_command(HZM_VXA::AudioVol::CONFIG_BGM_NAME,  :bgm)

        add_command(HZM_VXA::AudioVol::CONFIG_BGS_NAME,  :bgs)

        add_command(HZM_VXA::AudioVol::CONFIG_SE_NAME,   :se)

        add_command(HZM_VXA::AudioVol::CONFIG_ME_NAME,   :me)

        add_command(HZM_VXA::AudioVol::CONFIG_EXIT_NAME, :cancel)

      end

      def draw_item(index)

        super

        return unless index < 4

        case index

        when 0

          vol = Audio.volBGM

        when 1

          vol = Audio.volBGS

        when 2

          vol = Audio.volSE

        when 3

          vol = Audio.volME

        end

        draw_text(item_rect_for_text(index), vol, 2) # Draws vol after text, right aligned

      end

      def volAdd(index, val)

        case index

        when 0

          Audio.volBGM += val

          now = RPG::BGM.last 

          Audio.bgm_play('Audio/BGM/' + now.name, now.volume, now.pitch, now.pos) if now

        when 1

          Audio.volBGS += val

        when 2

          Audio.volSE += val

        when 3

          Audio.volME += val

        end

        Sound.play_cursor

        redraw_item(index)

      end

      def cursor_left(wrap = false)

        volAdd(@index, -HZM_VXA::AudioVol::ADD_VOL_NORMAL)

      end

      def cursor_right(wrap = false)

        volAdd(@index,  HZM_VXA::AudioVol::ADD_VOL_NORMAL)

      end

      def cursor_pageup

        volAdd(@index,  -HZM_VXA::AudioVol::ADD_VOL_HIGH)

      end

      def cursor_pagedown

        volAdd(@index,  HZM_VXA::AudioVol::ADD_VOL_HIGH)

      end

    end

    class Scene_VolConfig < Scene_MenuBase

      def start

        super

        @command_window = Window_VolConfig.new

        @command_window.viewport = @viewport

        @command_window.set_handler(:cancel,   method(:return_scene))

      end

      def terminate

        super

        @command_window.dispose

      end

    end

  end

end

# Reading/Saving

class << DataManager

  alias hzm_Vol_make_save_contents make_save_contents

  def make_save_contents

    contents = hzm_Vol_make_save_contents

    contents[:hzm_vxa_vol]   = {

      :bgm => Audio.volBGM,

      :bgs => Audio.volBGS,

      :se  => Audio.volSE,

      :me  => Audio.volME

    }

    contents

  end

  alias hzm_Vol_extract_save_contents extract_save_contents

  def extract_save_contents(contents)

    hzm_Vol_extract_save_contents(contents)

    Audio.volBGM = contents[:hzm_vxa_vol][:bgm]

    Audio.volBGS = contents[:hzm_vxa_vol][:bgs]

    Audio.volSE  = contents[:hzm_vxa_vol][:se]

    Audio.volME  = contents[:hzm_vxa_vol][:me]

  end

end

Screeny:

Spoiler: (Otwórz)

Demo:

Dodatkowe informacje:
Wkleić nad main

Skrypt na screenshot z całej mapy !

Sat, 09 Aug 2014 21:51:03 +0200

Krótki opis:
Skrypt pozwala robić screen z całej mapy.
Wystarczy wstawić go do projektu i w trakcie testowania gry nacisnąć F7.
Skrypt utworzy screen z całej mapy.

Autor:
Hime

Skrypt:

Spoiler: (Otwórz)

Kod:

=begin

#===============================================================================​

 Title: Map Screenshot

 Author: Hime

 Date: Apr 15, 2013

--------------------------------------------------------------------------------

 ** Change log

 Apr 15, 2013

   - updated script to use GDI+ interface

   - added support for region map overlay and passage map overlay

 Apr 6, 2013

   - fixed bug where drawing events crashed the game

 Apr 2, 2013

   - map data is now setup by an instance of Game_Map, to account for custom

     map scripts adding to the map

 Jul 27

   - Export dirNames are now optional

 May 28

   - updated overlay mapping compatibility to draw the overlays 

     based on the player's current position

   - fixed issue where import hash was commented out

   - Added support for Yami's overlay mapping

 May 24, 2012

   - fixed large characters

   - some optimizations for calculating bounds and dimensions

 May 5, 2012

   - fixed waterfall autotile

   - added screenshot feature

 May 4, 2012

   - fixed tiles with alpha channel

   - fixed shadows

   - fixed wall autotiles

 May 1, 2012

   - fixed wall autotile, although there is still an issue with some tiles

 Apr 29, 2012

   - fixed shadow map drawing

   - added region highlighting

   - added damage tile highlighting

 Apr 28, 2012

   - Initial Release

------------------------------------------------------------------------------

 ** Description

 This script allows you to take a full image of any of your game's maps

 and export. An image of the map is referred to as a "mapshot" (as opposed to

 screenshot).

 The script provides various configuration options to control what kinds of

 things you want to see on your map, such as events, vehicles, region ID's, or

 specific tile properties.

------------------------------------------------------------------------------

 ** Usage

 The default key for taking a mapshot is F7. This can be changed in the

 configuration section.

 To take a mapshot, first start the game, and then hit F7.

 A message will appear informing you that a mapshot was successfully taken.

 Alternatively, you can use script calls to take mapshots.

    Map_Saver.new(map_id).export

 Aside from exporting images, you are able to use the image that the

 map saver captures.

   ms = Map_Saver.new(map_id)

   bmp = ms.map_image

 This gives you a reference to a Bitmap object that contains an image of

 your map.

--------------------------------------------------------------------------------

  ** Credits

  Cremno

    -GDI+ interface code

  Cidiomar

    -for drawing autotiles and shadows, 

    -providing efficient bmp and png exporters

  Moon

    -auto-tile related info

  Mephistox

    -testing and suggestions

================================================================================​

=end

$imported = {} if $imported.nil?

$imported["TH_MapSaver"] = true

#===============================================================================​

# ** Configuration

#===============================================================================​

module TH

  module Map_Saver

    #Mapshot options. This takes an image of the entire map

    Mapshot_Button = Input::F7

    Mapshot_Scale = 1

    #Screenshot options. This takes an image of the visible map

    Screenshot_Button = Input::F6

    Screenshot_Scale = 1

    #Folder that the map will be exported to

    Mapshot_Directory = "Mapshots"

    Screenshot_Directory = "Screenshots"

    # format you want to export to. You should stick with png.

    # Options: [bmp, png] 

    Export_Format = "png"

    # Sprite draw options

    Draw_Events = false

    Draw_Player = false

    Draw_Followers = false

    Draw_Vehicles = false

    #Should shadows be drawn? What color?

    Draw_Shadow = true

    Shadow_Color = Color.new(0, 0, 0, 128)

    # Should regions be drawn? Requires "Region Overlay Map" script

    Draw_Regions = false

    # Should passage settings be drawn? Requires "Passage Overlay Map" script

    Draw_Passages = false

    #Should damage tiles be highlighted? What color?

    Highlight_Damage = true

    Damage_Color = Color.new(128, 0, 0, 128)

  end

end

#==============================================================================

# ** Module: Map_Tiles

# Contains data and methods useful for working with maps and tiles

#==============================================================================

module Map_Tiles

  AUTOTILE_PARTS = [[18,17,14,13], [ 2,14,17,18], [13, 3,17,18], [ 2, 3,17,18],

                    [13,14,17, 7], [ 2,14,17, 7], [13, 3,17, 7], [ 2, 3,17, 7],

                    [13,14, 6,18], [ 2,14, 6,18], [13, 3, 6,18], [ 2, 3, 6,18],

                    [13,14, 6, 7], [ 2,14, 6, 7], [13, 3, 6, 7], [ 2, 3, 6, 7],

                    [16,17,12,13], [16, 3,12,13], [16,17,12, 7], [12, 3,16, 7], 

                    [10, 9,14,13], [10, 9,14, 7], [10, 9, 6,13], [10, 9, 6, 7],

                    [18,19,14,15], [18,19, 6,15], [ 2,19,14,15], [ 2,19, 6,15],

                    [18,17,22,21], [ 2,17,22,21], [18, 3,22,21], [ 2, 3,21,22],

                    [16,19,12,15], [10, 9,22,21], [ 8, 9,12,13], [ 8, 9,12, 7],

                    [10,11,14,15], [10,11, 6,15], [18,19,22,23], [ 2,19,22,23],

                    [16,17,20,21], [16, 3,20,21], [ 8,11,12,15], [ 8, 9,20,21],

                    [16,19,20,23], [10,11,22,23], [ 8,11,20,23], [ 0, 1, 4, 5]]

  WATERFALL_PIECES = [[ 2, 1, 6, 5], [ 0, 1, 4, 5], [ 2, 3, 6, 7], [0, 3, 4, 7]]

  WALL_PIECES =  [[10, 9, 6, 5], [ 8, 9, 4, 5], [ 2, 1, 6, 5], [ 0, 1, 4, 5],

                  [10,11, 6, 7], [ 8,11, 4, 7], [ 2, 3, 6, 7], [ 0, 3, 4, 7],

                  [10, 9,14,13], [ 8, 9,12,13], [ 2, 1,14,13], [ 0, 1,12,13],

                  [10,11,14,15], [8, 11,12,15], [ 2, 3,14,15], [ 0, 3,12,15]]

  A1_TILES = [[0, 0], [0, 96], [192, 0], [192, 96],

               [256, 0], [448, 0], [256, 96], [448, 96],

               [0, 192], [192, 192], [0, 288], [192, 288],

               [256, 192], [448, 192], [256, 288], [448, 288]]

  #--------------------------------------------------------------------------

  # * Checks if a tile is a wall

  #--------------------------------------------------------------------------

  def is_wall?(data)

    return true if data.between?(2288, 2335)

    return true if data.between?(2384, 2431)

    return true if data.between?(2480, 2527)

    return true if data.between?(2576, 2623)

    return true if data.between?(2672, 2719)

    return true if data.between?(2768, 2815)

    return true if data.between?(4736, 5119)

    return true if data.between?(5504, 5887)

    return true if data.between?(6272, 6655)

    return true if data.between?(7040, 7423)

    return true if data > 7807

    false

  end

  #--------------------------------------------------------------------------

  # * Checks if a tile is roof

  #--------------------------------------------------------------------------

  def is_roof?(data)

    return true if data.between?(4352, 4735)

    return true if data.between?(5120, 5503)

    return true if data.between?(5888, 6271)

    return true if data.between?(6656, 7039)

    return true if data.between?(7424, 7807)

    false

  end  

  #--------------------------------------------------------------------------

  # * Checks if a tile is soil

  #--------------------------------------------------------------------------

  def is_soil?(data)

    return true if data.between?(2816, 4351) && !is_table?(data)

    return true if data > 1663 && !is_stair?(data)

    false

  end    

  #--------------------------------------------------------------------------

  # * Checks if a tile is a stair

  #--------------------------------------------------------------------------

  def is_stair?(data)

     return true if data.between?(1541, 1542)

     return true if data.between?(1549, 1550)

     return true if data.between?(1600, 1615)

     false

  end

  #--------------------------------------------------------------------------

  # * Checks if a tile is a table

  #--------------------------------------------------------------------------

  def is_table?(data)

    return true if data.between?(3152, 3199)

    return true if data.between?(3536, 3583)

    return true if data.between?(3920, 3967)

    return true if data.between?(4304, 4351)

    false

  end

  #--------------------------------------------------------------------------

  # * The tileset to be used

  #--------------------------------------------------------------------------

  def tileset

    $data_tilesets[@tileset_id]

  end

  #--------------------------------------------------------------------------

  # * Region ID

  #--------------------------------------------------------------------------

  def region_id(x, y)

    valid?(x, y) ? @map.data[x, y, 3] >> 8 : 0

  end

  #--------------------------------------------------------------------------

  # * Gets all of the tiles for each layer at position x,y

  #--------------------------------------------------------------------------

  def layered_tiles(x, y)

    [2, 1, 0].collect {|z| @map.data[x, y, z] }

  end

  def layered_tiles_flag?(x, y, bit)

    layered_tiles(x, y).any? {|tile_id| tileset.flags[tile_id] & bit != 0 }

  end

  def valid?(x, y)

    x >= 0 && x < width && y >= 0 && y < height

  end

  def damage_floor?(x, y)

    valid?(x, y) && layered_tiles_flag?(x, y, 0x100)

  end

  #--------------------------------------------------------------------------

  # * Specifies which type of autotile is used

  #--------------------------------------------------------------------------

  def auto_tile(id)

    id / 48

  end

  #--------------------------------------------------------------------------

  # * Specifies the specific arrangement of autotiles used

  #--------------------------------------------------------------------------

  def auto_index(id)

    id % 48

  end

  #--------------------------------------------------------------------------

  # * Put the auto-tile pieces together

  #--------------------------------------------------------------------------

  def make_autotile(rects, sx, sy)

    @tile.clear

    for i in 0...4

      @auto_rect.x = (rects[i] % 4) * 16 + sx

      @auto_rect.y = (rects[i] / 4) * 16 + sy

      @tile.blt((i % 2) * 16,(i / 2) * 16, @tilemap, @auto_rect)

    end

  end

  #--------------------------------------------------------------------------

  # * Get auto-tile A1 tiles

  #--------------------------------------------------------------------------

  def autotile_A1(tile_id)

    @tilemap = @bitmaps[0]

    autotile = tile_id / 48

    auto_id = tile_id % 48

    sx, sy = A1_TILES[autotile]

    if is_wall?(tile_id + 2048)

      rects = WATERFALL_PIECES[auto_id]

    else  

      rects = AUTOTILE_PARTS[auto_id]

    end

    make_autotile(rects, sx, sy)

  end

  #--------------------------------------------------------------------------

  # * Get auto-tile A2 tiles.

  # 64x96 tiles, 8 per row, 4 rows

  #--------------------------------------------------------------------------

  def autotile_A2(tile_id)

    autotile = tile_id / 48

    auto_id = tile_id % 48

    @tilemap = @bitmaps[1]

    sx = (autotile % 8) * 64

    sy = (autotile / 8 % 4) * 96

    rects = AUTOTILE_PARTS[auto_id]

    make_autotile(rects, sx, sy)

  end

  #--------------------------------------------------------------------------

  # * Get auto-tile A3 tiles.

  # 64x64 tiles, 8 per row, 4 rows

  #--------------------------------------------------------------------------

  def autotile_A3(tid)

    @tilemap = @bitmaps[2]

    sx = (auto_tile(tid) % 8) * 64

    sy = (auto_tile(tid) / 8 % 4) * 64

    rects = WALL_PIECES[auto_index(tid)]

    make_autotile(rects, sx, sy)

  end

  #--------------------------------------------------------------------------

  # * Get auto-tile A4 tiles (walls)

  #--------------------------------------------------------------------------

  def autotile_A4(tile_id)

    @tilemap = @bitmaps[3]

    autotile = tile_id / 48

    auto_id = tile_id % 48

    sx = (autotile % 8) * 64

    sy = (autotile / 16 * 160) + (autotile / 8 % 2) * 96

    if is_wall?(tile_id + 5888)

      rects = WALL_PIECES[auto_id]

    else

      rects = AUTOTILE_PARTS[auto_id]

    end 

    make_autotile(rects, sx, sy)

  end

  #--------------------------------------------------------------------------

  # * Get auto-tile A5 tiles (normal)

  #--------------------------------------------------------------------------

  def autotile_A5(tile_id)

    @tilemap = @bitmaps[4]

    sx = (tile_id) % 8 * tilesize

    sy = (tile_id) / 8 * tilesize

    @src_rect.set(sx, sy, tilesize, tilesize)

    @tile.clear

    @tile.blt(0, 0, @tilemap, @src_rect)

  end

  #--------------------------------------------------------------------------

  # * Get normal tiles B, C, D, E

  #--------------------------------------------------------------------------

  def normal_tile(tile_id)

    @tilemap = @bitmaps[5 + tile_id / 256]

    sx = (tile_id / 128 % 2 * 8 + tile_id % 8) * tilesize;

    sy = (tile_id % 256 / 8 % 16) * tilesize;

    @src_rect.set(sx, sy, tilesize, tilesize)

    @tile.clear

    @tile.blt(0, 0, @tilemap, @src_rect)

  end

  #--------------------------------------------------------------------------

  # * Get bitmap for the specified tile id

  #--------------------------------------------------------------------------

  def get_bitmap(id)

    if id < 1024

      normal_tile(id)

    elsif id < 1664

      autotile_A5(id - 1536)

    elsif id < 2816

      autotile_A1(id - 2048)

    elsif id < 4352

      autotile_A2(id - 2816)

    elsif id < 5888

      autotile_A3(id - 4352)

    else

      autotile_A4(id - 5888)

    end

  end

end

#==============================================================================

# ** 

#==============================================================================

class Game_Player < Game_Character

  alias :th_mapsaver_update :update

  def update

    th_mapsaver_update

    if Input.trigger?(TH::Map_Saver::Mapshot_Button)

      s = Map_Saver.new($game_map.map_id)

      s.set_scale(TH::Map_Saver::Mapshot_Scale)

      s.mapshot

    end

    if Input.trigger?(TH::Map_Saver::Screenshot_Button)

      s = Map_Saver.new($game_map.map_id)

      s.set_scale(TH::Map_Saver::Screenshot_Scale)

      s.screenshot

    end

  end

end

class Game_Vehicle < Game_Character

  attr_reader :map_id

end

class Game_Map

  attr_reader :map

end

#==============================================================================

# ** 

#==============================================================================

class Map_Saver

  include TH::Map_Saver

  include Map_Tiles

  #--------------------------------------------------------------------------

  # * Constants

  #--------------------------------------------------------------------------

  SHADOW_COLOR = TH::Map_Saver::Shadow_Color

  DAMAGE_COLOR = TH::Map_Saver::Damage_Color

  #--------------------------------------------------------------------------

  # * Public instance variables

  #--------------------------------------------------------------------------

  attr_reader :map_image

  def initialize(map_id=$game_map.map_id, x=$game_player.x, y=$game_player.y)

    @scale = 1

    @local_x = x

    @local_y = y

    @screen_local = false

    @shadow_bitmap = Bitmap.new(128, 128)

    @draw_layer0 = true

    @draw_layer1 = true

    @draw_layer2 = true

    @draw_events = Draw_Events

    @draw_vehicles = Draw_Vehicles

    @draw_player = Draw_Player

    @draw_followers = Draw_Followers

    @draw_shadow = Draw_Shadow

    @draw_damage = Highlight_Damage

    @draw_regions = Draw_Regions

    @draw_passages = Draw_Passages

    @tile = Bitmap.new(32, 32) #stores the current tile to be drawn

    @tilemap = nil

    @src_rect = Rect.new

    @auto_rect = Rect.new(0, 0, tilesize / 2, tilesize/ 2) #constant

    @tile_rect = Rect.new(0, 0, tilesize, tilesize)        #constant

  end

  def load_tilesets

    bitmaps = []

    tileset.tileset_names.each_with_index do |name, i|

      bitmaps[i] = Cache.tileset(name)

    end

    return bitmaps

  end

  #--------------------------------------------------------------------------

  # * Refresh, possibly with a new map

  #--------------------------------------------------------------------------

  def redraw(map_id=$game_map.map_id, x=$game_player.x, y=$game_player.y)

    @map_image.dispose if @map_image

    @map_id = map_id

    @local_x = x

    @local_y = y

    @game_map = Game_Map.new

    @game_map.setup(map_id)

    @map = @game_map.map

    @map_info = $data_mapinfos[map_id]

    @screen = $game_map.screen

    @tileset_id = @game_map.tileset.id

    @bitmaps = load_tilesets

    get_bounds

    @map_image = Bitmap.new(@width * tilesize, @height * tilesize)

    draw_map

    scale_map if @scale != 1

  end

  #--------------------------------------------------------------------------

  # * Pre-process. These will never change when drawing the map. 

  #--------------------------------------------------------------------------

  def get_bounds

    @start_x = start_x

    @start_y = start_y

    @end_x = end_x

    @end_y = end_y

    @width = width

    @height = height

    @tilesize = tilesize

  end

  def screen_tile_x

    Graphics.width / 32

  end

  def screen_tile_y

    Graphics.height / 32

  end

  #--------------------------------------------------------------------------

  # * Sets the scale for the map

  #--------------------------------------------------------------------------

  def set_scale(scale)

    @scale = scale

  end

  #--------------------------------------------------------------------------

  # * Size of a tile

  #--------------------------------------------------------------------------

  def tilesize

    32

  end

  #--------------------------------------------------------------------------

  # * Width and height of the map, both locally and globally

  #--------------------------------------------------------------------------

  def width

    end_x - @start_x

  end

  def height

    end_y - @start_y

  end

  #--------------------------------------------------------------------------

  # * Starting and end positions, relative to the screen or map

  #--------------------------------------------------------------------------

  def start_x

    @screen_local ? [[$game_player.x - screen_tile_x / 2, @map.width - screen_tile_x].min, 0].max : 0

  end

  def start_y

    @screen_local ? [[$game_player.y - screen_tile_y / 2, @map.height - screen_tile_y].min, 0].max : 0

  end

  def end_x

    @screen_local ? [[screen_tile_x, @local_x + screen_tile_x / 2 + 1].max, @map.width].min : @map.width

  end

  def end_y

    @screen_local ? [[screen_tile_y, @local_y + screen_tile_y / 2 + 1].max, @map.height].min : @map.height

  end

  #--------------------------------------------------------------------------

  # * Draw tile onto image. x and y values are absolute coords. They should

  # be re-mapped based on the start_x and start_y values

  #--------------------------------------------------------------------------

  def draw_tile(x, y, tile, rect)

    ox = (x - @start_x) * tilesize

    oy = (y - @start_y) * tilesize

    @map_image.blt(ox, oy, tile, rect)

  end

  #--------------------------------------------------------------------------

  # * Get bitmap for the specified character

  #--------------------------------------------------------------------------

  def get_character_bitmap(name)

    charmap = Cache.character(name)

    sign = name[/^[\!\$]./]

    if sign && sign.include?('$')

      cw = charmap.width / 3

      ch = charmap.height / 4

    else

      cw = charmap.width / 12

      ch = charmap.height / 8

    end

    return charmap, cw, ch

  end

  #--------------------------------------------------------------------------

  # * Draw the character onto the tile

  #--------------------------------------------------------------------------

  def set_character_bitmap(character, x, y)

    charmap, cw, ch = get_character_bitmap(character.character_name)

    index = character.character_index

    pattern = character.pattern < 3 ? character.pattern : 1

    sx = (index % 4 * 3 + pattern) * cw

    sy = (index / 4 * 4 + (character.direction - 2) / 2) * ch

    @src_rect.set(sx, sy, cw, ch)

    x -= cw / (@tilesize * 2) if cw >= @tilesize

    y -= ch / (@tilesize * 2) if ch >= @tilesize  

    draw_tile(x, y, charmap, @src_rect)

  end

  #--------------------------------------------------------------------------

  # * create the shadow map

  #--------------------------------------------------------------------------

  def make_shadow_map

    for s in 0 ... 16

      x = s % 4

      y = s / 4

      if s & 0b1000 == 0b1000

        @shadow_bitmap.fill_rect(x*tilesize+16, y*@tilesize+16, 16, 16, SHADOW_COLOR)

      end

      if s & 0b0100 == 0b0100

        @shadow_bitmap.fill_rect(x*tilesize, y*@tilesize+16, 16, 16, SHADOW_COLOR)

      end

      if s & 0b0010 == 0b0010

        @shadow_bitmap.fill_rect(x*tilesize+16, y*@tilesize, 16, 16, SHADOW_COLOR)

      end

      if s & 0b0001 == 0b0001

        @shadow_bitmap.fill_rect(x*tilesize, y*@tilesize, 16, 16, SHADOW_COLOR)

      end

    end

  end

  def draw_parallax

    image = Cache.parallax(@map.parallax_name)

    @src_rect.set(0, 0, image.width, image.height)

    @map_image.blt(0, 0, image, @src_rect)

  end

  #--------------------------------------------------------------------------

  # * Draw the shadow map

  #--------------------------------------------------------------------------

  def draw_shadow_map

    for x in @start_x ... @end_x

      for y in @start_y ... @end_y

      _x, _y = x*@tilesize, y*@tilesize

        s = @map.data[x, y, 3]  & 0b1111

        if s != 0

          x_ = (s % 4) * @tilesize

          y_ = (s / 4) * @tilesize

          @src_rect.set(x_, y_, @tilesize, @tilesize)

          draw_tile(x, y, @shadow_bitmap, @src_rect)

        end

      end

    end

  end

  #--------------------------------------------------------------------------

  # * Draw the specified layer

  #--------------------------------------------------------------------------

  def draw_layer(layer)

    for x in @start_x ... @end_x

      for y in @start_y ... @end_y

        _x, _y = x*@tilesize, y*@tilesize

        tile_id = @map.data[x, y, layer]

        next if tile_id == 0

        get_bitmap(tile_id)

        draw_tile(x, y, @tile, @tile_rect)

      end

    end

  end

  #-----------------------------------------------------------------------------

  # Draw game regions

  #-----------------------------------------------------------------------------

  def draw_regions

    if $imported["TH_RegionOverlay"]

      image = SceneManager.scene.instance_variable_get(:@spriteset).instance_variable_get(:@re​gion_map).bitmap

      @src_rect.set(@start_x * tilesize, @start_y * tilesize, image.width, image.height)

      @map_image.blt(0, 0, image, @src_rect, 255)

    end

  end

  def draw_passages

    if $imported["TH_OverlayPassageMap"]

      image = SceneManager.scene.instance_variable_get(:@spriteset).instance_variable_get(:@pa​ssage_map).bitmap

      @src_rect.set(@start_x * tilesize, @start_y * tilesize, image.width, image.height)

      @map_image.blt(0, 0, image, @src_rect, 255)

    end

  end

  #--------------------------------------------------------------------------

  # * Draw the game player

  #--------------------------------------------------------------------------

  def draw_player

    set_character_bitmap($game_player, $game_player.x, $game_player.y) if @map_id == $game_map.map_id

  end

  def draw_followers

  end

  #--------------------------------------------------------------------------

  # * Draw map events

  #--------------------------------------------------------------------------

  def draw_events

    @map.events.values.each do |event|

      id = event.pages[0].graphic.tile_id

      char_name = event.pages[0].graphic.character_name

      if id > 0

        normal_tile(id)

        draw_tile(event.x, event.y, @tilemap, @src_rect)

      elsif char_name != ""

        set_character_bitmap(event.pages[0].graphic, event.x, event.y)

      end

    end

  end

  #--------------------------------------------------------------------------

  # * Draw map vehicles

  #--------------------------------------------------------------------------

  def draw_vehicles

    $game_map.vehicles.each do |vehicle|

      set_character_bitmap(vehicle, vehicle.x, vehicle.y,) if @map_id == vehicle.map_id

    end

  end

  #--------------------------------------------------------------------------

  # * Draw map sprites

  #--------------------------------------------------------------------------

  def draw_sprites

    draw_events if @draw_events

    draw_vehicles if @draw_vehicles

    draw_player if @draw_player

    draw_followers if @draw_followers

  end

  #--------------------------------------------------------------------------

  # * Highlight damage tiles

  #--------------------------------------------------------------------------

  def draw_damage

    @tile.clear

    @tile.fill_rect(0, 0, @tilesize, @tilesize, DAMAGE_COLOR)

    @src_rect.set(0, 0, @tilesize, @tilesize)

    for x in @start_x ... @end_x

      for y in @start_y ... @end_y

        _x, _y = x*@tilesize, y*@tilesize

        if damage_floor?(x, y)

          draw_tile(x, y, @tile, @src_rect)

        end

      end

    end

  end

  def draw_screen_effects

  end

  #--------------------------------------------------------------------------

  # * Draw the map

  #--------------------------------------------------------------------------

  def draw_map

    make_shadow_map if @draw_shadow

    draw_parallax

    draw_layer(0)

    draw_layer(1)

    draw_shadow_map

    draw_layer(2)

    draw_damage if @draw_damage

    draw_regions if @draw_regions

    draw_passages if @draw_passages

    draw_sprites

    draw_screen_effects

  end

  #--------------------------------------------------------------------------

  # * Scale the map

  #--------------------------------------------------------------------------

  def scale_map

    nw = @width * @scale

    nh = @height * @scale

    @src_rect.set(0, 0, @width, @height)

    scaled_map = Bitmap.new(nw, nh)

    scaled_rect = Rect.new(0, 0, nw, nh)

    scaled_map.stretch_blt(scaled_rect, @map_image, @src_rect)

    @map_image = scaled_map

  end

  #--------------------------------------------------------------------------

  # * Take a mapshot of the map

  #--------------------------------------------------------------------------

  def mapshot

    @screen_local = false

    redraw

    export(TH::Map_Saver::Mapshot_Directory)

    $game_message.add("Mapshot taken")

  end

  #--------------------------------------------------------------------------

  # * Take a screenshot of the map

  #--------------------------------------------------------------------------

  def screenshot

    @screen_local = true

    redraw

    export(TH::Map_Saver::Screenshot_Directory)

    $game_message.add("Screenshot taken")

  end

  #--------------------------------------------------------------------------

  # * Get the format to export to

  #--------------------------------------------------------------------------

  def get_format

    TH::Map_Saver::Export_Format

  end

  #--------------------------------------------------------------------------

  # * Export the map to a file

  #--------------------------------------------------------------------------

  def export(dirName="")

    format = get_format

    #name = @map.display_name != "" ? @map.display_name : @map_info.name

    name = sprintf("Map%03d" %[@map_id])

    Dir.mkdir(dirName) unless File.directory?(dirName)

    name = 

    filename = "%s\\%s.%s" %[dirName, name, format]

    t1 = Time.now

    @map_image.save(filename)

    t2 = Time.now

    $game_message.add("Exported in %f seconds" %[t2 - t1])

  end

end

class Bitmap

  def save(filename, options = {})

    options.merge!(format: File.extname(filename)[1..-1].to_sym)

    retval = false

    #bitmap = Gdiplus::Bitmap.new(:hbitmap, hbitmap)

    #bitmap = Gdiplus::Bitmap.new(:gdidib, *gdidib)

    # this seems to be the fastest one (RGSS 3.0.1, Windows 8 64-bit)

    bitmap = Gdiplus::Bitmap.new(:scan0, width, height, scan0)

    if bitmap

      retval = bitmap.save(:file, filename, options[:format])

      bitmap.dispose

    end

    retval

  end

private

  def _data_struct(offset = 0)

    @_data_struct ||= (DL::CPtr.new((object_id << 1) + 16).ptr + 8).ptr

    (@_data_struct + offset).ptr.to_i

  end

  def gdidib

     [_data_struct(8), _data_struct(16)]

  end

  def hbitmap

    _data_struct(44)

  end

  def scan0

    _data_struct(12)

  end

end

# ★ GDI+ interface

# ★★★★★★★★★★★★

#

# Author : Cremno

#

module Gdiplus

  DLL = 'gdiplus.dll'

  def self.get_function name, import, export = 'L'

    Win32API.new DLL, name, import, export

  end

  FUNCTIONS = {

    GdiplusStartup: get_function('GdiplusStartup', 'PPP'),

    GdiplusShutdown: get_function('GdiplusShutdown', 'P', 'V'),

    GdipDisposeImage: get_function('GdipDisposeImage', 'P'),

    GdipSaveImageToFile: get_function('GdipSaveImageToFile', 'PPPP'),

    GdipCreateBitmapFromGdiDib: get_function('GdipCreateBitmapFromGdiDib', 'LLP'),

    GdipCreateBitmapFromHBITMAP: get_function('GdipCreateBitmapFromHBITMAP', 'LLP'),

    GdipCreateBitmapFromScan0: get_function('GdipCreateBitmapFromScan0', 'LLLLPP')

  }

  @@token = [0].pack('I')

  def self.token

    @@token

  end

  @@clsids = {}

  def self.clsids

    @@clsids

  end

  def self.gen_clsids

    return unless @@clsids.empty?

    func = Win32API.new('rpcrt4.dll', 'UuidFromString', 'PP', 'L')

    {

      bmp:  '557cf400-1a04-11d3-9a73-0000f81ef32e',

      jpeg: '557cf401-1a04-11d3-9a73-0000f81ef32e',

      gif:  '557cf402-1a04-11d3-9a73-0000f81ef32e',

      tiff: '557cf405-1a04-11d3-9a73-0000f81ef32e',

      png:  '557cf406-1a04-11d3-9a73-0000f81ef32e'

    }.each_pair do |k, v|

      clsid = [0].pack('I')

      func.call(v, clsid)

      @@clsids[k] = clsid

    end

    @@clsids[:jpg] = @@clsids[:jpeg]

    @@clsids[:tif] = @@clsids[:tiff]

  end

  # TODO: prepend prefix (Gdip or Gdiplus) automatically

  def self.call(*args)

    name = args.shift

    func = FUNCTIONS[name]

    v = func.call(*args)

    if v && v != 0

      msgbox "GDI+ error: #{v}\n\nFunction: #{name}\nArguments: #{args.inspect}"

      false

    else

      true

    end

  end

  def self.startup

    call :GdiplusStartup, @@token, [1, 0, 0, 0].pack('L4'), 0

  end

  def self.shutdown

    call :GdiplusShutdown, @@token

  end

  class Image

    attr_reader :instance

    def initialize

      @instance = 0

      true

    end

    def save(destination, *args)

      case destination

      when :file

        filename = args.shift << "\0"

        filename.encode!('UTF-16LE')

        argv = [:GdipSaveImageToFile, filename, Gdiplus.clsids[args.shift], 0]

      else

        raise ArgumentError, "unknown GDI+ image destination: #{source}"

      end

      argv.insert(1, @instance)

      Gdiplus.call *argv

    end

    def dispose

      Gdiplus.call :GdipDisposeImage, @instance

    end

  end

  class Bitmap < Image

    def initialize source, *args

      case source

      when :gdidib

        argv = [:GdipCreateBitmapFromGdiDib, args.shift, args.shift]

      when :hbitmap

        argv = [:GdipCreateBitmapFromHBITMAP, args.shift, 0]

      when :scan0

        w = args.shift

        h = args.shift

        argv = [:GdipCreateBitmapFromScan0, w, h, w * -4, 0x26200a, args.shift]

      else

        raise ArgumentError, "unknown GDI+ bitmap source: #{source}"

      end

      argv.push([0].pack('I'))

      retval = Gdiplus.call *argv

      @instance = retval ? argv.last.unpack('I').first : 0

      retval

    end

  end

end

if Gdiplus.startup

  Gdiplus.gen_clsids

  class << SceneManager

    alias_method :run_wo_gdip_shutdown, :run

    def run

      run_wo_gdip_shutdown

      Gdiplus.shutdown

    end

  end

end

#==============================================================================

# * Compatibility add-ons

#==============================================================================

#Yami overlays

if $imported["YSE-OverlayMapping"]

  class Map_Saver

    def draw_overlay_map_ground

      filename = YSA::OVERLAY::GROUND

      filename += $game_map.map_id.to_s

      filename += "-" + $game_variables[YSA::OVERLAY::GROUND_VARIABLE].to_s

      p filename

      image = Cache.overlay(filename)

      @src_rect.set(@start_x*tilesize, @start_y*tilesize, image.width, image.height)

      @map_image.blt(0, 0, image, @src_rect)

    end

    def draw_overlay_map_parallax

      filename = YSA::OVERLAY::PARALLAX

      filename += $game_map.map_id.to_s

      filename += "-" + $game_variables[YSA::OVERLAY::PARALLAX_VARIABLE].to_s

      image = Cache.overlay(filename)

      @src_rect.set(@start_x*tilesize, @start_y*tilesize, image.width, image.height)

      @map_image.blt(0, 0, image, @src_rect)

    end

    def draw_overlay_map_light

      filename = YSA::OVERLAY::LIGHT

      filename += $game_map.map_id.to_s

      filename += "-" + $game_variables[YSA::OVERLAY::LIGHT_VARIABLE].to_s

      image = Cache.overlay(filename)

      @src_rect.set(@start_x*tilesize, @start_y*tilesize, image.width, image.height)

      @map_image.blt(0, 0, image, @src_rect, 10)

    end

    def draw_overlay_map_shadow

      filename = YSA::OVERLAY::SHADOW

      filename += $game_map.map_id.to_s

      filename += "-" + $game_variables[YSA::OVERLAY::SHADOW_VARIABLE].to_s

      image = Cache.overlay(filename)

      @src_rect.set(@start_x*tilesize, @start_y*tilesize, image.width, image.height)

      @map_image.blt(0, 0, image, @src_rect, 10)

    end

    alias :th_map_overlay_draw_map :draw_map

    def draw_map

      th_map_overlay_draw_map

      draw_overlay_map_ground if $game_switches[YSA::OVERLAY::GROUND_SWITCH] 

      draw_overlay_map_parallax if $game_switches[YSA::OVERLAY::PARALLAX_SWITCH] 

      draw_overlay_map_shadow if $game_switches[YSA::OVERLAY::SHADOW_SWITCH]

      draw_overlay_map_light if $game_switches[YSA::OVERLAY::LIGHT_SWITCH]

    end

  end

end

if $imported["TH_AreaOverlay"]

  class Map_Saver

    def draw_overlay_area_map

      image = SceneManager.scene.instance_variable_get(:@spriteset).instance_variable_get(:@ar​ea_map).bitmap

      @src_rect.set(@start_x * tilesize, @start_y * tilesize, image.width, image.height)

      @map_image.blt(0, 0, image, @src_rect, 255)

    end

    alias :th_area_overlay_draw_map :draw_map

    def draw_map

      th_area_overlay_draw_map

      draw_overlay_area_map

    end

  end

end

CSCA AutoSave Plus

Sat, 10 May 2014 13:10:18 +0200

~ 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:

=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 <
  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)

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

Pominięcie ekranu tytułowego

Sat, 03 May 2014 16:22:14 +0200

~ Pominięcie ekranu tytułowego [VXACE] ~

Krótki opis:
Skrypt pozwala na pominięcie ekranu tytułowego poprzez zamienienie kodu w Scene_Title na ten podany poniżej.

Autor:
Avenger_B7 http://caveirarpgmaker.weebly.com/

Tłumaczenie:
ReetzO

Skrypt:

Spoiler: (Otwórz)

Dodatkowe informacje:
1)Nie działa w RPG Maker VX :(
2)Przenosi nas na mapę z Pozycją Startową Gracza
3)Credisty mile widziane dla AUTORA

Wyłączenie battlebacks (tło mapy)

Tue, 01 Apr 2014 19:11:31 +0200

~ Battlebacks ~

Krótki opis:
Ten skrypt pozwala na wyłączenie battlebacks,zamiast niego jest tło mapy.
Według mnie jest on bardzo przydatny ponieważ gdy mamy np. mapkę
jakiejś biblioteki to w rtp nie znajdziemy battlebacksa pasującego do niej.
Szczególnie polecam ten skrypt gdy używacie sid viev battle system.
INSTRUKCJA:
Jedyne co trzeba ustawić to przełącznik jest ON
Domyślny przełącznik w skrypcie to 20

Autor:
Xypher (Skrypt podesłał Diablo i postanowiłem się nim podzielić)

Tłumaczenie:
Tłumaczenie jest niepotrzebne

Skrypt:

Spoiler: (Otwórz)

Screeny:

Spoiler: (Otwórz)

Demo:

Screeny ewenualnie podeślę jutro.

Player Wideo

Mon, 24 Mar 2014 10:07:37 +0100

~ EST - SOV Video Player ~

Krótki opis:
Kodeki do poprawnego działania http://www.download.hr/download-k-lite-m...-pack.html

Wklejam tutaj bardzo ciekawy skrypt jaki znalazłem w necie, a mianowicie skrypy który pozwala nam na odtworzenie filmików w grze. Jak napisał autor podstawowe zastosowanie może być gdy np: podczas walki przyzywamy meteoryty to dajemy filmik jak lecą jakieś kozackie meteoryty i mamy świetny efekt. Filmiki można wyświetlać w fullscreenie lub w rogu ekranu mniejszy ekran.

Tutaj możliwości wypunktowane:
- Włączanie wideo na mapie
- Włączanie wideo podczas używania umiejętności
- Włączanie wideo podczas używania przedmiotu
- Zatrzymywanie wideo
- Wyłączanie wideo
- Włączanie wideo przed ekranem tytułowym gry (zobacz konfiguracje)

Instrukcja używania skryptu w jego treści, w języku angielskim.

Autor:
Estriole wersja VX, przekonwertował na Ace:SuperOverlord

Tłumaczenie:
brak

Skrypt:

Spoiler: (Otwórz)

Kod:

#==============================================================================

#

# [ACE]EST_SOV_Video_Player ++ Conversion

#

# v1.4

#==============================================================================

# Author : Estriole

# (Conversion to ace and improving)

# VX version author: SuperOverlord

#

# also credit Crystal Noel for solution for title that have encoding problem character

# also credit ruin for fixes he made to this script.

#

# History :

# version 1.4 2013.05.16 - apply fixes from ruin. typo error and ability to use

#                          play video using battle event page.

# version 1.3 2013.03.05 - create configuration for people that have encoding character

#                          problem with their title. ex: Pokémon Ace.

#                          set the IGNORE_TITLE to true inside module Sov::Video

# version 1.2 2012.09.27 - made if game at fullscreen automaticly become windowed

# version 1.1 2012.09.25 - some bug fix. now avi video can played at full screen mode(alt enter) with some position error.

#                        - can play other format such as mkv but it will play full screen and when played at full screen

#                          mode (alt enter) the size will be smaller and the game switched.

#                        - basicly this script not support full screen game yet. will try to fix this in next version

# version 1.0 2012.09.23 - finish converting + some change

#

#

#==============================================================================

# Features:

#------------------------------------------------------------------------------

# o Play video's on the map or in battle using a simple script event command.

#

# o Optionally pause or exit video's while they play.

#

# o View the video in the game window or in fullscreen.

#

# o Setup video skills, which show the video before damage effects.

#

# o ACE version also made not only video skill but can use video item too

#

# o ACE version also can play video before title scene

#

#==============================================================================

# Instructions:

#------------------------------------------------------------------------------

# o Place all videos in a folder with the same name as in configuration.

#   This folder is created automatically the first time the game is played if

#   it doesn't already exist.

#

# o Playing Videos when on the map.

#

#   - See script calls below.

#

# o Playing videos in battle.

#

#   - As when on the map the script event command can be used in battle also.

#

#   - As well as this you can setup skills as video skills which display

#     a video before damaging the enemy.

#

#     

#     To do this the following tags can be used in the skills notebox:

#     1) 

#        ~ name is the name of the video file. If the filename extension is

#          missing the first file matching that name is used.

#          (Quotes are necessary around the filename)

#

#      As well as the first tag 2 others are available. These tags will only

#      take effect if placed on a line below the first tag.

#      If these don't exist they are assumed true.

#

#      2)    ~ Can the video be exited by the exit input?

#      3)    ~ Can the video be paused?

#         ~ n is replaced with either t or f (t : true, f : false)

#

#      For other Video properties (x,y,width,height,fullscreen) the default

#      settings are used. (See script calls below)

#

# o Playing videos before title screen

# ctrl + f this : CONFIGURATION FOR VIDEO BEFORE TITLE

# and change the

# @video_title = nil

# to

# @video_title = "yourvideonamewithoutextensionhere"

#

#==============================================================================

# Script Calls:

#------------------------------------------------------------------------------

# Commands (From the script call command on page three of event commands)

#------------------------------------------------------------------------------

# o To change default values for video properties.

#

#  1) Video.default_x = n

#  2) Video.default_y = n

#  3) Video.default_width  = n

#  4) Video.default_height = n

#  5) Video.fullscreen = bool #disabled now since could make error

#  

#  In all 5 commands above:

#  ~ n is an integer value

#  ~ bool is either true or false

#

# o To play videos

#

#   play_video(filename,exitable,pausable)

#   ~ filename : name of video file             (Must be in quotes)

#   ~ exitable : Can the video be exited?       (When left out = true)

#   ~ pausable : Can the video be paused?       (When left out = true)

#  

#   For all other values the default's are used.

#==============================================================================

# Compatibility:

#------------------------------------------------------------------------------

# o Skill videos will depend on the battle system but sould work.

#==============================================================================

# Credit:

#------------------------------------------------------------------------------

# o Credit goes to Trebor and Berka whose scripts helped be figure out the

#   mci_send_stringA function.

#==============================================================================

module SOV

  module Video

  #--------------------------------------------------------------------------

  # Configuration

  #--------------------------------------------------------------------------

    # Name of folder for videos to be held in.

    DIR_NAME = "Videos"

    # Exit video input

    EXIT_INPUT  = Input::B

    # Pause video input

    PAUSE_INPUT = Input::C

    IGNORE_TITLE = true

    #set to true if your title contain strange character such as é or other.    

  #--------------------------------------------------------------------------

  # End Configuration

  #--------------------------------------------------------------------------

  end

end

module SceneManager

################ CONFIGURATION FOR VIDEO BEFORE TITLE #######################  

  @video_title = nil  # "example" # FILENAME OF THE VIDEO IN VIDEO FOLDER IN QUOTES

  #IF YOU DON'T WANT TO USE THIS FEATURE JUST CHANGE TO NIL

################ END CONFIGURATION ##########################################  

  def self.run

    DataManager.init

    Audio.setup_midi if use_midi?

    if @video_title != nil

    video = Cache.video(@video_title)

    video.exitable = true # True/False

    video.pausable = true # True/False

    Video.play(video)

    end

    @scene = first_scene_class.new

    @scene.main while @scene

  end

end

class << Graphics

  def Graphics.fullscreen? # Property

    screen_size = Win32API.new('user32', 'GetSystemMetrics', 'I', 'I')

    screen_width = screen_size.call(0);   screen_height = screen_size.call(1)    

    detect_fullscreen = false

    detect_fullscreen = true if screen_width == 640 and screen_height == 480

    return detect_fullscreen

  end

  def Graphics.toggle_fullscreen # Main function

    keybd = Win32API.new 'user32.dll', 'keybd_event', ['i', 'i', 'l', 'l'], 'v'

    keybd.call(0xA4, 0, 0, 0)

    keybd.call(13, 0, 0, 0)

    keybd.call(13, 0, 2, 0)

    keybd.call(0xA4, 0, 2, 0)    

  end

end

#==============================================================================

# Import

#------------------------------------------------------------------------------

$imported = {} if $imported == nil

$imported['Videos'] = true

#==============================================================================

#==============================================================================

# ** SOV::Video::Commands

#==============================================================================

module SOV::Video::Commands

  #--------------------------------------------------------------------------

  # * Play a video

  #  filename : video's filename (with or without extension)

  #  exitable : Can the video be exited

  #  pausable : Can the video be paused

  #--------------------------------------------------------------------------

  def play_video(filename,exitable=true,pausable=true)

    video = Cache.video(filename)

    video.exitable = exitable

    video.pausable = pausable

    $game_map.video = video

  end

  #---------------------------------------------------------------------------

  # Define as module function

  #---------------------------------------------------------------------------

  module_function :play_video

end

#==============================================================================

# ** SOV::Video::Regexp

#==============================================================================

module SOV::Video::Regexp

  #--------------------------------------------------------------------------

  # * Skill

  #--------------------------------------------------------------------------

  module Skill

    FILENAME   = //i

    PAUSABLE   = //i

    EXITABLE   = //i

  end

end

#==============================================================================

# ** SOV::Game

#==============================================================================

module SOV::Game

  #--------------------------------------------------------------------------

  # Constants

  #--------------------------------------------------------------------------

  INI = 'Game'

  #--------------------------------------------------------------------------

  # * Get the game windows handle

  #--------------------------------------------------------------------------

  def self.hwnd

    unless defined?(@@hwnd)

      find_window = Win32API.new('user32','FindWindow','pp','i')

#      @@hwnd = find_window.call('RGSS Player',title)  

      gamefullscreen = Graphics.fullscreen?

      @@hwnd = find_window.call('RGSS Player',title)  

    end

    return @@hwnd

  end

  #--------------------------------------------------------------------------

  # * Get game title

  #--------------------------------------------------------------------------

  def self.title

    unless defined?(@@title)

      @@title = read_ini('title')

    end

    return @@title

  end

  #--------------------------------------------------------------------------

  # * Read ini (Returns nil or match)

  #--------------------------------------------------------------------------

  def self.read_ini(variable,filename=INI)

    return nil if variable == 'title' && SOV::Video::IGNORE_TITLE

    reg = /^#{variable}=(.*)$/

    File.foreach(filename+'.ini') { |line| break($1) if line =~ reg }

  end

end

#==============================================================================

# ** Cache

#==============================================================================

module Cache

  #--------------------------------------------------------------------------

  # Class Variables

  #--------------------------------------------------------------------------

  @@vcache = {}

  #--------------------------------------------------------------------------

  # Define as class methods

  #--------------------------------------------------------------------------

  class << self

    #------------------------------------------------------------------------

    # Alias List

    #------------------------------------------------------------------------

    alias sov_video_clear clear unless $@

    #------------------------------------------------------------------------

    # * Get a video object

    #  filename : basename of file

    #------------------------------------------------------------------------

    def video(filename)

      # Get full filename if extension is missing

      if File.extname(filename) == ''

        files = Dir["#{SOV::Video::DIR_NAME}/#{filename}.*"]

        filename = File.basename(files[0]) # Set as first matching file

      end

      # Create or get the video object.

      if @@vcache.has_key?(filename)

        @@vcache[filename]

      else

        @@vcache[filename] = Video.new(filename)

      end

    end

    #------------------------------------------------------------------------

    # * Clear

    #------------------------------------------------------------------------

    def clear

      @@vcache.clear

      sov_video_clear

    end

  end

end

#==============================================================================

# ** RPG::Skill

#==============================================================================

class RPG::UsableItem

  #--------------------------------------------------------------------------

  # * Determine if skill has a video skill

  #--------------------------------------------------------------------------

  def video

    if @video == nil

      @note.each_line { |line|

        if @video == nil

          @video = Cache.video($1) if line =~ SOV::Video::Regexp::Skill::FILENAME

        else

          @video.pausable = ($1 == 't') if line =~ SOV::Video::Regexp::Skill::PAUSABLE

          @video.exitable = ($1 == 't') if line =~ SOV::Video::Regexp::Skill::EXITABLE

        end

      }

      @video = :invalid if @video == nil

    end

    return @video

  end

end

#==============================================================================

# ** Video

#------------------------------------------------------------------------------

#  Class handling playing videos.

#==============================================================================

class Video

  #--------------------------------------------------------------------------

  # Constants

  #--------------------------------------------------------------------------

  TYPE_AVI  = 'avivideo'

  TYPE_MPEG = 'mpegvideo'

  #--------------------------------------------------------------------------

  # Class Variables

  #--------------------------------------------------------------------------

  @@default_x = 0

  @@default_y = 0

  @@default_width  = Graphics.width

  @@default_height = Graphics.height

  @@fullscreen = false

  #--------------------------------------------------------------------------

  # * Get and Set default_x/y/width/height

  #--------------------------------------------------------------------------

  for d in %w(x y width height)

    # Define setter method

    module_eval(%Q(def self.default_#{d}=(i); @@default_#{d} = i; end))

    # Define getter method

    module_eval(%Q(def self.default_#{d}; @@default_#{d}; end))

  end

  #--------------------------------------------------------------------------

  # * Get fullscreen

  #--------------------------------------------------------------------------

  def self.fullscreen

    @@fullscreen

  end  

  #--------------------------------------------------------------------------

  # * Set fullscreen

  #--------------------------------------------------------------------------

  def self.fullscreen=(val)

    @@fullscreen = val

  end

  #--------------------------------------------------------------------------

  # * Win32API

  #--------------------------------------------------------------------------

  @@mciSendStringA = Win32API.new('winmm','mciSendStringA','pplp','i')

  #--------------------------------------------------------------------------

  # * Video Command

  #  command_string : string following mci_command_string format

  #  buffer : string to retrieve return data

  #  buffer_size : number of characters in buffer

  #  callback_handle : handle of window to callback to. Used if notify is used

  #                    in the command string. (Not supported by game window)

  #--------------------------------------------------------------------------

  def self.send_command(cmnd_string,buffer='',buffer_size=0,callback_handle=0)

    # Returns error code. No error if NULL

    err = @@mciSendStringA.call(cmnd_string,buffer,buffer_size,callback_handle)

    if err != 0

      buffer = ' ' * 255

      Win32API.new('winmm','mciGetErrorString','LPL','V').call(err,buffer,255)

      raise(buffer.squeeze(' ').chomp('\000'))

    end

  end

  #--------------------------------------------------------------------------

  # * Play a video

  #--------------------------------------------------------------------------

  def self.play(video)

    # Make path and buffer

    path = "#{SOV::Video::DIR_NAME}/#{video.filename}"

    buffer = ' ' * 255

    # Initialize device and dock window with game window as parent.

    type = " type #{video.type}" if video.type != ''

    send_command("open #{path}#{type} alias VIDEO style child parent #{SOV::Game.hwnd}")

    # Display video in client rect at x,y with width and height.

    x = video.x

    y = video.y

    width  = video.width

    height = video.height

    send_command("put VIDEO window at #{x} #{y} #{width} #{height}")

    # Begin playing video

    screen = @@fullscreen ? 'fullscreen' : 'window'

    gamefullscreen = Graphics.fullscreen?

    case video.type

    when "avivideo"

      if gamefullscreen == true

      #send_command("put VIDEO window at #{x} #{y} 640 480")

      Graphics.toggle_fullscreen

      send_command("play VIDEO window")

      else

      send_command("play VIDEO window")

      end

    when "mpegvideo"

        if gamefullscreen == true

        Graphics.toggle_fullscreen

        send_command("play VIDEO window")

        else

        send_command("play VIDEO fullscreen")

        end

    else

    end

    flag = 0

    # Start Input and status processing loop

    while buffer !~ /^stopped/

      # Idle processing for a frame

      sleep(1.0/Graphics.frame_rate)

      # Get mode string

      send_command('status VIDEO mode',buffer,255)

      Input.update    

      if Input.trigger?(SOV::Video::PAUSE_INPUT) and video.pausable?

        Sound.play_cursor

        if buffer =~ /^paused/                 # If already paused

          send_command("resume VIDEO")         # Resume video

        else                                   # Otherwise

          send_command("pause VIDEO")          # Pause video

        end

      elsif Input.trigger?(SOV::Video::EXIT_INPUT) and video.exitable?

        Sound.play_cancel

        # Terminate loop on exit input

        break

      end

    end

    # Terminate the device

    send_command('close VIDEO')

  end

  #--------------------------------------------------------------------------

  # Public Instance Variables

  #--------------------------------------------------------------------------

  attr_accessor :x

  attr_accessor :y

  attr_accessor :width

  attr_accessor :height

  attr_writer :exitable

  attr_writer :pausable

  attr_reader :filename

  #--------------------------------------------------------------------------

  # * Initialize

  #--------------------------------------------------------------------------

  def initialize(filename)

    unless FileTest.file?("#{SOV::Video::DIR_NAME}/#{filename}")

      raise(Errno::ENOENT,filename)

    end

    @filename = filename

    @x = @@default_x

    @y = @@default_y

    @width  = @@default_width

    @height = @@default_height

    @exitable = true

    @pausable = true

  end

  #--------------------------------------------------------------------------

  # * Get Type

  #--------------------------------------------------------------------------

  def type

    if @type == nil

      case File.extname(@filename)

      when '.avi'; @type = TYPE_AVI

      when '.mpeg'||'.mpg'; @type = TYPE_MPEG

      else

        @type = TYPE_MPEG#''

      end

    end

    @type

  end

  #--------------------------------------------------------------------------

  # * Is the video exitable?

  #--------------------------------------------------------------------------

  def exitable?

    @exitable

  end

  #--------------------------------------------------------------------------

  # * Is the video pausable?

  #--------------------------------------------------------------------------

  def pausable?

    @pausable

  end

  #--------------------------------------------------------------------------

  # Access

  #--------------------------------------------------------------------------

  private_class_method :send_command  

end

#==============================================================================

# ** Game_Interpreter

#==============================================================================

class Game_Interpreter

  #--------------------------------------------------------------------------

  # Import

  #--------------------------------------------------------------------------

  include(SOV::Video::Commands)

end

#==============================================================================

# ** Game_Map

#==============================================================================

class Game_Map

  #--------------------------------------------------------------------------

  # Public Instance Variables

  #--------------------------------------------------------------------------

  attr_accessor :video  

end

#==============================================================================

# ** Scene_Map

#==============================================================================

class Scene_Map

  #--------------------------------------------------------------------------

  # Alias List

  #--------------------------------------------------------------------------

  alias sov_video_update update unless $@

  #--------------------------------------------------------------------------

  # * Play Video

  #--------------------------------------------------------------------------

  def play_video(video)

    # Memorize and stop current bgm and bgs

    bgm = RPG::BGM.last

    bgs = RPG::BGS.last

    RPG::BGM.stop

    RPG::BGS.stop

    # Play video

    Video.play(video)

    # Restart bgm and bgs

    bgm.play

    bgs.play

  end

  #--------------------------------------------------------------------------

  # * Update

  #--------------------------------------------------------------------------

  def update

    if $game_map.video != nil

      play_video($game_map.video)

      $game_map.video = nil

      Input.update

    else

      sov_video_update

    end

  end

end

#==============================================================================

# ** Scene_Battle

#==============================================================================

class Scene_Battle

  #--------------------------------------------------------------------------

  # * Alias list

  #--------------------------------------------------------------------------

  alias sov_video_update_battle update unless $@

  alias sov_video_use_item use_item unless $@

  #--------------------------------------------------------------------------

  # * Play Video

  #--------------------------------------------------------------------------

  def play_video(video)

    # Memorize and stop current bgm

    bgm = RPG::BGM.last

    RPG::BGM.stop

    # Play video

    Video.play(video)

    # Restart bgm

    bgm.play

  end

  #--------------------------------------------------------------------------

  # * Execute Action Skill

  #--------------------------------------------------------------------------

  def use_item

    skill = @subject.current_action.item    

    if skill.video.is_a?(Video)

      execute_action_video(skill)

      sov_video_use_item

    else

      sov_video_use_item

    end

  end

  #--------------------------------------------------------------------------

  # * Execute Action Video

  #--------------------------------------------------------------------------

  def execute_action_video(skill)

    br = Graphics.brightness

    120.times { |i| Graphics.brightness = 255 - 255/60 * i; Graphics.update }

    # Play video

    play_video(skill.video)

    # Reset brightness

    Graphics.brightness = br

  end

  #ADDED UPDATE FUNCTION FROM SCENE_MAP TO SCENE_BATTLE

  def update

    if $game_map.video != nil

      play_video($game_map.video)

      $game_map.video = nil

      Input.update

    else

      sov_video_update_battle

    end

  end

end

#==============================================================================

# Pre-Main Processing

#==============================================================================

unless FileTest.directory?(SOV::Video::DIR_NAME) # If directory doesn't exist.

  Dir.mkdir(SOV::Video::DIR_NAME)                # Make the directory

end

=begin

=end

Screeny:

Spoiler: (Otwórz)

Dodatkowe informacje:
Skrypt w 100% wspiera jedynie pliki wideo AVI.

Myślę, że paru osobom skrypt się przyda, bo mi na pewno :)

Jeżeli chodzi o instrukcję i ważniejsze treści to za tydzień postaram wziąć się za tłumaczenie.

8 Dir Move (Poruszanie się w 8 kierunkach)

Tue, 23 Jul 2013 16:45:30 +0200

~ 8 Dir Move ~

Krótki opis:
Skrypt dodaje możliwość poruszania się w 8 kierunkach.

Autor:
JV Master

Tłumaczenie:
Nie potrzebne

Skrypt:

Spoiler: (Otwórz)

Kod:

#==============================================================================

# 8 Dir Move                                                  JV Master Script

#------------------------------------------------------------------------------

# Make player move in 8 dir, supports diagonal pattern.

#==============================================================================

module JvScripts

  module Dirs8

    Switch = 0               # Switch id for toggle 4/8 dir, 0 if always 8 dir

    DiagonalSuffix = "_di"   # Suffix for 8 dir charsets

                             # 8 dir charsets include in the first char

                             # the orthogonal and in the second the diagonal

  end

end

#==============================================================================

# Game CharacterBase

#==============================================================================

class Game_CharacterBase

  def move_diagonal(horz, vert)

    @move_succeed = diagonal_passable?(x, y, horz, vert)

    if @move_succeed

      @x = $game_map.round_x_with_direction(@x, horz)

      @y = $game_map.round_y_with_direction(@y, vert)

      @real_x = $game_map.x_with_direction(@x, reverse_dir(horz))

      @real_y = $game_map.y_with_direction(@y, reverse_dir(vert))

      increase_steps

    end

    if diagonal_charset?

      set_direction_diagonal(horz, vert)

    else

      set_direction(horz) if @direction == reverse_dir(horz)

      set_direction(vert) if @direction == reverse_dir(vert)

    end

  end

  def set_direction(d)

    if !@direction_fix && d != 0

      @direction = d

      @character_index = 0 if diagonal_charset?

    end

    @stop_count = 0

  end

  def set_direction_diagonal(horz, vert)

    if !@direction_fix && horz != 0 && vert != 0

      if horz == 4 && vert == 2

        @direction = 2

      elsif horz == 4 && vert == 8

        @direction = 4

      elsif horz == 6 && vert == 2

        @direction = 6

      elsif horz == 6 && vert == 8

        @direction = 8

      end

      @character_index = 1

    end

    @stop_count = 0

  end

  def diagonal_charset?

    true if @character_name.include?(JvScripts::Dirs8::DiagonalSuffix)

  end

end

#==============================================================================

# Game Player

#==============================================================================

class Game_Player < Game_Character

  def move_by_input

    return if !movable? || $game_map.interpreter.running?

    if JvScripts::Dirs8::Switch > 0

      if $game_switches[JvScripts::Dirs8::Switch] == true

        case Input.dir8

        when 2, 4, 6, 8

          move_straight(Input.dir4)

        when 1

          move_diagonal(4, 2)

        when 3

          move_diagonal(6, 2)

        when 7

          move_diagonal(4, 8)

        when 9

          move_diagonal(6, 8)

        end

      else

        move_straight(Input.dir4) if Input.dir4 > 0

      end

    else

      if Input.dir8 > 0

        case Input.dir8

        when 2, 4, 6, 8

          move_straight(Input.dir4)

        when 1

          move_diagonal(4, 2)

        when 3

          move_diagonal(6, 2)

        when 7

          move_diagonal(4, 8)

        when 9

          move_diagonal(6, 8)

        end

      end

    end

  end

end

Instalacja:
Instalacja skryptu jest zwyczajna czyli wklejamy pod "▼ Materials" lub pod "▼ 素材" (zależy od wersji językowej naszego RPG Makera VX Ace)

Force 640x480 Resolution Script

Tue, 23 Jul 2013 15:53:26 +0200

~ Force 640x480 Resolution Script ~

Krótki opis:
Skrypt powiększa rozmiar okna naszej gry do 640x480.

Autor:
Matt Sully (Gump)

Tłumaczenie:
Nie potrzebne

Skrypt:

Spoiler: (Otwórz)

Instalacja:
Skrypt wklejamy w "Main" nad "rgss_main { SceneManager.run }"

UWAGA!
O wiele lepszy od tego jest skrypt "Miscellaneous Options", który posiada jeszcze więcej opcji niż zmiana rozmiaru okna gry i jest łatwiejszy w wgrywaniu.

Cache Optimization

Tue, 23 Jul 2013 15:23:05 +0200

~ Cache Optimization ~

Krótki opis:
Jest to skrypt, który zwiększa wydajność naszej gry poprzez optymalizacje Cache.
Funkcje: pre-buforuje wszystkie grafiki poza zaszyfrowanymi archiwami, redukuje drobne, malutkie stężenia niepotrzebnych opóźnień, Returns dup of image instead of original.

Autor:
Jet10985 (Jet)

Tłumaczenie:
Nie potrzebne

Skrypt:

Spoiler: (Otwórz)

Instalacja:
Instalacja skryptu jest zwyczajna czyli wklejamy pod "▼ Materials" lub pod "▼ 素材" (zależy od wersji językowej naszego RPG Makera VX Ace)

Miscellaneous Options (Dodatkowe opcje gry)

Tue, 23 Jul 2013 13:36:03 +0200

~ Miscellaneous Options ~

Krótki opis:
Ten skrypt pozwala skonfigurować 14 ustawień niedostępnych w edytorze takich jak np. wielkość okna, wysoki priorytet okna gry, ukrycie kursora, dużo ustawień czcionki itd.

Autor:
Jet10985 (Jet)

Tłumaczenie:
Mateix

Skrypt:

Spoiler: (Otwórz)

Kod:

#===============================================================================​

# Miscellaneous Options

# By Jet10985 (Jet)

#===============================================================================​

# Ten skrypt pozwala dostosować do własnych potrzeb niektóre opcje

# z "szczegółów" gry, które nie są dostępne w edytorze.

# Ten skrypt zawiera: 14 opcji do dostosowania.

#===============================================================================​

# Overwritten Methods:

# None

#-------------------------------------------------------------------------------

# Aliased methods:

# DataManager: make_filename, save_file_exists?

# Game_System: japanese?

#===============================================================================​

module MiscellaneousOptions

  #==========================================================================​===

  # Opcje czcionki

  #==========================================================================​===

  #-----------------------------------------------------------------------------

  # Wybór czcionki używanej domyślnie:

  # Można użyć jednej czcionki lub wiele w postaci tablicy.

  # W przypadku stosowania wielu czcionek, gra będzie przeszukiwać tablicę, aż

  # znajdzie czcionkę, którą gracz zainstalował.

  #-----------------------------------------------------------------------------

  Font.default_name = ["Verdana", "Arial", "Courier New"]

  #-----------------------------------------------------------------------------

  # Domyślna wielkość czcionki

  #-----------------------------------------------------------------------------

  Font.default_size = 20

  #-----------------------------------------------------------------------------

  # Określenie czy tekst jest domyślnie pogrubiony, czy nie

  #-----------------------------------------------------------------------------

  Font.default_bold = false

  #-----------------------------------------------------------------------------

  # Określenie czy tekst jest domyślnie z kursywą, czy nie

  #-----------------------------------------------------------------------------

  Font.default_italic = false

  #-----------------------------------------------------------------------------

  # Określenie czy tekst jest domyślnie z cieniem, czy bez

  #-----------------------------------------------------------------------------

  Font.default_shadow = true

  #-----------------------------------------------------------------------------

  # Określenie domyślnego koloru tekstu

  #-----------------------------------------------------------------------------

  Font.default_color = Color.new(255, 255, 255)

  #-----------------------------------------------------------------------------

  # Określenie czy wokół liter jest obramowanie, czy nie

  #-----------------------------------------------------------------------------

  Font.default_outline = true

  #-----------------------------------------------------------------------------

  # Określenie koloru obramowania wokół liter

  #-----------------------------------------------------------------------------

  Font.default_out_color = Color.new(0, 0, 0, 128)

  #-----------------------------------------------------------------------------

  # Czy w grze jest użyty język japoński?

  #-----------------------------------------------------------------------------

  JAPANESE = false

  #==========================================================================​===

  # Opcje okna

  #==========================================================================​===

  #-----------------------------------------------------------------------------

  # To ustawienie decyduje, czy grze jest nadawany priorytet procesu "Wysoki"

  # przy starcie. Możliwe jest dzięki temu zwiększenie wydajności gry.

  #-----------------------------------------------------------------------------

  HIGH_PROCESS = true

  #-----------------------------------------------------------------------------

  # To ustawienie określa czy kursor myszy powinien być ukryty.

  # Działa tylko wtedy, gdy kursor znajduje się w obszarze okna gry.

  #-----------------------------------------------------------------------------

  HIDE_MOUSE = true

  #-----------------------------------------------------------------------------

  # To ustawienie określa czy okno może być skalowane.

  # Domyślnie okno nie jest skalowane bez dodatkowych skryptów.

  # UWAGA! To nie zwiększa możliwości graficznych wyświetlania gry

  # i spowoduje rozciągnięcie lub skurczenie grafiki.

  #-----------------------------------------------------------------------------

  ALLOW_RESIZING = false

  #==========================================================================​===

  # Opcje gry

  #==========================================================================​===

  #-----------------------------------------------------------------------------

  # Określenie rozmiaru okna gry. Max: 640x480

  # Musi być wielokrotnością liczby 32

  #-----------------------------------------------------------------------------

  Graphics.resize_screen(544, 416)

  #-----------------------------------------------------------------------------

  # Tu możesz określić czy pliki zapisanych gier są zapisywane w folderze

  # AppData (zamiast w katalogu z grą).

  # W Windows XP: C:\Documents and Settings\UserName\Application Data\NAZWA_GRY

  # W Windows Vista/7: C:\Users\UserName\AppData\Roaming\NAZWA_GRY

  #-----------------------------------------------------------------------------

  SAVE_IN_APPDATA = true

  #-----------------------------------------------------------------------------

  # Jaka jest nazwa twojej gry? To będzie wykorzystywane jedynie, jeśli używasz

  # zapisu w folderze AppData (ustawienie wyżej).

  #-----------------------------------------------------------------------------

  GAME_NAME = "Tu wpisz nazwe swojej gry"

end

#===============================================================================​

# NIE EDYTUJ DALEJ, JEŚLI NIE WIESZ CO ROBIĆ.

#===============================================================================​

module MiscellaneousOptions

  def self.handle

    a = Win32API.new('kernel32', 'GetPrivateProfileString', 'pppplp', 'l')

    b = Win32API.new('user32', 'FindWindow', 'pp', 'i')

    a.call("Game", "Title", "", title = "\0" * 256, 256, ".//Game.ini")

    return b.call("RGSS Player", title.delete!("\0"))

  end

end

if MiscellaneousOptions::HIDE_MOUSE

  Win32API.new('user32', 'ShowCursor', 'i', 'i').call(0)

end

if MiscellaneousOptions::HIGH_PROCESS

  Win32API.new('kernel32','SetPriorityClass','pi','i').call(-1, 256)

end

if MiscellaneousOptions::ALLOW_RESIZING

  Win32API.new('user32', 'SetWindowLong', 'lll', 'l').call(

    MiscellaneousOptions.handle, -16, 0x10C70000|0x00080000)

end

if MiscellaneousOptions::SAVE_IN_APPDATA

    f = "#{ENV['APPDATA']}\\#{MiscellaneousOptions::GAME_NAME}"

    Dir.mkdir(f) unless File.directory?(f)

    Dir.mkdir("#{f}\\Saves") unless File.directory?("#{f}\\Saves")

end

class << DataManager

    alias jet3849_save_file_exists save_file_exists?

    def save_file_exists?(*args, &block)

        if MiscellaneousOptions::SAVE_IN_APPDATA

            f = "#{ENV['APPDATA']}\\#{MiscellaneousOptions::GAME_NAME}"

            Dir.entries("#{f}\\Saves").size > 2

        else

            jet3849_save_file_exists(*args, &block)

        end

    end

    alias jet2734_make_filename make_filename

    def make_filename(index)

        if MiscellaneousOptions::SAVE_IN_APPDATA

            f = "#{ENV['APPDATA']}\\#{MiscellaneousOptions::GAME_NAME}"

            return "#{f}\\Saves\\#{sprintf("Save%02d.rvdata2", index + 1)}"

        else

            jet2734_make_filename(index)

        end

    end

end

class Game_System

    alias jet2734_japanese japanese?

    def japanese?(*args, &block)

        $data_system.japanese = MiscellaneousOptions::JAPANESE

        jet2734_japanese(*args, &block)

    end

end

Instalacja:
Instalacja skryptu jest zwyczajna czyli wklejamy pod "▼ Materials" lub pod "▼ 素材" (zależy od wersji językowej naszego RPG Makera VX Ace)

Dodatkowe informacje:
Skrypt postaram się aktualizować, jeśli wyjdzie nowsza wersja.
Z góry przepraszam za błędy w tłumaczeniu.

Pearl ABS Liquid

Wed, 10 Jul 2013 20:12:05 +0200

~ Pearl ABS Liquid ~

Krótki opis:
Aktualnie najbardziej rozbudowany ABS (system walki w czasie rzeczywistym) dla RGSS3, czyli dla RPG Maker'a VX Ace. Skrypt ma wielkie możliwości, jest wysoce konfigurowalny, można go zmienić wedle swoich upodobań.

Autor:
Falcao

Screeny:

Spoiler: (Otwórz)

Demo:

Dodatkowe informacje:
Aby skrypt poprawnie działał, skopiuj wszystkie (oprócz Title) skrypty z dema do swojego projektu, a następnie grafiki z folderu "Graphics", które możesz później skonfigurować...

Tutaj dodatkowy skrypt, który umożliwia pokazywanie HP i MP drużyny:
http://pastebin.com/H0X6VMfS