Mundo Maker
¡Bienvenid@ a Mundo Maker!

¿Quieres aprender todo sobre el RPG Maker?



Regístrate y forma parte de Mundo Maker.
Conectarse

Recuperar mi contraseña

Temas importantes
----------------------------------------
Páginas con recursos RPG Maker
----------------------------------------
----------------------------------------
----------------------------------------
----------------------------------------
----------------------------------------
----------------------------------------
----------------------------------------
----------------------------------------
----------------------------------------
Afiliados
Estadísticas
Tenemos 4197 miembros registrados.
El último usuario registrado es FosForium.

Nuestros miembros han publicado un total de 85248 mensajes en 12139 argumentos.

Script de gif en mapa.

Ver el tema anterior Ver el tema siguiente Ir abajo

RPG Maker XP Script de gif en mapa.

Mensaje por Ledai el 2013-05-12, 14:12

Hola... solo encuentro este script de gif. para xp

pero es solo para los icos, me gustaría que sirviera cualquier imagen; en especial las de la carpeta pictures:
o si conocen otro script que ya lo haga...
Código:
#==============================================================================
# Icons GIF Script [XP]
#------------------------------------------------------------------------------
# Permite que sejam adicionadas ícones GIF ao seu projeto.
#------------------------------------------------------------------------------
# Grupo : Street Coders
# Site : http://www.mundorpgmaker.com/
# Autor : Kyo Panda
# Versão : 1.1
# Lançado em : 31 de Agosto de 2010
#==============================================================================

#==============================================================================
# Agradecimentos:
#------------------------------------------------------------------------------
# * 灼眼的夏娜: Pelo módulo GIF completo, usado para ler as imagens .GIF.
# * CoolChampZ: Pela idealização do script e localização de bugs.
#==============================================================================

#==============================================================================
# Como usar:
#------------------------------------------------------------------------------
#
# #--------------------------------------------------------------------------
# # Instalação
# #--------------------------------------------------------------------------
#
# * Cole o script acima do "Main" e abaixo das "Scene_" no Editor de Scripts
# do RPG Maker XP.
# * Configure o script no guia configuração logo abaixo.
#
#==============================================================================

#==============================================================================
# GIF_Config
#------------------------------------------------------------------------------
# Módulo de configuração do script GIF Script.
#==============================================================================

module GIF_Config
  #--------------------------------------------------------------------------
  # Configuração
  #--------------------------------------------------------------------------
 
  # Desde que não há como definir gifs como ícones manualmente, utilize o
  # seguinte modo para definí-los:
  #
  # id_do_objeto => "arquivo_gif",
  #
  # id_do_objeto : É o ID do item, arma, armdura ou habilidade
  # "arquivo_gif" : É o nome arquivo .gif, sem sua extensão, localzada na pasta
  # base do seu projeto
  #
  # Não se esqueça de colocar a vírgula (,) ap´so a definição de cada arquivo
  # gif, se não colocado, o script pode retornar erros.
 
  # Defina aqui os itens que terão suas imagens como GIF
  ITEMS = {
  # 1 => "Warrior-03-june",
  }
 
  # Defina aqui as armas que terão suas imagens como GIF
  WEAPONS = {
  }
 
  # Defina aqui os armaduras que terão suas imagens como GIF
  ARMORS = {
  }
 
  # Defina aqui as habilidades que terão suas imagens como GIF
  SKILLS = {
  }
 
  #--------------------------------------------------------------------------
  # Fim da configuração
  #--------------------------------------------------------------------------
end

#==============================================================================
# Scene_Title
#------------------------------------------------------------------------------
# Esta classe trata da tela de títulos.
#==============================================================================

class Scene_Title
  #--------------------------------------------------------------------------
  # Alias do comando: Novo Jogo
  #--------------------------------------------------------------------------
  alias kpngifs0001_command_new_game command_new_game
  #--------------------------------------------------------------------------
  # Comando: Novo Jogo
  #--------------------------------------------------------------------------
  def command_new_game
    kpngifs0001_command_new_game
    GIF_Config::ITEMS.each do |id, name|
      $data_items[id].icon_name = name if !$data_items[id].nil?
    end
    GIF_Config::WEAPONS.each do |id, name|
      $data_weapons[id].icon_name = name if !$data_weapons[id].nil?
    end
    GIF_Config::ARMORS.each do |id, name|
      $data_armors[id].icon_name = name if !$data_armors[id].nil?
    end
    GIF_Config::SKILLS.each do |id, name|
      $data_skills[id].icon_name = name if !$data_skills[id].nil?
    end
    kpngifs0001_command_new_game
  end
end

#==============================================================================
# Window_Base
#------------------------------------------------------------------------------
# Esta classe é para todos as janelas do jogo
#==============================================================================

class Window_Base < Window
  #--------------------------------------------------------------------------
  # Alias da inicialização dos Objetos
  #--------------------------------------------------------------------------
  alias kpngifs0001_initialize initialize
  #--------------------------------------------------------------------------
  # Inicialização dos Objetos
  # x : coordenada x da janela
  # y : coordenada y da janela
  # width : largura da janela
  # height : altura da janela
  #--------------------------------------------------------------------------
  def initialize(x, y, width, height)
    @gif_sprites = Array.new
    kpngifs0001_initialize(x, y, width, height)
  end
  #--------------------------------------------------------------------------
  # Alias do dispose
  #--------------------------------------------------------------------------
  alias kpngifs0001_dispose dispose
  #--------------------------------------------------------------------------
  # Dispose
  #--------------------------------------------------------------------------
  def dispose
    @gif_sprites.each{|gif| gif[0].dispose}
    kpngifs0001_dispose
  end
  #--------------------------------------------------------------------------
  # Alias da atualização da tela
  #--------------------------------------------------------------------------
  alias kpngifs0001_update update
  #--------------------------------------------------------------------------
  # Atualização da tela
  #--------------------------------------------------------------------------
  def update
    @gif_sprites.each do |array|
    if array[1] != self.x
      array[0].x = array[0].x + self.x - array[1]
    end
    if array[2] != self.y
      array[0].y = array[0].y + self.y - array[2]
    end
    if array[3] != self.z
      array[0].z = array[0].z + self.z - array[3]
    end
  end
  kpngifs0001_update
  end
  #--------------------------------------------------------------------------
  # Visibilidade
  # visible : Se está visível ou não
  #--------------------------------------------------------------------------
  def visible=(visible)
    super(visible)
    @gif_sprites.each{|sprite| sprite[0].visible = visible}
  end
  #--------------------------------------------------------------------------
  # Alias do desenhar Nome do Item
  #--------------------------------------------------------------------------
  alias kpngifs0001_draw_item_name draw_item_name
  #--------------------------------------------------------------------------
  # Desenhar Nome do Item
  # item : Item
  # x : Desenhar a partir da coordenada x
  # y : Desenhar a partir da coordenada y
  #--------------------------------------------------------------------------
  def draw_item_name(item, x, y)
    if item == nil
      return
    end
    if File.exist?("./Graphics/Icons/" + item.icon_name + ".gif")
      sprite = GIFSprite.new(nil, self.x + x, self.y + y)
      sprite.bitmap = "./Graphics/Icons/" + item.icon_name + ".gif"
      sprite.x = self.x + x + 16
      sprite.y = self.y + y + 16
      sprite.z = self.z + 2
      sprite.opacity = self.opacity
      @gif_sprites << [sprite, self.x, self.y, self.z]
      self.contents.font.color = normal_color
      self.contents.draw_text(x + 28, y, 212, 32, item.name)
    else
      kpngifs0001_draw_item_name(item, x, y)
    end
  end
end

#==============================================================================
# Window_Item
#------------------------------------------------------------------------------
# Esta janela exibe os Itens possuídos na tela de Itens
#==============================================================================

class Window_Item < Window_Selectable
  #--------------------------------------------------------------------------
  # Alias da atualização
  #--------------------------------------------------------------------------
  alias kpngifs0001_refresh refresh
  #--------------------------------------------------------------------------
  # Atualização
  #--------------------------------------------------------------------------
  def refresh
    @gif_sprites.each{|sprite| sprite[0].dispose}
    kpngifs0001_refresh
  end
  #--------------------------------------------------------------------------
  # Desenhar item
  # index : índice de Itens
  #--------------------------------------------------------------------------
  def draw_item(index)
    item = @data[index]
    case item
    when RPG::Item
      number = $game_party.item_number(item.id)
    when RPG::Weapon
      number = $game_party.weapon_number(item.id)
    when RPG::Armor
      number = $game_party.armor_number(item.id)
    end
    if item.is_a?(RPG::Item) and $game_party.item_can_use?(item.id)
      self.contents.font.color = normal_color
    else
      self.contents.font.color = disabled_color
    end
    x = 4 + index % 2 * (288 + 32)
    y = index / 2 * 32
    rect = Rect.new(x, y, self.width / @column_max - 32, 32)
    self.contents.fill_rect(rect, Color.new(0, 0, 0, 0))
    opacity = self.contents.font.color == normal_color ? 255 : 128
    if File.exist?("./Graphics/Icons/" + item.icon_name + ".gif")
      sprite = GIFSprite.new(nil, self.x + x, self.y + y)
      sprite.bitmap = "./Graphics/Icons/" + item.icon_name + ".gif"
      sprite.x = self.x + x + 16
      sprite.y = self.y + y + 16 + 4
      sprite.z = self.z + 2
      sprite.opacity = opacity
      @gif_sprites << [sprite, self.x, self.y, self.z]
    else
      bitmap = RPG::Cache.icon(item.icon_name)
      self.contents.blt(x, y + 4, bitmap, Rect.new(0, 0, 24, 24), opacity)
    end
    self.contents.draw_text(x + 28, y, 212, 32, item.name, 0)
    self.contents.draw_text(x + 240, y, 16, 32, ":", 1)
    self.contents.draw_text(x + 256, y, 24, 32, number.to_s, 2)
  end
end

#==============================================================================
# Window_Skill
#------------------------------------------------------------------------------
# É a janela que mostra as Habilidades
#==============================================================================

class Window_Skill < Window_Selectable
  #--------------------------------------------------------------------------
  # Alias da atualização
  #--------------------------------------------------------------------------
  alias kpngifs0001_refresh refresh
  #--------------------------------------------------------------------------
  # Atualização
  #--------------------------------------------------------------------------
  def refresh
    @gif_sprites.each{|sprite| sprite[0].dispose}
    kpngifs0001_refresh
  end
  #--------------------------------------------------------------------------
  # Desenhando itens
  # index : Número de Itens
  #--------------------------------------------------------------------------
  def draw_item(index)
    skill = @data[index]
    if @actor.skill_can_use?(skill.id)
      self.contents.font.color = normal_color
    else
      self.contents.font.color = disabled_color
    end
    x = 4 + index % 2 * (288 + 32)
    y = index / 2 * 32
    rect = Rect.new(x, y, self.width / @column_max - 32, 32)
    self.contents.fill_rect(rect, Color.new(0, 0, 0, 0))
    opacity = self.contents.font.color == normal_color ? 255 : 128
    if File.exist?("./Graphics/Icons/" + skill.icon_name + ".gif")
      sprite = GIFSprite.new(nil, self.x + x, self.y + y)
      sprite.bitmap = "./Graphics/Icons/" + skill.icon_name + ".gif"
      sprite.x = self.x + x + 16
      sprite.y = self.y + y + 16 + 4
      sprite.z = self.z + 2
      sprite.opacity = opacity
      @gif_sprites << [sprite, self.x, self.y, self.z]
    else
      bitmap = RPG::Cache.icon(skill.icon_name)
      self.contents.blt(x, y + 4, bitmap, Rect.new(0, 0, 24, 24), opacity)
    end
    self.contents.draw_text(x + 28, y, 204, 32, skill.name, 0)
    self.contents.draw_text(x + 232, y, 48, 32, skill.sp_cost.to_s, 2)
  end
end

#==============================================================================
# Window_EquipItem
#------------------------------------------------------------------------------
# Esta é a janela que mostra as escolhas ao se trocar de equipamento.
#==============================================================================

class Window_EquipItem < Window_Selectable
  #--------------------------------------------------------------------------
  # Alias da atualização
  #--------------------------------------------------------------------------
  alias kpngifs0001_refresh refresh
  #--------------------------------------------------------------------------
  # Atualização
  #--------------------------------------------------------------------------
  def refresh
    @gif_sprites.each{|sprite| sprite[0].dispose}
    kpngifs0001_refresh
  end
  #--------------------------------------------------------------------------
  # Desenhar itens
  # index : índice
  #--------------------------------------------------------------------------
  def draw_item(index)
    item = @data[index]
    x = 4 + index % 2 * (288 + 32)
    y = index / 2 * 32
    case item
    when RPG::Weapon
      number = $game_party.weapon_number(item.id)
    when RPG::Armor
      number = $game_party.armor_number(item.id)
    end
    if File.exist?("./Graphics/Icons/" + item.icon_name + ".gif")
      sprite = GIFSprite.new(nil, self.x + x, self.y + y)
      sprite.bitmap = "./Graphics/Icons/" + item.icon_name + ".gif"
      sprite.x = self.x + x + 16
      sprite.y = self.y + y + 16 + 4
      sprite.z = self.z + 2
      sprite.opacity = self.opacity
      @gif_sprites << [sprite, self.x, self.y, self.z]
    else
      bitmap = RPG::Cache.icon(item.icon_name)
      self.contents.blt(x, y + 4, bitmap, Rect.new(0, 0, 24, 24))
    end
    self.contents.font.color = normal_color
    self.contents.draw_text(x + 28, y, 212, 32, item.name, 0)
    self.contents.draw_text(x + 240, y, 16, 32, ":", 1)
    self.contents.draw_text(x + 256, y, 24, 32, number.to_s, 2)
  end
end

#==============================================================================
# Window_EquipRight
#------------------------------------------------------------------------------
# Esta janela exibe o que o Herói tem equipado na tela de Equipamentos.
#==============================================================================

class Window_EquipRight < Window_Selectable
  #--------------------------------------------------------------------------
  # Alias da atualização
  #--------------------------------------------------------------------------
  alias kpngifs0001_refresh refresh
  #--------------------------------------------------------------------------
  # Atualização
  #--------------------------------------------------------------------------
  def refresh
    @gif_sprites.each{|sprite| sprite[0].dispose}
    kpngifs0001_refresh
  end
end

#==============================================================================
# Window_ShopBuy
#------------------------------------------------------------------------------
# É a lista de mercadorias a serem mostradas em uma venda.
#==============================================================================

class Window_ShopBuy < Window_Selectable
  #--------------------------------------------------------------------------
  # Alias da atualização
  #--------------------------------------------------------------------------
  alias kpngifs0001_refresh refresh
  #--------------------------------------------------------------------------
  # Atualização
  #--------------------------------------------------------------------------
  def refresh
    @gif_sprites.each{|sprite| sprite[0].dispose}
    kpngifs0001_refresh
  end
  #--------------------------------------------------------------------------
  # Desenho de um item
  # index : Número de itens
  #--------------------------------------------------------------------------
  def draw_item(index)
    item = @data[index]
    # A quantidade de itens possuídos
    case item
    when RPG::Item
      number = $game_party.item_number(item.id)
    when RPG::Weapon
      number = $game_party.weapon_number(item.id)
    when RPG::Armor
      number = $game_party.armor_number(item.id)
    end
    # Aparece o preço do item se você tiver dinheiro suficiente e menos que 99
    # itens do tipo. Caso contrário haverá uma coloração de invalidez.
    if item.price <= $game_party.gold and number < 99
      self.contents.font.color = normal_color
    else
      self.contents.font.color = disabled_color
    end
    x = 4
    y = index * 32
    rect = Rect.new(x, y, self.width - 32, 32)
    self.contents.fill_rect(rect, Color.new(0, 0, 0, 0))
    opacity = self.contents.font.color == normal_color ? 255 : 128
    if File.exist?("./Graphics/Icons/" + item.icon_name + ".gif")
      sprite = GIFSprite.new(nil, self.x + x, self.y + y)
      sprite.bitmap = "./Graphics/Icons/" + item.icon_name + ".gif"
      sprite.x = self.x + x + 16
      sprite.y = self.y + y + 16 + 4
      sprite.z = self.z + 2
      sprite.opacity = opacity
      @gif_sprites << [sprite, self.x, self.y, self.z]
    else
      bitmap = RPG::Cache.icon(item.icon_name)
      self.contents.blt(x, y + 4, bitmap, Rect.new(0, 0, 24, 24), opacity)
    end
    self.contents.draw_text(x + 28, y, 212, 32, item.name, 0)
    self.contents.draw_text(x + 240, y, 88, 32, item.price.to_s, 2)
  end
end

#==============================================================================
# Window_ShopStatus
#------------------------------------------------------------------------------
# É a janela que mostra o número de Itens possuídos em uma venda.
#==============================================================================

class Window_ShopStatus < Window_Base
  #--------------------------------------------------------------------------
  # Atualização
  #--------------------------------------------------------------------------
  def refresh
    self.contents.clear
    @gif_sprites.each{|sprite| sprite[0].dispose}
    if @item == nil
      return
    end
    case @item
    when RPG::Item
      number = $game_party.item_number(@item.id)
    when RPG::Weapon
      number = $game_party.weapon_number(@item.id)
    when RPG::Armor
      number = $game_party.armor_number(@item.id)
    end
    self.contents.font.color = system_color
    self.contents.draw_text(4, 0, 200, 32, "Você tem")
    self.contents.font.color = normal_color
    self.contents.draw_text(204, 0, 32, 32, number.to_s, 2)
    if @item.is_a?(RPG::Item)
      return
    end
    # Informação adicional do equipamento
    for i in 0...$game_party.actors.size
      # Item é adquirido
      actor = $game_party.actors[i]
      # Aqui é demonstrado se é possível ou impossível equipar o Item pela sua
      # coloração.
      if actor.equippable?(@item)
        self.contents.font.color = normal_color
      else
        self.contents.font.color = disabled_color
      end
      # Desenhar nome do Item
      self.contents.draw_text(4, 64 + 64 * i, 120, 32, actor.name)
      # Descrição do Item é adquirida
      if @item.is_a?(RPG::Weapon)
        item1 = $data_weapons[actor.weapon_id]
      elsif @item.kind == 0
        item1 = $data_armors[actor.armor1_id]
      elsif @item.kind == 1
        item1 = $data_armors[actor.armor2_id]
      else
        item1 = $data_armors[actor.armor3_id]
      end
      # Se for equipável
      if actor.equippable?(@item)
        # Armas
        if @item.is_a?(RPG::Weapon)
          atk1 = item1 != nil ? item1.atk : 0
          atk2 = @item != nil ? @item.atk : 0
          change = atk2 - atk1
        end
        # Armaduras
        if @item.is_a?(RPG::Armor)
          pdef1 = item1 != nil ? item1.pdef : 0
          mdef1 = item1 != nil ? item1.mdef : 0
          pdef2 = @item != nil ? @item.pdef : 0
          mdef2 = @item != nil ? @item.mdef : 0
          change = pdef2 - pdef1 + mdef2 - mdef1
        end
        # Desenhar nome
        self.contents.draw_text(124, 64 + 64 * i, 112, 32,
        sprintf("%+d", change), 2)
      end
      # O Item é desenhado
      if item1 != nil
        x = 4
        y = 64 + 64 * i + 32
        opacity = self.contents.font.color == normal_color ? 255 : 128
        if File.exist?("./Graphics/Icons/" + item1.icon_name + ".gif")
          sprite = GIFSprite.new(nil, self.x + x, self.y + y)
          sprite.bitmap = "./Graphics/Icons/" + item1.icon_name + ".gif"
          sprite.x = self.x + x + 16
          sprite.y = self.y + y + 16 + 4
          sprite.z = self.z + 2
          sprite.opacity = opacity
          @gif_sprites << [sprite, self.x, self.y, self.z]
        else
          bitmap = RPG::Cache.icon(item1.icon_name)
          self.contents.blt(x, y + 4, bitmap, Rect.new(0, 0, 24, 24), opacity)
        end
        self.contents.draw_text(x + 28, y, 212, 32, item1.name)
      end
    end
  end
end

#==============================================================================
# Scene_Equip
#------------------------------------------------------------------------------
# Esta classe processa a tela de Equipamento
#==============================================================================

class Scene_Equip
  #--------------------------------------------------------------------------
  # Alias da atualização do frame
  #--------------------------------------------------------------------------
  alias kpngifs0001_update update
  #--------------------------------------------------------------------------
  # Atualização do frame
  #--------------------------------------------------------------------------
  def update
    @item_window1.update
    @item_window2.update
    @item_window3.update
    @item_window4.update
    @item_window5.update
    kpngifs0001_update
  end
end

#==============================================================================
# GIF
#------------------------------------------------------------------------------
# Permite que sejam adicionadas imagens GIF ao seu projeto.
#------------------------------------------------------------------------------
# Autor : 灼眼的夏娜
# Versão : 1.0
# Tradução PT : Kyo Panda (http://www.mundorpgmaker.com/
#==============================================================================

#==============================================================================
# Como usar:
#------------------------------------------------------------------------------
#
# #--------------------------------------------------------------------------
# # Instalação
# #--------------------------------------------------------------------------
#
# * Cole o script acima do "Main" e abaixo das "Scene_" no Editor de Scripts
# do RPG Maker XP.
#
# #--------------------------------------------------------------------------
# # Utilização
# #--------------------------------------------------------------------------
#
# * Para utilizar uma imagem .GIF utilize os seguintes códigos:
#
# variável = GIFSprite.new(viewport, x, y, loops)
# * Onde: viewport : Refere-se ao Viewport do Sprite
# x : Posicionamento horizontal do Sprite
# y : Posicionamento vertical do Sprite
# loops : Número de loops da imagem GIF
#
# variável.bitmap = arquivo_gif
# * Para definir o arquivo .GIF do sprite
#
#==============================================================================

#==============================================================================
# System
#------------------------------------------------------------------------------
# Módulo de sistema para o script de GIF.
#==============================================================================

module System
  #--------------------------------------------------------------------------
  # Declaração da função do módulo
  #--------------------------------------------------------------------------
  module_function
  #--------------------------------------------------------------------------
  # Declaração API
  #--------------------------------------------------------------------------
  WinExec = Win32API.new("Kernel32", "WinExec", 'pi', 'i')
  #--------------------------------------------------------------------------
  # Retorna se o arquivo é ou não um arquivo .GIF
  # filename : Nome do arquivo .GIF
  # *args : Argumentos para a inspeção
  #--------------------------------------------------------------------------
  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
#------------------------------------------------------------------------------
# Módulo que armazena as configurações de leitura e exibição do arquivo .GIF.
#==============================================================================

module GIF

#--------------------------------------------------------------------------
# Constantes
#--------------------------------------------------------------------------
SIZE_GIFH = 6 # Cabeçalho
SIZE_GIFS = 7 # Descritor de tela
SIZE_GIFI = 9 # Descritor de imagem
SIZE_GIFC = 6 # Descritor de cores
SIZE_GIFP = 13 # Descritor da paleta
SIZE_GIFA = 12 # Terminador
INC_TABLE = [8, 8, 4, 2, 0] # Tabela de latência de cores
BGN_TABLE = [0, 4, 2, 1, 0] # Tabela do background
# Máscara de códigos
CODE_MASK = [
0x0000, 0x0001, 0x0003, 0x0007, 0x000f, 0x001f, 0x003f,
0x007f, 0x00ff, 0x01ff, 0x03ff, 0x07ff, 0x0fff
]
#--------------------------------------------------------------------------
# Cria uma pasta para armazenar em cache o arquivo .GIF se a mesma não
# existir
#--------------------------------------------------------------------------
Dir.mkdir("GIF") unless Dir["*"].include?("GIF")
#--------------------------------------------------------------------------
# Declaração da função do módulo
#--------------------------------------------------------------------------
module_function
#--------------------------------------------------------------------------
# Analisa o arquivo .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 'Erro na leitura do arquivo .GIF'
exit
end
#--------------------------------------------------------------------------
# Realiza a leitura do arquivo .GIF e retorna suas informações
#--------------------------------------------------------------------------
def readdata(filename)
# Nome temporário do arquivo
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
# Inicia o arquivo .GIF
self.initial_var(filename)
# Inicia o processo de leitura
begin
@f = open(filename, "rb")
# Lê o cabeçalho do arquivo
self.read_gifh
# Lê o descritor de tela arquivo
self.read_gifs
# Cria um arquivo temporário com as novas informações
@temp = @f.read(1)[0]
# Enquanto a leitura for possível
while true
if @temp == 0x2c
# Lê o descritor da imagem
self.read_gifi
end
if @temp == 0x21
# Lê o descritor de tempo da imagem
self.read_gife
end
if @temp == 0x3b
break
end
# Cria um novo arquivo com as novas informações
@temp = @f.read(1)[0]
end
# Retorna o total de frames do arquivo
@gif_infos.total_frames = @frame_count
# Lê e grava as informações do arquivo .GIF
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
#--------------------------------------------------------------------------
# Inicia uma nova instância de informações do arquivo .GIF
#--------------------------------------------------------------------------
def initial_var(filename)
# Cria a instância de informações
@gif_infos = GIFSprite::Infos.new
# Define seus valores primários
@frame_count = 0
@f = nil
@temp = nil
# Adquire e armazena o caminho do arquivo
@filename = File.basename(filename, ".*")
end
#--------------------------------------------------------------------------
# Realiza a leitura do cabeçalho do arquivo .GIF
#--------------------------------------------------------------------------
def read_gifh
@gifh = @f.read(SIZE_GIFH)
if @gifh[0, 3] != "GIF"
raise "Arquivo não possui formato GIF ou está corrompido!"
end
if @gifh[3, 3] != "87a" and @gifh[3, 3] != "89a"
raise "Versão do arquivo não suportada!"
end
end
#-------------------------------------------------------------------------
# Realiza a leitura do descritor de tela do arquivo .GIF
#--------------------------------------------------------------------------
def read_gifs
@gifs = @f.read(SIZE_GIFS).unpack("S2C3")
# Define o campo de bits
@_pal_bits = (@gifs[2] & 7) + 1
# Define a largura do arquivo
@gif_infos.width = @gifs[0]
# Define a altura do arquivo
@gif_infos.height = @gifs[1]
# 是否有全局调色板
if @gifs[2] >> 7 == 1
# Define o tamanho do arquivo
@g_pal_size = 3 * (1 << @_pal_bits)
# Realiza a leitura das informações de acordo com o tamanho
@g_pal = @f.read(@g_pal_size).unpack("C*")
end
end
#--------------------------------------------------------------------------
# Realiza a leitura do descritor da imagem do arquivo .GIF
#--------------------------------------------------------------------------
def read_gifi
# Realiza a leitura dos dados da imagem
@gifi = @f.read(SIZE_GIFI).unpack("S4C")
# Define uma nova instância para armazenar os dados se a mesma não existir
@gif_fd = GIFSprite::Infos::FrameData.new if @gif_fd.nil?
# Define o início dos dados da imagem
@gif_fd.offset_x = @gifi[0]
@gif_fd.offset_y = @gifi[1]
# Define a altura e largura dos dados da imagem
@_width = @gifi[2]
@_height = @gifi[3]
# Define a paleta local de cores
@l_pal = nil
# Se o tamanho da paleta de cores não estiver definida
if @gifi[4] >> 7 == 1
# Define os bits da paleta
@_pal_bits = (@gifi[4] & 7) + 1
# Define o tamanho da paleta
@l_pal_size = 3 * (1 << @_pal_bits)
# Armazena o tamanho da paleta
@l_pal = @f.read(@l_pal_size).unpack("C*")
end
@_lace = (@gifi[4] >> 6) & 1
# Define os bits da paleta de cores
@_pal_bits = @_pal_bits == 1 ? 1 : (@_pal_bits <= 4 ? 4 :
# Define o tamanho do descritor
@_width_bytes = (((@_width * @_pal_bits) + 31) >> 5) << 2
# Realiza a leitura do tamanho do bloco de informações
self.read_lzw_data
# Define os dados de tempo
@gif_infos.frame_data[@frame_count - 1] = @gif_fd
# Apaga a instância iniciada
@gif_fd = nil
end
#--------------------------------------------------------------------------
# Realiza a leitura do tamanho do bloco de informações
#--------------------------------------------------------------------------
def read_lzw_data
# Lê a codificação do bloco de informações
lzw_mincodelen = @f.read(1)[0]
# Inicia a contagem de frames
@frame_count += 1
# Inicia os dados da imagem
image_data = ""
# Lê o tamanho do bloco de informações
blocksize = @f.read(1)[0]
while blocksize > 0
image_data += @f.read(blocksize)
blocksize = @f.read(1)[0]
end
# Carrega as imagens com as novas informações
self.dump_imgs(image_data,lzw_mincodelen)
end
#--------------------------------------------------------------------------
# Realiza a leitura do descritor de tempo do arquivo .GIF
#--------------------------------------------------------------------------
def read_gife
label = @f.read(1)[0]
case label
when 0xf9 # Lê os dados dos frames
@gifc = @f.read(SIZE_GIFC).unpack("C2SC2")
# Cria a instância de armazenamento de dados
@gif_fd = GIFSprite::Infos::FrameData.new
# Define o tempo de delay
@gif_fd.delay_time = @gifc[2]
# Define o método de dispose
@gif_fd.disposal_method = (@gifc[1] & 28) >> 2
# Define o index de transição
@_trans_index = nil
if @gifc[1] & 1 > 0
@_trans_index = @gifc[3]
end
when 0x01 # Lê o tamanho da paleta
@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 # Lê o tamanho do bloco de informações
blocksize = @f.read(1)[0]
while blocksize > 0
@f.read(blocksize)
blocksize = @f.read(1)[0]
end
when 0xff # Lê o terminador
@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
#--------------------------------------------------------------------------
# Define a paleta de cores
#--------------------------------------------------------------------------
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
#--------------------------------------------------------------------------
# Carrega e armazena a imagem
#--------------------------------------------------------------------------
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
# Realiza a leitura dos bytes
self.read_byte
# Quando não estiver no fim do arquivo
while @wcode != @lzw_eoi
# Limpa o arquivo
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
# Realiza uma nova leitura dos bytes
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]
# Define os dados de saída
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
# Define os dados de saída
self.output_data
end
@oldcode = @wcode
# Realiza uma nova leitura dos bytes
self.read_byte
end
Graphics.update
# Cria o .PNG de saída
self.make_png
end
#--------------------------------------------------------------------------
# Realiza a leitura dos bytes
#--------------------------------------------------------------------------
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
#--------------------------------------------------------------------------
# Define os dados de saída
#--------------------------------------------------------------------------
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
#--------------------------------------------------------------------------
# Cria o .PNG de saída
#--------------------------------------------------------------------------
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
#--------------------------------------------------------------------------
# Cria o cabeçalho .PNG
#--------------------------------------------------------------------------
def make_png_header
return [0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a].pack("C*")
end
#--------------------------------------------------------------------------
# Cria o descritor de tela .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
#--------------------------------------------------------------------------
# Cria o descritor de imagem .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
#--------------------------------------------------------------------------
# Cria a tebela de dados .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
#--------------------------------------------------------------------------
# Cria o terminador .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
#------------------------------------------------------------------------------
# Classe que rege os gráficos do RPG Maker XP.
#==============================================================================

class << Graphics
#--------------------------------------------------------------------------
# A menos que já haja o método origin_update
#--------------------------------------------------------------------------
unless method_defined? :origin_update
#--------------------------------------------------------------------------
# Alias da atualização da tela
#--------------------------------------------------------------------------
alias origin_update update
#--------------------------------------------------------------------------
# Atualização crítica
#--------------------------------------------------------------------------
def update_critical
Thread.critical = true
origin_update
Thread.critical = false
end
Thread.new{loop{Graphics.update_critical; sleep(9)}}
end
#--------------------------------------------------------------------------
# Cria a array de armazenamento de .GIFs
#--------------------------------------------------------------------------
@@gif_sprites = Array.new
#--------------------------------------------------------------------------
# Adiciona um .GIF a array de armazenamento
#--------------------------------------------------------------------------
def add(gs)
@@gif_sprites << gs
end
#--------------------------------------------------------------------------
# Deleta um .GIF a array de armazenamento
#--------------------------------------------------------------------------
def del(gs)
@@gif_sprites.delete gs
end
#--------------------------------------------------------------------------
# Atualização da tela
#--------------------------------------------------------------------------
def update
update_critical
@@gif_sprites.each{|gs| gs.update}
end
end

#==============================================================================
# GIFSprite
#------------------------------------------------------------------------------
# Classe Sprite que armazena os .GIFs.
#==============================================================================

class GIFSprite

#============================================================================
# GIFSprite::Infos
#----------------------------------------------------------------------------
# Classe que armazena as informações do arquivo .GIFs.
#============================================================================

class Infos
#------------------------------------------------------------------------
# Variáveis públicas
#------------------------------------------------------------------------
attr_accessor :total_frames
attr_accessor :width
attr_accessor :height
attr_accessor :frame_data
#------------------------------------------------------------------------
# Inicialização do objeto
#------------------------------------------------------------------------
def initialize
@total_frames = 0
@width = 0
@height = 0
@frame_data = Array.new
end

#==========================================================================
# GIFSprite::Infos::FrameData
#--------------------------------------------------------------------------
# Classe que armazedna as configurações de tempo dos .GIFs.
#==========================================================================

class FrameData
#----------------------------------------------------------------------
# Variáveis públicas
#----------------------------------------------------------------------
attr_accessor :offset_x
attr_accessor :offset_y
attr_accessor :delay_time
attr_accessor :disposal_method
#----------------------------------------------------------------------
# Inicialização do objeto
#----------------------------------------------------------------------
def initialize
@offset_x = 0
@offset_y = 0
@delay_time = 0
@disposal_method = 0
end
end

end # Fim da Graphics::Infos

#--------------------------------------------------------------------------
# Ao menos que exista a pasta temporária, a mesma é criada
#--------------------------------------------------------------------------
unless Dir["*"].include?("~TEMP")
Dir.mkdir("~TEMP")
System.attrib("~TEMP","+h","+s")
end
#--------------------------------------------------------------------------
# Limpa o cahce de arquivos
#--------------------------------------------------------------------------
def self.TmpFileclear
begin
Dir["~TEMP/*"].each{|filename| File.delete filename}
rescue
end
end
#--------------------------------------------------------------------------
# Faz o carregamento inicial do .GIF
#--------------------------------------------------------------------------
def self.pre_load(filename_arr)
filename_arr.each{|fn| GIF.readdata(fn)}
end
#--------------------------------------------------------------------------
# Variáveis públicas
#--------------------------------------------------------------------------
attr_accessor :x
attr_accessor :y
attr_reader :z
attr_reader :opacity
attr_reader :visible
attr_accessor :loop_counts
attr_accessor :viewport
#--------------------------------------------------------------------------
# Inicialização da instância
# viewport : Viewport do arquivo
# x : Posicionamento horizontal do arquivo
# y : Posicionamento vertical do arquivo
# loop_counts : Número de loops do arquivo
#--------------------------------------------------------------------------
def self.new(viewport = nil, x = 0, y = 0, loop_counts = -1)
obj = super()
obj.x = x
obj.y = y
obj.loop_counts = loop_counts
@visible = true
Graphics.add(obj)
obj
end
#--------------------------------------------------------------------------
# Retorna o bitmap
#--------------------------------------------------------------------------
def bitmap
@gif_infos
end
#--------------------------------------------------------------------------
# Define o bitmap
#--------------------------------------------------------------------------
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
sp.visible = i == 0 if @visible || @visible.nil?
sp.bitmap = Bitmap.new(sprintf("~TEMP/#{basename}_%02d.png", i + 1))
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
#--------------------------------------------------------------------------
# Definição do posicionamento horizontal
#--------------------------------------------------------------------------
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
#--------------------------------------------------------------------------
# Definição do posicionamento vertical
#--------------------------------------------------------------------------
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
#--------------------------------------------------------------------------
# Definição da prioridade
#--------------------------------------------------------------------------
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
#--------------------------------------------------------------------------
# Definição da opacidade
#--------------------------------------------------------------------------
def opacity=(opacity)
if @gif_infos.nil?
@opacity = 0
return
end
@opacity = opacity
for i in 0 ... @gif_infos.total_frames
@sp_arr[i].opacity = @opacity
end
end
#--------------------------------------------------------------------------
# Definição da visibilidade
#--------------------------------------------------------------------------
def visible=(visible)
if @gif_infos.nil?
@visible = false
return
end
@visible = visible
end
#--------------------------------------------------------------------------
# Retorna a largura
#--------------------------------------------------------------------------
def width
return @gif_infos.nil? ? 0 : @gif_infos.width
end
#--------------------------------------------------------------------------
# Retorna a altura
#--------------------------------------------------------------------------
def height
return @gif_infos.nil? ? 0 : @gif_infos.height
end
#--------------------------------------------------------------------------
# Realiza o dispose do .GIF
#--------------------------------------------------------------------------
def dispose
Graphics.del(self)
@sp_arr.each{|sp|
sp.bitmap.dispose
sp.dispose
}
@sp_arr.clear
@gif_infos = nil
end
#--------------------------------------------------------------------------
# Atualização da tela
#--------------------------------------------------------------------------
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 # Oculta o arquivo
@sp_arr[@current_show_frame - 1].visible = false
when 3
end
@sp_arr[@current_show_frame].visible = true if @visible || @visible.nil?
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 if @visible || @visible.nil?
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
avatar
Ledai
Aventurero
Aventurero

0/3

Créditos 2812

Gracias : 174

Volver arriba Ir abajo

Ver el tema anterior Ver el tema siguiente Volver arriba


Permisos de este foro:
No puedes responder a temas en este foro.