Code:
#==============================================================================
# Não reinciar Música do mapa após uma batalha
# por Atoa
# Novo modulo de Audio por Poccil
#==============================================================================
class Win32API
@@RGSSWINDOW=nil
@@GetCurrentThreadId=Win32API.new('kernel32','GetCurrentThreadId', '%w()','l')
@@GetWindowThreadProcessId=Win32API.new('user32','GetWindowThreadProcessId', '%w(l p)','l')
@@FindWindowEx=Win32API.new('user32','FindWindowEx', '%w(l l p p)','l')
def Win32API.GetPrivateProfileString(section, key)
val = "\0"*256
gps = Win32API.new('kernel32', 'GetPrivateProfileString',%w(p p p p l p), 'l')
gps.call(section, key, "", val, 256, ".\\Game.ini")
val.delete!("\0")
return val
end
end
class Thread
def Thread.exclusive
_old = Thread.critical
begin
Thread.critical = true
return yield
ensure
Thread.critical = _old
end
end
end
class AudioContext
attr_reader :context
def initialize
init = Win32API.new("audio.dll", "AudioContextInitialize", '', 'l')
@context=init.call()
end
def dispose
if @context!=0
init = Win32API.new("audio.dll", "AudioContextFree", 'l', '')
init.call(context)
@context=0
end
end
end
$AtExitProcs=[] if !$AtExitProcs
def exit(code=0)
for p in $AtExitProcs
p.call
end
raise SystemExit.new(code)
end
def at_exit(&block)
$AtExitProcs.push(Proc.new(&block))
end
module AudioState
w32_LL = Win32API.new("kernel32.dll", "LoadLibrary", 'p', 'l')
w32_FL = Win32API.new("kernel32.dll", "FreeLibrary", 'p', 'l')
@handle = w32_LL.call("audio.dll")
at_exit { w32_FL.call(@handle) }
AudioContextIsActive=Win32API.new("audio.dll","AudioContextIsActive","l","l")
AudioContextPlay=Win32API.new("audio.dll","AudioContextPlay","lpllll","")
AudioContextStop=Win32API.new("audio.dll","AudioContextStop","l","")
AudioContextFadeOut=Win32API.new("audio.dll","AudioContextFadeOut","ll","")
AudioContextGetPosition=Win32API.new("audio.dll","AudioContextGetPosition","l","l")
AudioContextFadeIn=Win32API.new("audio.dll","AudioContextFadeIn","ll","")
AudioContextSetVolume=Win32API.new("audio.dll","AudioContextSetVolume","ll","")
AudioContextSEPlay=Win32API.new("audio.dll","AudioContextSEPlay","lplll","")
if !@MEContext
@MEContext=AudioContext.new
at_exit { @MEContext.dispose }
end
if !@BGMContext
@BGMContext=AudioContext.new
at_exit { @BGMContext.dispose }
end
if !@SEContext
@SEContext=AudioContext.new
at_exit { @SEContext.dispose }
end
@channel=nil
@bgm=nil
@name=""
@pitch=100
@bgmVolume=100.0
@meVolume=100.0
@seVolume=100.0
def self.setWaitingBGM(bgm,volume,pitch,position)
@waitingBGM=[bgm,volume,pitch,position]
end
def self.bgmActive?
return (AudioContextIsActive.call(@BGMContext.context)!=0)
end
def self.meActive?
return (AudioContextIsActive.call(@MEContext.context)!=0)
end
def self.waitingBGM
@waitingBGM
end
def self.context
@BGMContext.context
end
def self.system
@system
end
def self.bgm
@bgm
end
def self.name
@name
end
def self.pitch
@pitch
end
def self.volume
@volume
end
def self.waitingBGM=(value)
Thread.exclusive{@waitingBGM=value}
end
def self.volume=(value)
@volume=value
end
def self.bgm=(value)
@bgm=value
end
def self.name=(value)
@name=value
end
def self.pitch=(value)
@pitch=value
end
end
def Audio_bgm_playing?
AudioState.channel!=nil
end
def Audio_bgm_name
AudioState.name
end
def Audio_bgm_pitch
AudioState.pitch
end
def Audio_bgm_play(name, volume, pitch, position = 0)
begin
filename = canonicalize(rtpGetPath(name,[".mid",".mp3",".wma",".ogg",".wav",""]))
if AudioState.meActive?
AudioState.setWaitingBGM(filename,volume,pitch,position)
return
end
AudioState::AudioContextPlay.call(AudioState.context,filename,volume,pitch,position,1)
AudioState.name=filename
AudioState.volume=volume
AudioState.pitch=pitch
rescue Hangup
rescue
p $!.message,$!.backtrace
end
end
def Audio_bgm_stop()
begin
AudioState::AudioContextStop.call(AudioState.context)
AudioState.waitingBGM=nil
AudioState.name = ""
rescue
p $!.message,$!.backtrace
end
end
def Audio_bgm_get_position
return AudioState::AudioContextGetPosition.call(AudioState.context)
end
def Audio_bgm_fade(ms)
AudioState::AudioContextFadeOut.call(AudioState.context,ms.to_i)
end
def Audio_bgm_fadein(ms)
AudioState::AudioContextFadeIn.call(AudioState.context,ms.to_i)
end
def Audio_bgm_get_volume
return 0 if !AudioState.bgmActive?
return AudioState.volume
end
def Audio_bgm_set_volume(volume)
return if !AudioState.bgmActive?
AudioState.volume = volume * 1.0
AudioState::AudioContextSetVolume.call(AudioState.context,volume.to_i)
end
module Graphics
if !defined?(audiomodule_update)
class << self
alias audiomodule_update update
end
end
def self.update
Audio.update
audiomodule_update
end
end
module Audio
@@musicstate=nil
@@soundstate=nil
def self.update
return if Graphics.frame_count%10!=0
if AudioState.waitingBGM && !AudioState.meActive?
waitbgm=AudioState.waitingBGM
AudioState.waitingBGM=nil
bgm_play(waitbgm[0],waitbgm[1],waitbgm[2],waitbgm[3])
end
end
def self.bgm_play(name,volume=80,pitch=100,position=nil)
begin
if position==nil || position==0
Kernel.Audio_bgm_play(name,volume,pitch,0)
else
Kernel.Audio_bgm_play(name,volume,pitch,position)
Kernel.Audio_bgm_fadein(500)
end
rescue Hangup
bgm_play(name,volume,pitch,position)
end
end
def self.bgm_fade(ms)
Kernel.Audio_bgm_fade(ms)
end
def self.bgm_stop
Kernel.Audio_bgm_stop()
end
def self.bgm_position
ret=Kernel.Audio_bgm_get_position
return ret
end
end
module Win32
class Registry
module Constants
HKEY_CLASSES_ROOT = 0x80000000
HKEY_CURRENT_USER = 0x80000001
HKEY_LOCAL_MACHINE = 0x80000002
HKEY_USERS = 0x80000003
HKEY_PERFORMANCE_DATA = 0x80000004
HKEY_PERFORMANCE_TEXT = 0x80000050
HKEY_PERFORMANCE_NLSTEXT = 0x80000060
HKEY_CURRENT_CONFIG = 0x80000005
HKEY_DYN_DATA = 0x80000006
REG_NONE = 0
REG_SZ = 1
REG_EXPAND_SZ = 2
REG_BINARY = 3
REG_DWORD = 4
REG_DWORD_LITTLE_ENDIAN = 4
REG_DWORD_BIG_ENDIAN = 5
REG_LINK = 6
REG_MULTI_SZ = 7
REG_RESOURCE_LIST = 8
REG_FULL_RESOURCE_DESCRIPTOR = 9
REG_RESOURCE_REQUIREMENTS_LIST = 10
REG_QWORD = 11
REG_QWORD_LITTLE_ENDIAN = 11
STANDARD_RIGHTS_READ = 0x00020000
STANDARD_RIGHTS_WRITE = 0x00020000
KEY_QUERY_VALUE = 0x0001
KEY_SET_VALUE = 0x0002
KEY_CREATE_SUB_KEY = 0x0004
KEY_ENUMERATE_SUB_KEYS = 0x0008
KEY_NOTIFY = 0x0010
KEY_CREATE_LINK = 0x0020
KEY_READ = STANDARD_RIGHTS_READ |
KEY_QUERY_VALUE | KEY_ENUMERATE_SUB_KEYS | KEY_NOTIFY
KEY_WRITE = STANDARD_RIGHTS_WRITE |
KEY_SET_VALUE | KEY_CREATE_SUB_KEY
KEY_EXECUTE = KEY_READ
KEY_ALL_ACCESS = KEY_READ | KEY_WRITE | KEY_CREATE_LINK
REG_OPTION_RESERVED = 0x0000
REG_OPTION_NON_VOLATILE = 0x0000
REG_OPTION_VOLATILE = 0x0001
REG_OPTION_CREATE_LINK = 0x0002
REG_OPTION_BACKUP_RESTORE = 0x0004
REG_OPTION_OPEN_LINK = 0x0008
REG_LEGAL_OPTION = REG_OPTION_RESERVED |
REG_OPTION_NON_VOLATILE | REG_OPTION_CREATE_LINK |
REG_OPTION_BACKUP_RESTORE | REG_OPTION_OPEN_LINK
REG_CREATED_NEW_KEY = 1
REG_OPENED_EXISTING_KEY = 2
REG_WHOLE_HIVE_VOLATILE = 0x0001
REG_REFRESH_HIVE = 0x0002
REG_NO_LAZY_FLUSH = 0x0004
REG_FORCE_RESTORE = 0x0008
MAX_KEY_LENGTH = 514
MAX_VALUE_LENGTH = 32768
end
include Constants
include Enumerable
class Error < ::StandardError
FormatMessageA=Win32API.new('kernel32.dll','FormatMessageA','LPLLPLP','L')
def initialize(code)
@code = code
msg = "\0" * 1024
len = FormatMessageA.call(0x1200, 0, code, 0, msg, 1024, 0)
super msg[0, len].tr("\r", '').chomp
end
attr_reader :code
end
class PredefinedKey < Registry
def initialize(hkey, keyname)
@hkey = hkey
@parent = nil
@keyname = keyname
@disposition = REG_OPENED_EXISTING_KEY
end
def close
raise Error.new(5)
end
def class
Registry
end
Constants.constants.grep(/^HKEY_/) do |c|
Registry.const_set c, new(Constants.const_get(c), c)
end
end
module API
[
%w/RegOpenKeyExA LPLLP L/,
%w/RegCreateKeyExA LPLLLLPPP L/,
%w/RegEnumValueA LLPPPPPP L/,
%w/RegEnumKeyExA LLPPLLLP L/,
%w/RegQueryValueExA LPLPPP L/,
%w/RegSetValueExA LPLLPL L/,
%w/RegFlushKey L L/,
%w/RegCloseKey L L/,
%w/RegQueryInfoKey LPPPPPPPPPPP L/,
].each do |fn|
const_set fn[0].intern, Win32API.new('advapi32.dll', *fn)
end
module_function
def check(result)
raise Error, result, caller(2) if result != 0
end
def packdw(dw)
[dw].pack('V')
end
def unpackdw(dw)
dw += [0].pack('V')
dw.unpack('V')[0]
end
def packqw(qw)
[ qw & 0xFFFFFFFF, qw >> 32 ].pack('VV')
end
def unpackqw(qw)
qw = qw.unpack('VV')
(qw[1] << 32) | qw[0]
end
def OpenKey(hkey, name, opt, desired)
result = packdw(0)
check RegOpenKeyExA.call(hkey, name, opt, desired, result)
unpackdw(result)
end
def CreateKey(hkey, name, opt, desired)
result = packdw(0)
disp = packdw(0)
check RegCreateKeyExA.call(hkey, name, 0, 0, opt, desired,
0, result, disp)
[ unpackdw(result), unpackdw(disp) ]
end
def EnumValue(hkey, index)
name = ' ' * Constants::MAX_KEY_LENGTH
size = packdw(Constants::MAX_KEY_LENGTH)
check RegEnumValueA.call(hkey, index, name, size, 0, 0, 0, 0)
name[0, unpackdw(size)]
end
def EnumKey(hkey, index)
name = ' ' * Constants::MAX_KEY_LENGTH
size = packdw(Constants::MAX_KEY_LENGTH)
wtime = ' ' * 8
check RegEnumKeyExA.call(hkey, index, name, size, 0, 0, 0, wtime)
[ name[0, unpackdw(size)], unpackqw(wtime) ]
end
def QueryValue(hkey, name)
type = packdw(0)
size = packdw(0)
check RegQueryValueExA.call(hkey, name, 0, type, 0, size)
data = ' ' * unpackdw(size)
check RegQueryValueExA.call(hkey, name, 0, type, data, size)
[ unpackdw(type), data[0, unpackdw(size)] ]
end
def SetValue(hkey, name, type, data, size)
check RegSetValueExA.call(hkey, name, 0, type, data, size)
end
def FlushKey(hkey)
check RegFlushKey.call(hkey)
end
def CloseKey(hkey)
check RegCloseKey.call(hkey)
end
def QueryInfoKey(hkey)
subkeys = packdw(0)
maxsubkeylen = packdw(0)
values = packdw(0)
maxvaluenamelen = packdw(0)
maxvaluelen = packdw(0)
secdescs = packdw(0)
wtime = ' ' * 8
check RegQueryInfoKey.call(hkey, 0, 0, 0, subkeys, maxsubkeylen, 0,
values, maxvaluenamelen, maxvaluelen, secdescs, wtime)
[ unpackdw(subkeys), unpackdw(maxsubkeylen), unpackdw(values),
unpackdw(maxvaluenamelen), unpackdw(maxvaluelen),
unpackdw(secdescs), unpackqw(wtime) ]
end
end
def self.expand_environ(str)
str.gsub(/%([^%]+)%/) { ENV[$1] || $& }
end
@@type2name = { }
%w[
REG_NONE REG_SZ REG_EXPAND_SZ REG_BINARY REG_DWORD
REG_DWORD_BIG_ENDIAN REG_LINK REG_MULTI_SZ
REG_RESOURCE_LIST REG_FULL_RESOURCE_DESCRIPTOR
REG_RESOURCE_REQUIREMENTS_LIST REG_QWORD
].each do |type|
@@type2name[Constants.const_get(type)] = type
end
def self.type2name(type)
@@type2name[type] || type.to_s
end
def self.wtime2time(wtime)
Time.at((wtime - 116444736000000000) / 10000000)
end
def self.time2wtime(time)
time.to_i * 10000000 + 116444736000000000
end
private_class_method :new
def self.open(hkey, subkey, desired = KEY_READ, opt = REG_OPTION_RESERVED)
subkey = subkey.chomp('\\')
begin
newkey = API.OpenKey(hkey.hkey, subkey, opt, desired)
rescue Error
return nil
end
obj = new(newkey, hkey, subkey, REG_OPENED_EXISTING_KEY)
if block_given?
begin
yield obj
ensure
obj.close
end
else
obj
end
end
def self.create(hkey, subkey, desired = KEY_ALL_ACCESS, opt = 0x0000)
newkey, disp = API.CreateKey(hkey.hkey, subkey, opt, desired)
obj = new(newkey, hkey, subkey, disp)
if block_given?
begin
yield obj
ensure
obj.close
end
else
obj
end
end
@@final = proc { |hkey| proc { API.CloseKey(hkey[0]) if hkey[0] } }
def initialize(hkey, parent, keyname, disposition)
@hkey = hkey
@parent = parent
@keyname = keyname
@disposition = disposition
@hkeyfinal = [ hkey ]
ObjectSpace.define_finalizer self, @@final.call(@hkeyfinal)
end
attr_reader :hkey, :parent, :keyname, :disposition
def created?
@disposition == REG_CREATED_NEW_KEY
end
def open?
!@hkey.nil?
end
def name
parent = self
name = @keyname
while parent = parent.parent
name = parent.keyname + '\\' + name
end
name
end
def inspect
"\#<Win32::Registry key=#{name.inspect}>"
end
def _dump(depth)
raise TypeError, "can't dump Win32::Registry"
end
def open(subkey, desired = KEY_READ, opt = REG_OPTION_RESERVED, &blk)
self.class.open(self, subkey, desired, opt, &blk)
end
def create(subkey, desired = KEY_ALL_ACCESS, opt = REG_OPTION_RESERVED, &blk)
self.class.create(self, subkey, desired, opt, &blk)
end
def close
API.CloseKey(@hkey)
@hkey = @parent = @keyname = nil
@hkeyfinal[0] = nil
end
def each_value
index = 0
while true
begin
subkey = API.EnumValue(@hkey, index)
rescue Error
break
end
begin
type, data = read(subkey)
rescue Error
next
end
yield subkey, type, data
index += 1
end
index
end
alias each each_value
def each_key
index = 0
while true
begin
subkey, wtime = API.EnumKey(@hkey, index)
rescue Error
break
end
yield subkey, wtime
index += 1
end
index
end
def keys
keys_ary = []
each_key { |key,| keys_ary << key }
keys_ary
end
def read(name, *rtype)
type, data = API.QueryValue(@hkey, name)
unless rtype.empty? or rtype.include?(type)
string = "Type mismatch (expect #{rtype.inspect} but #{type} present)"
raise TypeError, string
end
case type
when REG_SZ, REG_EXPAND_SZ
[ type, data.chop ]
when REG_MULTI_SZ
[ type, data.split(/\0/) ]
when REG_BINARY
[ type, data ]
when REG_DWORD
[ type, API.unpackdw(data) ]
when REG_DWORD_BIG_ENDIAN
[ type, data.unpack('N')[0] ]
when REG_QWORD
[ type, API.unpackqw(data) ]
else
raise TypeError, "Type #{type} is not supported."
end
end
def [](name, *rtype)
type, data = read(name, *rtype)
case type
when REG_SZ, REG_DWORD, REG_QWORD, REG_MULTI_SZ
data
when REG_EXPAND_SZ
Registry.expand_environ(data)
else
raise TypeError, "Type #{type} is not supported."
end
end
def read_s(name)
read(name, REG_SZ)[1]
end
def read_s_expand(name)
type, data = read(name, REG_SZ, REG_EXPAND_SZ)
if type == REG_EXPAND_SZ
Registry.expand_environ(data)
else
data
end
end
def read_i(name)
read(name, REG_DWORD, REG_DWORD_BIG_ENDIAN, REG_QWORD)[1]
end
def read_bin(name)
read(name, REG_BINARY)[1]
end
def write(name, type, data)
case type
when REG_SZ, REG_EXPAND_SZ
data = data.to_s + "\0"
when REG_MULTI_SZ
data = data.to_a.join("\0") + "\0\0"
when REG_BINARY
data = data.to_s
when REG_DWORD
data = API.packdw(data.to_i)
when REG_DWORD_BIG_ENDIAN
data = [data.to_i].pack('N')
when REG_QWORD
data = API.packqw(data.to_i)
else
raise TypeError, "Unsupported type #{type}"
end
API.SetValue(@hkey, name, type, data, data.length)
end
def []=(name, rtype, value = nil)
if value
write name, rtype, value
else
case value = rtype
when Integer
write name, REG_DWORD, value
when String
write name, REG_SZ, value
when Array
write name, REG_MULTI_SZ, value
else
raise TypeError, "Unexpected type #{value.class}"
end
end
value
end
def write_s(name, value)
write name, REG_SZ, value.to_s
end
def write_i(name, value)
write name, REG_DWORD, value.to_i
end
def write_bin(name, value)
write name, REG_BINARY, value.to_s
end
def flush
API.FlushKey @hkey
end
def info
API.QueryInfoKey(@hkey)
end
%w[
num_keys max_key_length
num_values max_value_name_length max_value_length
descriptor_length wtime
].each_with_index do |s, i|
eval <<-__END__
def #{s}
info[#{i}]
end
__END__
end
end
end
def getExistingPath(file,extensions=[])
return file if FileTest.exist?(file)
if extensions
for ext in extensions
fullfile=file+ext
return fullfile if FileTest.exist?(fullfile)
end
end
return nil
end
def rtpGetDirectory(key,rtpname)
rtp=Win32API.GetPrivateProfileString("Game",rtpname)
return nil if !rtp || rtp==""
begin
path=key.read_s(rtp)
if path && path!=""
return path
end
return nil
rescue
return nil
end
end
def rtpGetPathHelper(key,rtpname,file,extensions)
path=rtpGetDirectory(key,rtpname)
return path ? getExistingPath(path+"\\"+file,extensions) : nil
end
def chdirRTP(rtpname)
Win32::Registry.open(
Win32::Registry::HKEY_LOCAL_MACHINE,"SOFTWARE\\Enterbrain\\RGSS\\RTP"){|key|
path=rtpGetDirectory(key,rtpname)
if path && path!=""
if block_given?
Dir.chdir(path){ yield }
else
Dir.chdir(path)
end
end
}
end
def rtpGetPath(file,extensions=[])
path=getExistingPath(file,extensions)
if !path
Win32::Registry.open(
Win32::Registry::HKEY_LOCAL_MACHINE,"SOFTWARE\\Enterbrain\\RGSS\\RTP"){|key|
path=rtpGetPathHelper(key,"RTP1",file,extensions)
path=rtpGetPathHelper(key,"RTP2",file,extensions) if !path
path=rtpGetPathHelper(key,"RTP3",file,extensions) if !path }
end
return path
end
def getPlayMusic
begin
ret=true
Win32::Registry.open(
Win32::Registry::HKEY_CURRENT_USER,"SOFTWARE\\Enterbrain\\RGSS"){|key|
ret=(key["PlayMusic"] == 1)}
return ret
rescue
return true
end
end
def getPlaySound
begin
ret=true
Win32::Registry.open(
Win32::Registry::HKEY_CURRENT_USER,"SOFTWARE\\Enterbrain\\RGSS"){|key|
ret=(key["PlaySound"] == 1)}
return ret
rescue
p $!.message,$!.class.name
return true
end
end
module FileTest
Image_ext = ['.bmp', '.png', '.jpg', '.jpeg']
Audio_ext = ['.mp3', '.mid', '.midi', '.ogg', '.wav', '.wma']
def self.audio_exist?(filename)
return !rtpGetPath(filename,Audio_ext).nil?
end
def self.image_exist?(filename)
return !rtpGetPath(filename,Image_ext).nil?
end
end
class Hangup < Exception
end
def strsplit(str,re)
ret=[]
tstr=str
while re=~tstr
ret[ret.length]=$~.pre_match
tstr=$~.post_match
end
ret[ret.length]=tstr if ret.length
return ret
end
def canonicalize(c)
csplit=strsplit(c,/[\/\\]/)
pos=-1
ret=[]
retstr=""
for x in csplit
if x=="."
elsif x==".."
if pos>=0
ret.delete_at(pos)
pos-=1
end
else
ret.push(x)
pos+=1
end
end
for i in 0...ret.length
retstr+="/" if i>0
retstr+=ret[i]
end
return retstr
end
class Game_System
attr_accessor :bgm_position
def audioBgmPlay(str,vol,pitch,position)
Audio.bgm_play(str,vol,pitch,position)
end
def audioBgmFade(time)
Audio.bgm_fade(time)
end
def audioBgmStop
Audio.bgm_stop
end
def bgm_play_ex(bgm,volume,pitch,setplaying,position=0)
if bgm.is_a?(String)
bgm=RPG::AudioFile.new(bgm,volume,pitch)
end
if setplaying
@playing_bgm = bgm==nil ? nil : bgm.clone
end
if bgm != nil and bgm.name != ""
audioBgmPlay("Audio/BGM/" + bgm.name, bgm.volume, bgm.pitch,position) if !@defaultBGM
else
audioBgmStop if !@defaultBGM
end
if @defaultBGM
audioBgmPlay("Audio/BGM/"+@defaultBGM.name, @defaultBGM.volume,@defaultBGM.pitch,position)
end
Graphics.frame_reset
end
def bgm_play(bgm,volume=100,pitch=100,position=0)
bgm_play_ex(bgm,volume,pitch,true,position)
end
def bgm_stop
@bgm_position=0
@playing_bgm = nil
audioBgmStop if !@defaultBGM
end
def bgm_fade(time)
@playing_bgm = nil
audioBgmFade((time * 1000).floor) if !@defaultBGM
end
def getPlayingBGM
return @playing_bgm ? @playing_bgm.clone : nil
end
def bgm_memorize
@memorized_bgm = @playing_bgm
end
def bgm_restore
bgm_play(@memorized_bgm)
end
def setDefaultBGM(bgm,volume=100,pitch=100)
if bgm.is_a?(String)
bgm=RPG::AudioFile.new(bgm,volume,pitch)
end
if bgm != nil and bgm.name != ""
@defaultBGM=bgm==nil ? nil : bgm.clone
Audio.bgm_play("Audio/BGM/"+bgm.name)
else
@defaultBGM=nil
self.bgm_play(@playing_bgm)
end
end
def bgm_pause(fadetime=0.0)
pos=Audio.bgm_position
if fadetime>0.0
bgm_fade(fadetime)
end
@bgm_position=pos
end
def bgm_unpause
@bgm_position=0
end
def bgm_resume(bgm,volume=100,pitch=100);
bgm_play(bgm,volume,pitch,@bgm_position)
@bgm_position=0
end
end
#==============================================================================
# Scene_Map
#==============================================================================
class Scene_Map
def call_battle
$game_temp.battle_calling = false
$game_temp.menu_calling = false
$game_temp.menu_beep = false
$game_player.make_encounter_count
$playingBGM=$game_system.playing_bgm
$game_system.bgm_pause
$game_system.se_play($data_system.battle_start_se)
$game_system.bgm_play($game_system.battle_bgm)
$game_player.straighten
$scene = Scene_Battle.new
end
end
#==============================================================================
# Scene_Battle
#==============================================================================
class Scene_Battle
#--------------------------------------------------------------------------
alias battle_end_alias battle_end
def battle_end(result)
battle_end_alias(result)
Audio.me_stop
$game_system.bgm_resume($playingBGM)
end
end
Zitieren
Ich kenne diese Funktion, aber leider bietet sie nicht das, was ich will.