¡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
----------------------------------------
----------------------------------------
----------------------------------------
----------------------------------------
----------------------------------------
----------------------------------------
----------------------------------------
----------------------------------------
----------------------------------------
Últimos temas
» [AYUDA]Hootshot de moghunter
por Rudy_kinneas Hoy a las 01:06

» Necesito Script
por BreinLand entertainment Hoy a las 00:03

» El poder oculto (Segunda entrega)
por alex1633 Ayer a las 23:18

» Holaaa a tod@s!!!
por RiKennedy-Maker Ayer a las 21:53

» Tutorial Interactivo [Uso de interruptores]
por alex1633 Ayer a las 19:39

» Hola mucho gusto
por Hk Diamond Ayer a las 13:49

» SoraDeathss se presenta!
por chronoMxx Ayer a las 07:50

» {AYUDA}Blizz-ABS Script
por chronoMxx Ayer a las 06:45

» las cosas como son...
por Bleuw Ayer a las 04:18

» Busco artistas graficos para proyecto serio
por Rudy_kinneas 2016-12-02, 20:52

Afiliados
Estadísticas
Tenemos 3381 miembros registrados.
El último usuario registrado es Hk Diamond.

Nuestros miembros han publicado un total de 79765 mensajes en 11247 argumentos.
Navega con Google Chrome
[DESCARGA]

Script de gif en mapa.

 :: RPG Maker :: Ayuda RPG

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

Ledai
Aventurero
Aventurero

0/3

Créditos 1364

Gracias : 124

http://ahurallg.blogspot.com.es/

Volver arriba Ir abajo

Ver el tema anterior Ver el tema siguiente Volver arriba


 :: RPG Maker :: Ayuda RPG

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