(pedido)gif script

[iderval]

bem ente queria perguntar se existe algum script que permita,que o "mostrar img." nos comandos de evento,pudesse reproduzir gifs animadas...espero respostas .

[Sworgui]

eu sei um jeito sem script mas depende do tamanho do gif,por eventos,me
manda a imagem que te falo como deixar o gif,e nem precisa o de mostrar
imagem,tem outro jeito mas o gif tem q ta cortado,tipo todas as imagens
do gif ai vc coloca

<>label:1
<>mostrar imagem 1 (uma das imagens do gif)
<>esperar:2 frames
<>apagar imagem 1
<>mostrar imagem 2
<>esperar:2 frames

<>apagar imagem 2
<>mostrar imagem 1
<>ai vai seguindo até a imagem do fim do gif que vc quer,e
depois vc coloca
<>ir para label 1
ai vai repitindo o gif

se vc quiser que so repeti um ves é so tirar o label e o ir para label

[Vongole Primo]

Massa Cara Eu Tava Precisando Tbm!

[Guilherme Totoli]

Primeiramente, especifique para qual Maker você precisa.

Este Script aqui serve para o XP.

Aqui, o Script:

Código:

=begin

脚本：【怨念产物 - GIF图片播放】

功能：在游戏中播放GIF图片 ※ 表情优先。

说明: 使用步骤：

1、使用 @gs = GIFSprite.new([viewport,[x,[,y,[loop_counts]]]])
创建GIF图片对象；

2、然后使用 @gs.bitmap = "gif_filename" ※ 包含文件夹路径；

3、可以 @gs.loop_counts = n

设置循环次数，-1表示无限循环(默认的)，0就释放图片。

4、@gs.x = x,@gs.y = y,@gs.z = z 等设置各种坐标值。

补充：1、由于考虑的效率问题，提供了生成临时文件技术，即第一运行之后以后每次运

行会直接读取临时文件生成对象，可以使用 GIFSprite.TmpFileclear 清空临时

文件。

2、可以使用 GIFSprite.pre_load(filename_arr) 数组预加载一组图片。

版本：v1.0

作者：灼眼的夏娜

=end


#==============================================================================
# ■ System
#------------------------------------------------------------------------------
# 　处理系统相关的模块 。
#==============================================================================
module System

#--------------------------------------------------------------------------
# ● 模块函数
#--------------------------------------------------------------------------
module_function

#--------------------------------------------------------------------------
# ● API函数声明
#--------------------------------------------------------------------------
WinExec = Win32API.new("kernel32","WinExec",'pi','i')

#--------------------------------------------------------------------------
# ● 查看或修改文件及文件夹属性
# filename ：文件或文件夹名字
#
# +a -a ：添加、删除 存档 属性
# +r -r ：添加、删除 只读 属性
# +s -s ：添加、删除 系统 属性
# +h -h ：添加、删除 隐藏 属性
#--------------------------------------------------------------------------
def attrib(filename,*args)
if args.empty?
astr = `attrib #{filename}`
attri_arr = Array.new
astr = astr.split(/:/)[0]
astr = astr[0,astr.size - 1]
astr.gsub!(/ /,"")
return astr.split(//)
else
cmdline = ""
for cmdchar in args
cmdchar.downcase!
next if cmdline.include? cmdchar
if ["+a","-a","+r","-r","+s","-s","+h","-h"].include? cmdchar
cmdline += " " + cmdchar
end
end
cmdline += " "
result = WinExec.call("attrib #{cmdline}#{filename}",0)
if result < 31
return
end
end
end

end

#==============================================================================
# ■ GIF
#------------------------------------------------------------------------------
# 　分析处理GIF图片的核心模块 。
#==============================================================================
module GIF

# 定义常量
SIZE_GIFH = 6

SIZE_GIFS = 7

SIZE_GIFI = 9

SIZE_GIFC = 6

SIZE_GIFP = 13

SIZE_GIFA = 12

CODE_MASK = [0x0000,
0x0001,0x0003,0x0007,0x000f,
0x001f,0x003f,0x007f,0x00ff,
0x01ff,0x03ff,0x07ff,0x0fff]

INC_TABLE = [8,8,4,2,0]

BGN_TABLE = [0,4,2,1,0]

# 建立文件夹
Dir.mkdir("GIF") unless Dir["*"].include?("GIF")

# 函数定义
module_function

#--------------------------------------------------------------------------
# ● 分解gif图片
#--------------------------------------------------------------------------
def analyze_gif
@old_dir = Dir.pwd
Dir.chdir("GIF")
@total_gif = []
for g in Dir["*"]
suf = g.split(/\./)
if suf[1].is_a?(String) and suf[1].downcase == "gif"
@total_gif.push(g)
Dir.mkdir(suf[0]) unless Dir["*"].include? suf[0]
end
end
@total_gif.each{|file| self.readdata(file)}
Dir.chdir(@old_dir)
p '全部分解完毕，点击确定退出'
exit
end

#--------------------------------------------------------------------------
# ● 读取文件数据：成功返回@gif_infos，失败返回nil
#--------------------------------------------------------------------------
def readdata(filename)
# 检查是否有临时记忆文件
tmp_filename = File.basename(filename,".*")
unless Dir["~TEMP/#{tmp_filename}_infos.fmd"].empty?
begin
giffr = open("~TEMP/#{tmp_filename}_infos.fmd","rb")
tmp_infos = Marshal.load(giffr)
giffr.close
if Dir["~TEMP/#{tmp_filename}_*.png"].size == tmp_infos.total_frames
return tmp_infos
end
rescue
end
end
# 初始化数据
self.initial_var(filename)
# 打开文件
begin
@f = open(filename,"rb")
# 读取文件头
self.read_gifh
# 读取逻辑屏幕描述块
self.read_gifs
# 读取下一个字节
@temp = @f.read(1)[0]
# 循环读取每个图象描述块
while true
if @temp == 0x2c
# 读取图象描述块
self.read_gifi
end
if @temp == 0x21
# 读取图象扩展块
self.read_gife
end
if @temp == 0x3b
break
end
# 读取下一个字节
@temp = @f.read(1)[0]
end
# ※ 设置图象帧数
@gif_infos.total_frames = @frame_count
# ※ 写入图象分解数据
giffw = open("~TEMP/#{@filename}_infos.fmd","wb")
Marshal.dump(@gif_infos,giffw)
giffw.close
rescue
return nil
ensure
@f.close
end
return @gif_infos
end

#--------------------------------------------------------------------------
# ● 初始化变量
#--------------------------------------------------------------------------
def initial_var(filename)
# ※ 生成图象数据对象
@gif_infos = GIFSprite::Infos.new
# 帧数计数
@frame_count = 0
@f = nil
@temp = nil
# 获取文件名
@filename = File.basename(filename,".*")
end

#--------------------------------------------------------------------------
# ● 读取文件头
#--------------------------------------------------------------------------
def read_gifh
@gifh = @f.read(SIZE_GIFH)
if @gifh[0,3] != "GIF"
raise "不是GIF文件!"
end
if @gifh[3,3] != "87a" and @gifh[3,3] != "89a"
raise "不支持的版本!"
end
end

#--------------------------------------------------------------------------
# ● 读取逻辑屏幕描述块
#--------------------------------------------------------------------------
def read_gifs
@gifs = @f.read(SIZE_GIFS).unpack("S2C3")
# 获取调色板位数
@_pal_bits = (@gifs[2] & 7) + 1
# ※ 获取图象宽度
@gif_infos.width = @gifs[0]
# ※ 获取图象高度
@gif_infos.height = @gifs[1]
# 是否有全局调色板
if @gifs[2] >> 7 == 1
# 全局调色板大小
@g_pal_size = 3 * (1 << @_pal_bits)
# 读取全局调色板数据
@g_pal = @f.read(@g_pal_size).unpack("C*")
end
end

#--------------------------------------------------------------------------
# ● 读取图象描述块
#--------------------------------------------------------------------------
def read_gifi
# 读取图象描述块
@gifi = @f.read(SIZE_GIFI).unpack("S4C")
# ※ 生成临时帧数据对象
@gif_fd = GIFSprite::Infos::FrameData.new if @gif_fd.nil?
# ※ 获取帧偏移
@gif_fd.offset_x = @gifi[0]
@gif_fd.offset_y = @gifi[1]
# 获取宽度和高度
@_width = @gifi[2]
@_height = @gifi[3]
# 清空局部调色板
@l_pal = nil
# 是否有局部调色板
if @gifi[4] >> 7 == 1
# 获取调色板位数
@_pal_bits = (@gifi[4] & 7) + 1
# 局部调色板大小
@l_pal_size = 3 * (1 << @_pal_bits)
# 读取局部调色板数据
@l_pal = @f.read(@l_pal_size).unpack("C*")
end
# 获取交错标记
@_lace = (@gifi[4] >> 6) & 1
# 修正调色板位数
@_pal_bits = @_pal_bits == 1 ? 1 : (@_pal_bits <= 4 ? 4 : 8)
# 获取行字节数
@_width_bytes = (((@_width * @_pal_bits) + 31) >> 5) << 2
# 读取图象压缩数据
self.read_lzw_data
# ※ 设置GIF帧数据
@gif_infos.frame_data[@frame_count - 1] = @gif_fd
# ※ 清除帧数据
@gif_fd = nil
end

#--------------------------------------------------------------------------
# ● 读取图象压缩数据
#--------------------------------------------------------------------------
def read_lzw_data
# 解码用
lzw_mincodelen = @f.read(1)[0]
# 帧数加 1
@frame_count += 1
# 图象块数据
image_data = ""
# 块大小
blocksize = @f.read(1)[0]
while blocksize > 0
image_data += @f.read(blocksize)
blocksize = @f.read(1)[0]
end
# 导出图象
self.dump_imgs(image_data,lzw_mincodelen)
end

#--------------------------------------------------------------------------
# ● 读取扩充块
#--------------------------------------------------------------------------
def read_gife
label = @f.read(1)[0]
case label
when 0xf9 # 图形控制扩展块
@gifc = @f.read(SIZE_GIFC).unpack("C2SC2")
# ※ 生成帧数据对象
@gif_fd = GIFSprite::Infos::FrameData.new
# ※ 获取帧数据 延迟时间
@gif_fd.delay_time = @gifc[2]
# ※ 获取下一帧的处理方法
@gif_fd.disposal_method = (@gifc[1] & 28) >> 2
# 获取透明颜色
@_trans_index = nil
if @gifc[1] & 1 > 0
@_trans_index = @gifc[3]
end
when 0x01 # 图形说明扩展块
@gifp = @f.read(SIZE_GIFP).unpack("CS4C4")
blocksize = @f.read(1)[0]
while blocksize > 0
@f.read(blocksize)
blocksize = @f.read(1)[0]
end
when 0xfe # 注解说明扩展块
blocksize = @f.read(1)[0]
while blocksize > 0
@f.read(blocksize)
blocksize = @f.read(1)[0]
end
when 0xff # 应用程序扩展块
@gifa = @f.read(SIZE_GIFA).unpack("C*")
blocksize = @f.read(1)[0]
while blocksize > 0
@f.read(blocksize)
blocksize = @f.read(1)[0]
end
end
end

#--------------------------------------------------------------------------
# ● 设置调色板
#--------------------------------------------------------------------------
def set_pal
@_pal = []
if @l_pal != nil
@_pal = @l_pal
elsif @g_pal != nil
@_pal = @g_pal
else
for i in 0...1 << @_pal_bits
@_pal.push i,i,i
end
end
end

#--------------------------------------------------------------------------
# ● 解码图形数据
#--------------------------------------------------------------------------
def dump_imgs(image_data,lze_len)
@image_data = image_data.unpack("C*")

self.set_pal

@png_data = []

@stack = []
@images = []

@prefix = []
@suffix = []

@bitcount = @_pal_bits
@widthcount = 0

@left_bits = 0x00
@current_bits = lze_len + 0x01

@lzw_clear = 1 << lze_len
@lzw_eoi = @lzw_clear + 1
@nowtablendx = @lzw_clear + 2
@toptablendx = 1 << @current_bits

@wdata = 0
@wcode = 0
@oldcode = 0xffff
@row_num = 0
@tempchar = 0x00
@pass = 0x00
@firstchar = 0
@tempndx = 0
# 读取编码字符
self.read_byte
# 不是@lzw_eoi则循环
while @wcode != @lzw_eoi
# @lzw_clear码
if @wcode == @lzw_clear
for i in 0...@lzw_clear
@prefix[i] = 0xffff
@suffix[i] = i
end
for i in @nowtablendx...4096
@prefix[i] = 0xffff
@suffix[i] = 0x00
end
@current_bits = lze_len + 0x01
@nowtablendx = @lzw_clear + 2
@toptablendx = 1 << @current_bits
@oldcode = 0xffff
# 读取编码字符
self.read_byte
if @wcode != @lzw_eoi
while @prefix[@wcode] != 0xffff
@stack.push(@suffix[@wcode])
@wcode = @prefix[@wcode]
end
@stack.push(@suffix[@wcode])
@firstchar = @stack[-1]
# 输出解码数据
self.output_data
end
else
if @wcode < @nowtablendx
@tempndx = @wcode
else
@tempndx = @oldcode
@stack.push(@firstchar)
end
while @prefix[@tempndx] != 0xffff
@stack.push(@suffix[@tempndx])
@tempndx = @prefix[@tempndx]
end
@stack.push(@suffix[@tempndx])
@firstchar = @stack[-1]
@prefix[@nowtablendx] = @oldcode
@suffix[@nowtablendx] = @firstchar
@nowtablendx += 1
if @nowtablendx == @toptablendx and @current_bits < 12
@current_bits += 1
@toptablendx = 1 << @current_bits
end
# 输出解码数据
self.output_data
end
@oldcode = @wcode
# 读取编码字符
self.read_byte
end
Graphics.update
# 生成png图
self.make_png
end

#--------------------------------------------------------------------------
# ● 读取下一个字节
#--------------------------------------------------------------------------
def read_byte
while @left_bits < @current_bits
@next_char = @image_data.shift
@wdata |= (@next_char << @left_bits)
@left_bits += 0x08
end
@wcode = @wdata & CODE_MASK[@current_bits]
@wdata >>= @current_bits
@left_bits -= @current_bits
end

#--------------------------------------------------------------------------
# ● 输出解码数据
#--------------------------------------------------------------------------
def output_data
while !@stack.empty?
@tempchar |= (@stack.pop << (8 - @bitcount))
if @bitcount == 8
@images.push(@tempchar)
@tempchar = 0x00
@bitcount = @_pal_bits
else
@bitcount += @_pal_bits
end
@widthcount += 1
if @widthcount == @_width
if @bitcount != @_pal_bits
@images.push(@tempchar)
@tempchar = 0x00
@bitcount = @_pal_bits
end
@png_data[@row_num] = @images.clone
@images.clear
if @_lace > 0
@row_num += INC_TABLE[@pass]
if @row_num >= @_height
@pass += 1
@row_num = BGN_TABLE[@pass]
end
else
@row_num += 1
end
@widthcount = 0
end
end
end

#--------------------------------------------------------------------------
# ● 生成png图片
#--------------------------------------------------------------------------
def make_png
fp = open("~TEMP/#@filename" + sprintf("_%02d",@frame_count)+".png","wb")
fp.write(self.make_png_header)
fp.write(self.make_png_ihdr)
fp.write(self.make_png_plte) if @_trans_index.nil?
fp.write(self.make_png_idat)
fp.write(self.make_png_iend)
fp.close
end

#--------------------------------------------------------------------------
# ● png头文件
#--------------------------------------------------------------------------
def make_png_header
return [0x89,0x50,0x4e,0x47,0x0d,0x0a,0x1a,0x0a].pack("C*")
end

#--------------------------------------------------------------------------
# ● png信息头块
#--------------------------------------------------------------------------
def make_png_ihdr
ih_size = [13].pack("N")
ih_sign = "IHDR"
ih_width = [@_width].pack("N")
ih_height = [@_height].pack("N")
if @_trans_index != nil
ih_bit_depth = [@_pal_bits > 8 ? 16 : 8].pack("C")
ih_color_type = [6].pack("C")
else
ih_bit_depth = [@_pal_bits].pack("C")
ih_color_type = [3].pack("C")
end
ih_compression_method = [0].pack("C")
ih_filter_method = [0].pack("C")
ih_interlace_method = [0].pack("C")
string = ih_sign + ih_width + ih_height + ih_bit_depth + ih_color_type +
ih_compression_method + ih_filter_method + ih_interlace_method
ih_crc = [Zlib.crc32(string)].pack("N")
return ih_size + string + ih_crc
end

#--------------------------------------------------------------------------
# ● png调色板块
#--------------------------------------------------------------------------
def make_png_plte
pl_size = [@_pal.size].pack("N")
pl_sign = "PLTE"
pl_data = @_pal.pack("C*")
pl_crc = [Zlib.crc32(pl_sign + pl_data)].pack("N")
return pl_size + pl_sign + pl_data + pl_crc
end

#--------------------------------------------------------------------------
# ● png数据块
#--------------------------------------------------------------------------
def make_png_idat
lz_data = []
if @_trans_index != nil
for i in 0...@png_data.size
lz_data.push 0
for j in @png_data[i]
if j == @_trans_index
lz_data.push @_pal[j*3],@_pal[j*3+1],@_pal[j*3+2],0
else
lz_data.push @_pal[j*3],@_pal[j*3+1],@_pal[j*3+2],255
end
end
end
else
for i in 0...@png_data.size
lz_data.push 0
lz_data += @png_data[i]
end
end
id_data = Zlib::Deflate.deflate(lz_data.pack("C*"),9)
id_size = [id_data.size].pack("N")
id_sign = "IDAT"
id_crc = [Zlib.crc32(id_sign + id_data)].pack("N")
return id_size + id_sign + id_data + id_crc
end

#--------------------------------------------------------------------------
# ● png 结尾块
#--------------------------------------------------------------------------
def make_png_iend
ie_size = [0].pack("N")
ie_sign = "IEND"
ie_crc = [Zlib.crc32(ie_sign)].pack("N")
return ie_size + ie_sign + ie_crc
end

end

#==============================================================================
# ■ Graphics
#------------------------------------------------------------------------------
# 　处理画面的模块 。
#==============================================================================
class << Graphics

#--------------------------------------------------------------------------
# ● 添加别名、线程、临界区
#--------------------------------------------------------------------------
unless method_defined? :origin_update
alias origin_update update
def update_critical
Thread.critical = true
origin_update
Thread.critical = false
end
Thread.new{loop{Graphics.update_critical;sleep(9)}}
end

#--------------------------------------------------------------------------
# ● 定义类变量
#--------------------------------------------------------------------------
@@gif_sprites = Array.new

#--------------------------------------------------------------------------
# ● 添加GIF图片精灵
#--------------------------------------------------------------------------
def add(gs)
@@gif_sprites << gs
end

#--------------------------------------------------------------------------
# ● 删除GIF图片精灵
#--------------------------------------------------------------------------
def del(gs)
@@gif_sprites.delete gs
end

#--------------------------------------------------------------------------
# ● 更新画面
#--------------------------------------------------------------------------
def update
update_critical
@@gif_sprites.each{|gs| gs.update}
end

end

#==============================================================================
# ■ GIFSprite
#------------------------------------------------------------------------------
# 　GIF精灵的核心类 。
#==============================================================================
class GIFSprite

#============================================================================
# ● GIFSprite::Infos
#----------------------------------------------------------------------------
# 　GIF图片信息类 。
#============================================================================
class Infos

#------------------------------------------------------------------------
# ● 定义实例变量
#------------------------------------------------------------------------
attr_accessor :total_frames
attr_accessor :width
attr_accessor :height
attr_accessor :frame_data

#------------------------------------------------------------------------
# ● 初始化
#------------------------------------------------------------------------
def initialize
@total_frames = 0
@width = 0
@height = 0
@frame_data = Array.new
end

#==========================================================================
# ● GIFSprite::Infos::FrameData
#--------------------------------------------------------------------------
# 　GIF图片每帧信息类 。
#==========================================================================
class FrameData

#----------------------------------------------------------------------
# ● 定义实例变量
#----------------------------------------------------------------------
attr_accessor :offset_x
attr_accessor :offset_y
attr_accessor :delay_time
attr_accessor :disposal_method

#----------------------------------------------------------------------
# ● 初始化
#----------------------------------------------------------------------
def initialize
@offset_x = 0
@offset_y = 0
@delay_time = 0
@disposal_method = 0
end

end

end

#--------------------------------------------------------------------------
# ● 预处理：建立临时文件夹
#--------------------------------------------------------------------------
unless Dir["*"].include?("~TEMP")
Dir.mkdir("~TEMP")
System.attrib("~TEMP","+h","+s")
end

#--------------------------------------------------------------------------
# ● 清空硬缓存
#--------------------------------------------------------------------------
def self.TmpFileclear
begin
Dir["~TEMP/*"].each{|filename| File.delete filename}
rescue
end
end

#--------------------------------------------------------------------------
# ● 预加载图片
#--------------------------------------------------------------------------
def self.pre_load(filename_arr)
filename_arr.each{|fn| GIF.readdata(fn)}
end

#--------------------------------------------------------------------------
# ● 定义实例变量
#--------------------------------------------------------------------------
attr_accessor :x
attr_accessor :y
attr_reader :z
attr_accessor :loop_counts
attr_accessor :viewport

#--------------------------------------------------------------------------
# ● 创建对象
#--------------------------------------------------------------------------
def self.new(viewport = nil,x = 0,y = 0,loop_counts = -1)
obj = super()
obj.viewport = viewport
obj.x = x
obj.y = y
obj.loop_counts = loop_counts
Graphics.add(obj)
obj
end

#--------------------------------------------------------------------------
# ● 获取图片信息
#--------------------------------------------------------------------------
def bitmap
@gif_infos
end

#--------------------------------------------------------------------------
# ● 设置图片文件名
#--------------------------------------------------------------------------
def bitmap=(filename)
@gif_infos = GIF.readdata(filename)
if @gif_infos != nil
@sp_arr = Array.new
basename = File.basename(filename,".*")
for i in 0...@gif_infos.total_frames
sp = Sprite.new(@viewport)
sp.bitmap = Bitmap.new(sprintf("~TEMP/#{basename}_%02d.png",i + 1))
sp.visible = i == 0
sp.x = @gif_infos.frame_data[i].offset_x
sp.y = @gif_infos.frame_data[i].offset_y
@sp_arr << sp
end
@update_frame_count = 0
@current_show_frame = 0
@next_frame_counts =
(@gif_infos.frame_data[0].delay_time * Graphics.frame_rate / 100)
end
end

#--------------------------------------------------------------------------
# ● 定义x=
#--------------------------------------------------------------------------
def x=(x)
if @gif_infos.nil?
@x = 0
return
end
@x = x
for i in 0...@gif_infos.total_frames
@sp_arr[i].x = @gif_infos.frame_data[i].offset_x + @x
end
end

#--------------------------------------------------------------------------
# ● 定义y=
#--------------------------------------------------------------------------
def y=(y)
if @gif_infos.nil?
@y = 0
return
end
@y = y
for i in 0...@gif_infos.total_frames
@sp_arr[i].y = @gif_infos.frame_data[i].offset_y + @y
end
end

#--------------------------------------------------------------------------
# ● 定义z=
#--------------------------------------------------------------------------
def z=(z)
if @gif_infos.nil?
@z = 0
return
end
@z = z
for i in 0...@gif_infos.total_frames
@sp_arr[i].z = @z
end
end

#--------------------------------------------------------------------------
# ● 获取宽度
#--------------------------------------------------------------------------
def width
return @gif_infos.nil? ? 0 : @gif_infos.width
end

#--------------------------------------------------------------------------
# ● 获取高度
#--------------------------------------------------------------------------
def height
return @gif_infos.nil? ? 0 : @gif_infos.height
end

#--------------------------------------------------------------------------
# ● 释放精灵
#--------------------------------------------------------------------------
def dispose
Graphics.del(self)
@sp_arr.each{|sp|
sp.bitmap.dispose
sp.dispose
}
@sp_arr.clear
@gif_infos = nil
end

#--------------------------------------------------------------------------
# ● 更新精灵
#--------------------------------------------------------------------------
def update
if @gif_infos.nil?
return
end
@update_frame_count += 1
if @update_frame_count >= @next_frame_counts
@current_show_frame = (@current_show_frame + 1) % @gif_infos.total_frames
case @gif_infos.frame_data[@current_show_frame - 1].disposal_method
when 0 # 不处理

when 1 # 图象保留在原处

when 2 # 当前图象消失
@sp_arr[@current_show_frame - 1].visible = false
when 3 # 尚不明 = =

end
@sp_arr[@current_show_frame].visible = true
if @current_show_frame == 0
@loop_counts -= 1 if @loop_counts > 0
if @loop_counts == 0
self.dispose
return
end
for i in 0...@sp_arr.size
@sp_arr[i].visible = i == @current_show_frame
end
end
@update_frame_count = 0
@next_frame_counts = (@gif_infos.frame_data[@current_show_frame].\
delay_time * Graphics.frame_rate / 100)
end
end

end



Qualquer coisa, me avise.
Até mais!

[Snakin]

Não está funcionando o script q vc forneceu Guilherme. Talvez seja por estar em japonês, ou quem sabe por estar verde (ilegível) os comandos iniciais..

[iderval]

é pra vx o script...

[Snakin]

Neste caso.. erro meu. mas.. tem como converter para XP?

[iderval]

nããããooo foi isso que quiz dizer!!!estou dizendo que o q preciso é pra vx...esse é pra xp...

[Guilherme Totoli]

Tente este Script:

Código:


# Script de compatiblidade (XP para VX)
#==========================================================================
# Criado por sandgolem & Solstice para gamebaker.com
# Versão 3 [VX]
# 9 de Março de 2008
#==========================================================================

module GameBaker
BattleCompatibilityType = 2
end


$DEBUG = $TEST

module Cache
def self.battleback(filename); Cache.system(filename); end
def self.fog(filename); Cache.system(filename); end
def self.gameover(filename); Cache.system(filename); end
def self.icon(filename); Cache.system(filename); end
def self.panorama(filename); Cache.parallax(filename); end
end

module RPG
class Armor
def guard_element_set; return @element_set; end
end

class System
def cursor_se; return @sounds[0]; end
def decision_se; return @sounds[1]; end
def cancel_se; return @sounds[2]; end
def buzzer_se; return @sounds[3]; end
def equip_se; return @sounds[4]; end
def shop_se; return @sounds[17]; end
def save_se; return @sounds[5]; end
def load_se; return @sounds[6]; end
def battle_start_se; return @sounds[7]; end
def escape_se; return @sounds[8]; end
def enemy_collapse_se; return @sounds[11]; end
def actor_collapse_se; return @sounds[13]; end
def windowskin_name; return 'Window'; end
end
end

class Game_Actor
def equip(type,id,test = false); change_equip_by_id(type,id,test); end
end

class Game_Battler
attr_accessor :animation_hit, :critical, :damage, :damage_pop

def current_action; return @action; end
def sp; return @mp; end
def sp=(num); mp = num; end
end

class Game_Character
attr_accessor :character_hue
end

class Game_Interpreter
def command_106; command_230; end
def command_207; command_212; end
def command_208; command_211; end
def command_209; command_205; end
end

class Game_Map
attr_accessor :autotile_names, :battleback_name, :priorities, :tileset_name
attr_accessor :fog_blend_type, :fog_hue, :fog_opacity, :fog_ox, :fog_oy,
:fog_name, :fog_sx, :fog_sy, :fog_tone, :fog_zoom
attr_accessor :panorama_hue, :terrain_tags

def panorama_name; return parallax_name; end
def panorama_name=(num); @parallax_name = num; end
end

class Game_Party
def actors; members; end
def gain_armor(id,num); gain_item($data_armors[id],num); end
def gain_weapon(id,num); gain_item($data_weapons[id],num); end

def gain_item(id,num,something = false)
id = $data_items[id] if id.is_a?(Integer)
gain_item(id,num,something)
end
end

class Game_Player
attr_accessor :transferring, :new_map_id, :new_x, :new_y, :new_direction
end

class Game_System
attr_accessor :magic_number, :message_frame

def battle_interpreter; return $game_troop.interpreter; end
def bgm_play(name); gamebaker_compatibility_sound(name,'RPG::BGM'); end
def bgs_play(name); gamebaker_compatibility_sound(name,'RPG::BGS',80); end
def map_interpreter; return $game_map.interpreter; end
def me_play(name); gamebaker_compatibility_sound(name,'RPG::ME'); end
def message_position; return $game_message.position; end
def message_position=(num); $game_message.position = num; end
def se_play(name); gamebaker_compatibility_sound(name,'RPG::SE',80); end

def gamebaker_compatibility_sound(name,type,vol = 100)
begin
name.play
rescue
pitch = 100
if name.is_a?(RPG::AudioFile)
vol = name.volume
pitch = name.pitch
name = name.name
end
temp = eval(type + '.new(name,' + vol.to_s + ',' + pitch.to_s + ')')
temp.play
end
end
end

class Game_Temp
attr_accessor :gamebaker_compat_gameover2, :battle_main_phase,
:transition_name, :transition_processing, :battleback_name

def gameover; return @gamebaker_compat_gameover2; end
def gameover=(num)
if num == true
if @in_battle
$scene.call_gameover
else
@next_scene = 'gameover'
end
return
end
@gamebaker_compat_gameover2 = nil
@next_scene = nil if @next_scene == 'gameover'
end

def gamebaker_compat_scenecall(num,name)
if num == true
@next_scene = name
elsif @next_scene == name
@next_scene = nil
end
end

def battle_calling; return @next_scene == 'battle'; end
def battle_calling=(num); gamebaker_compat_scenecall(num,'battle'); end
def debug_calling; return @next_scene == 'debug'; end
def debug_calling=(num); gamebaker_compat_scenecall(num,'debug'); end
def menu_calling; return @next_scene == 'menu'; end
def menu_calling=(num); gamebaker_compat_scenecall(num,'menu'); end
def name_calling; return @next_scene == 'name'; end
def name_calling=(num); gamebaker_compat_scenecall(num,'name'); end
def save_calling; return @next_scene == 'save'; end
def save_calling=(num); gamebaker_compat_scenecall(num,'save'); end
def shop_calling; return @next_scene == 'shop'; end
def shop_calling=(num); gamebaker_compat_scenecall(num,'shop'); end
def to_title; return @next_scene == 'title'; end
def to_title=(num); gamebaker_compat_scenecall(num,'title'); end

def battle_abort; return @next_scene == 'map'; end
def battle_abort=(num); $game_temp.next_scene = "map" if num == true; end
def battle_can_escape; return $game_troop.can_escape; end
def battle_can_escape=(num); $game_troop.can_escape = num; end
def battle_can_lose; return $game_troop.can_lose; end
def battle_can_lose=(num); $game_troop.can_lose = num; end
def battle_event_flags; return $game_troop.event_flags; end
def battle_event_flags=(num); $game_troop.event_flags = num; end
def battle_forcing_battler; return $game_troop.forcing_battler; end
def battle_forcing_battler=(num); $game_troop.forcing_battler = num; end
def battle_troop_id; return $game_troop.troop_id; end
def battle_troop_id=(num); $game_troop.gamebaker_compat_id = num; end
def battle_turn; return $game_troop.turn_count; end
def battle_turn=(num); $game_troop.turn_count = num; end

def choice_cancel_type; return $game_message.choice_cancel_type; end
def choice_cancel_type=(num); $game_message.choice_cancel_type = num; end
def choice_max; return $game_message.choice_max; end
def choice_max=(num); $game_message.choice_max = num; end
def choice_proc; return $game_message.choice_proc; end
def choice_proc=(num); $game_message.choice_proc = num; end
def choice_start; return $game_message.choice_start; end
def choice_start=(num); $game_message.choice_start = num; end
def message_proc; return $game_message.main_proc; end
def message_proc=(num); $game_message.main_proc = num; end
def message_text; return $game_message.texts.to_s; end
def message_text=(num); $game_message.texts = num.to_a; end
def message_window_showing; return $game_message.visible; end
def message_window_showing=(num); $game_message.visible = num; end
def num_input_digits_max; return $game_message.num_input_digits_max; end
def num_input_digits_max=(num); $game_message.num_input_digits_max = num; end
def num_input_variable_id; return $game_message.num_input_variable_id; end
def num_input_variable_id=(num); $game_message.num_input_variable_id = num; end

def player_new_direction; return $game_player.new_direction; end
def player_new_direction=(num); $game_player.new_direction = num; end
def player_new_map_id; return $game_player.new_map_id; end
def player_new_map_id=(num); $game_player.new_map_id = num; end
def player_new_x; return $game_player.new_x; end
def player_new_x=(num); $game_player.new_x = num; end
def player_new_y; return $game_player.new_y; end
def player_new_y=(num); $game_player.new_y = num; end
def player_transferring; return $game_player.transferring; end
def player_transferring=(num); $game_player.transferring = num; end
end

class Game_Troop
attr_accessor :event_flags, :gamebaker_compat_id, :troop_id, :turn_count

alias_method :gamebaker_compatibility_setup, :setup
def setup(troop_id)
if @gamebaker_compat_id
troop_id = @gamebaker_compat_id
@gamebaker_compat_id = nil
end
gamebaker_compatibility_setup(troop_id)
end
end

class Scene_Battle
alias_method :gamebaker_compatibility_gameoverjudge, :judge_win_loss
def judge_win_loss
if $game_temp.in_battle && $game_party.all_dead?
$game_temp.gamebaker_compat_gameover2 = true
else
$game_temp.gamebaker_compat_gameover2 = nil
end
return gamebaker_compatibility_gameoverjudge
end


def update_phase4_step3; end
def update_phase4_step4; end
def update_phase4_step5; end

alias_method :gamebaker_compatibility_dispaction, :display_action_effects
def display_action_effects(target, action = nil)
gamebaker_compatibility_dispaction(target, action)
update_phase4_step5
end

alias_method :gamebaker_compatibility_displayanim, :display_animation
def display_animation(targets, animation_id)
update_phase4_step3
gamebaker_compatibility_displayanim(targets, animation_id)
update_phase4_step4
end

if GameBaker::BattleCompatibilityType == 1

def end_actor_select; end_target_actor_selection; end
def end_enemy_select; end_target_enemy_selection; end
def end_item_select; end_item_selection; end
def end_skill_select; end_skill_selection; end
def judge; return judge_win_loss; end
def make_item_action_result; execute_action_item; end
def make_skill_action_result; execute_action_skill; end
def phase3_next_actor; next_actor; end
def phase3_prior_actor; prior_actor; end
def phase3_setup_command_window; start_actor_command_selection; end
def start_actor_select; start_target_actor_selection; end
def start_enemy_select; start_target_enemy_selection; end
def start_item_select; start_item_selection; end
def start_phase2; start_party_command_selection; end
def start_phase4; start_main; end
def start_phase5; process_victory; end
def start_skill_select; start_skill_selection; end
def update_phase2; update_party_command_selection; end
def update_phase2_escape; process_escape; end
def update_phase3; update_actor_command_selection; end
def update_phase3_actor_select; update_target_actor_selection; end
def update_phase3_basic_command; update_actor_command_selection; end
def update_phase3_enemy_select; update_target_enemy_selection; end
def update_phase3_item_select; update_item_selection; end
def update_phase3_skill_select; update_skill_selection; end
def update_phase4_step1; process_action; end
def update_phase4_step2; execute_action; end
def update_phase4_step6; process_action; end

elsif GameBaker::BattleCompatibilityType == 2

def end_actor_select; end
def end_enemy_select; end
def end_item_select; end
def end_skill_select; end
def make_item_action_result; end
def make_skill_action_result; end
def phase3_next_actor; end
def phase3_prior_actor; end
def phase3_setup_command_window; end
def start_actor_select; end
def start_enemy_select; end
def start_item_select; end
def start_phase2; end
def start_phase4; end
def start_phase5; end
def start_skill_select; end
def update_phase2; end
def update_phase2_escape; end
def update_phase3; end
def update_phase3_actor_select; end
def update_phase3_basic_command; end
def update_phase3_enemy_select; end
def update_phase3_item_select; end
def update_phase3_skill_select; end
def update_phase4_step1; end
def update_phase4_step2; end
def update_phase4_step6; end

alias_method :gamebaker_compatibility_endactor, :end_target_actor_selection
def end_target_actor_selection
gamebaker_compatibility_endactor
end_actor_select
end

alias_method :gamebaker_compatibility_endenemy, :end_target_enemy_selection
def end_target_enemy_selection
gamebaker_compatibility_endenemy
end_enemy_select
end

alias_method :gamebaker_compatibility_enditem, :end_item_selection
def end_item_selection
gamebaker_compatibility_enditem
end_item_select
end

alias_method :gamebaker_compatibility_endskill, :end_skill_selection
def end_skill_selection
gamebaker_compatibility_endskill
end_skill_select
end

alias_method :gamebaker_compatibility_judge, :judge_win_loss
def judge; return gamebaker_compatibility_judge; end
def judge_win_loss; return judge; end

alias_method :gamebaker_compatibility_execitem, :execute_action_item
def execute_action_item
gamebaker_compatibility_execitem
make_item_action_result
end

alias_method :gamebaker_compatibility_execskill, :execute_action_skill
def execute_action_skill
gamebaker_compatibility_execskill
make_skill_action_result
end

alias_method :gamebaker_compatibility_nextactor, :next_actor
def next_actor
gamebaker_compatibility_nextactor
phase3_next_actor
end

alias_method :gamebaker_compatibility_prioractor, :prior_actor
def prior_actor
gamebaker_compatibility_prioractor
phase3_prior_actor
end

alias_method :gamebaker_compatibility_startactorc, :start_actor_command_selection
def start_actor_command_selection
gamebaker_compatibility_startactorc
phase3_setup_command_window
end

alias_method :gamebaker_compatibility_startactor, :start_target_actor_selection
def start_target_actor_selection
gamebaker_compatibility_startactor
start_actor_select
end

alias_method :gamebaker_compatibility_startenemy, :start_target_enemy_selection
def start_target_enemy_selection
gamebaker_compatibility_startenemy
start_enemy_select
end

alias_method :gamebaker_compatibility_startitem, :start_item_selection
def start_item_selection
gamebaker_compatibility_startitem
start_item_select
end

alias_method :gamebaker_compatibility_startskill, :start_skill_selection
def start_skill_selection
gamebaker_compatibility_startskill
start_skill_select
end

alias_method :gamebaker_compatibility_startparty, :start_party_command_selection
def start_party_command_selection
gamebaker_compatibility_startparty
start_phase2
end

alias_method :gamebaker_compatibility_startmain, :start_main
def start_main
gamebaker_compatibility_startmain
start_phase4
end

alias_method :gamebaker_compatibility_procvictory, :process_victory
def process_victory
gamebaker_compatibility_procvictory
start_phase5
end

alias_method :gamebaker_compatibility_partycom, :update_party_command_selection
def update_party_command_selection
gamebaker_compatibility_partycom
update_phase2
end

alias_method :gamebaker_compatibility_procescape, :process_escape
def process_escape
gamebaker_compatibility_procescape
update_phase2_escape
end

alias_method :gamebaker_compatibility_procaction, :process_action
def process_action
update_phase4_step6
gamebaker_compatibility_procaction
update_phase4_step1
end

alias_method :gamebaker_compatibility_execaction, :execute_action
def execute_action
gamebaker_compatibility_execaction
update_phase4_step2
end

alias_method :gamebaker_compatibility_updactor, :update_actor_command_selection
def update_actor_command_selection
gamebaker_compatibility_updactor
update_phase3
update_phase3_basic_command
end

alias_method :gamebaker_compatibility_updtactor, :update_target_actor_selection
def update_target_actor_selection
gamebaker_compatibility_updtactor
update_phase3_actor_select
end

alias_method :gamebaker_compatibility_updenemy, :update_target_enemy_selection
def update_target_enemy_selection
gamebaker_compatibility_updenemy
update_phase3_enemy_select
end

alias_method :gamebaker_compatibility_upditem, :update_item_selection
def update_item_selection
gamebaker_compatibility_upditem
update_phase3_item_select
end

alias_method :gamebaker_compatibility_updskill, :update_skill_selection
def update_skill_selection
gamebaker_compatibility_updskill
update_phase3_skill_select
end

elsif GameBaker::BattleCompatibilityType == 3

def end_actor_select; gamebaker_compatibility_endactor; end
def end_enemy_select; gamebaker_compatibility_endenemy; end
def end_item_select; gamebaker_compatibility_enditem; end
def end_skill_select; gamebaker_compatibility_endskill; end
def make_item_action_result; gamebaker_compatibility_execitem; end
def make_skill_action_result; gamebaker_compatibility_execskill; end
def phase3_next_actor; gamebaker_compatibility_nextactor; end
def phase3_prior_actor; gamebaker_compatibility_prioractor; end
def phase3_setup_command_window; gamebaker_compatibility_startactorc; end
def start_actor_select; gamebaker_compatibility_startactor; end
def start_enemy_select; gamebaker_compatibility_startenemy; end
def start_item_select; gamebaker_compatibility_startitem; end
def start_phase2; gamebaker_compatibility_startparty; end
def start_phase4; gamebaker_compatibility_startmain; end
def start_phase5; gamebaker_compatibility_procvictory; end
def start_skill_select; gamebaker_compatibility_startskill; end
def update_phase2; gamebaker_compatibility_partycom; end
def update_phase2_escape; gamebaker_compatibility_procescape; end
def update_phase3; gamebaker_compatibility_updactor; end
def update_phase3_actor_select; gamebaker_compatibility_updtactor; end
def update_phase3_basic_command; end
def update_phase3_enemy_select; gamebaker_compatibility_updenemy; end
def update_phase3_item_select; gamebaker_compatibility_upditem; end
def update_phase3_skill_select; gamebaker_compatibility_updskill; end
def update_phase4_step1; gamebaker_compatibility_procaction; end
def update_phase4_step2; gamebaker_compatibility_execaction; end
def update_phase4_step6; end

alias_method :gamebaker_compatibility_endactor, :end_target_actor_selection
def end_target_actor_selection
end_actor_select
end

alias_method :gamebaker_compatibility_endenemy, :end_target_enemy_selection
def end_target_enemy_selection
end_enemy_select
end

alias_method :gamebaker_compatibility_enditem, :end_item_selection
def end_item_selection
end_item_select
end

alias_method :gamebaker_compatibility_endskill, :end_skill_selection
def end_skill_selection
end_skill_select
end

alias_method :gamebaker_compatibility_judge, :judge_win_loss
def judge; return gamebaker_compatibility_judge; end
def judge_win_loss; return judge; end

alias_method :gamebaker_compatibility_execitem, :execute_action_item
def execute_action_item
make_item_action_result
end

alias_method :gamebaker_compatibility_execskill, :execute_action_skill
def execute_action_skill
make_skill_action_result
end

alias_method :gamebaker_compatibility_nextactor, :next_actor
def next_actor
phase3_next_actor
end

alias_method :gamebaker_compatibility_prioractor, :prior_actor
def prior_actor
phase3_prior_actor
end

alias_method :gamebaker_compatibility_startactorc, :start_actor_command_selection
def start_actor_command_selection
phase3_setup_command_window
end

alias_method :gamebaker_compatibility_startactor, :start_target_actor_selection
def start_target_actor_selection
start_actor_select
end

alias_method :gamebaker_compatibility_startenemy, :start_target_enemy_selection
def start_target_enemy_selection
start_enemy_select
end

alias_method :gamebaker_compatibility_startitem, :start_item_selection
def start_item_selection
start_item_select
end

alias_method :gamebaker_compatibility_startskill, :start_skill_selection
def start_skill_selection
start_skill_select
end

alias_method :gamebaker_compatibility_startparty, :start_party_command_selection
def start_party_command_selection
start_phase2
end

alias_method :gamebaker_compatibility_startmain, :start_main
def start_main
start_phase4
end

alias_method :gamebaker_compatibility_procvictory, :process_victory
def process_victory
start_phase5
end

alias_method :gamebaker_compatibility_partycom, :update_party_command_selection
def update_party_command_selection
update_phase2
end

alias_method :gamebaker_compatibility_procescape, :process_escape
def process_escape
update_phase2_escape
end

alias_method :gamebaker_compatibility_procaction, :process_action
def process_action
update_phase4_step6
update_phase4_step1
end

alias_method :gamebaker_compatibility_execaction, :execute_action
def execute_action
update_phase4_step2
end

alias_method :gamebaker_compatibility_updactor, :update_actor_command_selection
def update_actor_command_selection
update_phase3
update_phase3_basic_command
end

alias_method :gamebaker_compatibility_updtactor, :update_target_actor_selection
def update_target_actor_selection
update_phase3_actor_select
end

alias_method :gamebaker_compatibility_updenemy, :update_target_enemy_selection
def update_target_enemy_selection
update_phase3_enemy_select
end

alias_method :gamebaker_compatibility_upditem, :update_item_selection
def update_item_selection
update_phase3_item_select
end

alias_method :gamebaker_compatibility_updskill, :update_skill_selection
def update_skill_selection
update_phase3_skill_select
end
end
end

class Scene_Equip
alias_method :gamebaker_compatibility_init, :initialize
def initialize
gamebaker_compatibility_init
@right_window = @equip_window
end
end

class Scene_Load
def initialize; $scene = Scene_File.new(false,true,false); end
end

class Scene_Save
def initialize; $scene = Scene_File.new(true,false,false); end
end

class Spriteset_Battle
attr_reader :viewport1, :viewport2
end

class Window_InputNumber < Window_NumberInput
end

class Window_Selectable
attr_accessor :column_max, :item_max
end

[iderval]

hum....n funciona. mesmo assim vlws bor tentar ajudar

[Kyo Panda]

Eu vou tentar esclarecer um pouco o problema.
Eu fiz o teste em ambas as engines, e a única que funcionou foi no RPG Maker VX, não perfeitamente, mas funcionou.
Para exibir uma imagem com o VX, utilize a seguinte linha de comando:

Código:

GIFSprite.new.bitmap = "caminho do arquivo"

Logo, se você quer exibir um gif que esteja na pasta Graphics\System, utilize o seguinte código

Código:

GIFSprite.new.bitmap = ".\\Graphics\\System\\arquivo.gif"

Simples, não?

[Conteúdo patrocinado]