[Giba]

Introdução :

Bem gente , vim aqui pedir a vocês uma conversão de um script , "Dinamic Shadows" , é muito bom e não encontrei nada com o mesmo efeito no VX , testei ele no mesmo e não funcionou.

Alguém pode fazer esse favor para mim ?

Link :

Link do Tópico : Dinamic Shadows

[Darth Bane]

Tem um script parecido com esse pro VX chamado Sistema de Sol
você coloca um comentario em um evento para simular a luz do sol e o char (e outros eventos) ficam com uma sombra do lado oposto do evento "sol"






Script

Código: [Selecionar]

#==============================================================================
# Sprite Sun
#------------------------------------------------------------------------------
#    Baseado em Sprite Shadow
#    Modificado por Rataime
#    Novas edições por DerVVulfman
#    Modificado para VX por Syvkal
#    Traduzido por Bennamy :: Amy Productions
#    28 de Agosto, 2008
#
#------------------------------------------------------------------------------
#
# Introdução:
#
#  Este sistema permitir que você e todos os eventos "preparados" gerem sombras
#  no mapa. O jogador pode mover-se em torno de um evento de "sol" e
#  será exibida uma sombra. Do mesmo modo, os eventos com um comentário
#  especial dentro da lista de comandos podem igualmente gerar sombras.
#
#------------------------------------------------------------------------------
#
# Instruções:
#
#  -- O Sol
#     Para criar um efeito de sol, você precisa criar um evento no mapa que
#     será usado como "sol". Na maioria das vezes, isto será evento sem um
#     gráfico do jogo. Você não quer "VÊ" o sol, você quer?
#
#     Para fazer um destes eventos ser um sol, você precisa colocar
#     poucas coisas em "comandos de eventos". Essas coisas são nada mais que
#     comentários. 
#
#     O primeiro comentário para adicionar é "begin Sun" (sem aspas). Ele
#     informa o sistema que este mapa tem um efeito do sol. Os outros
#     dois valores são opcionais e possuem valores padrão definidos na seção de
#     configuração (somente apenas adicionadas no script). Esses támbem são
#     adicionados como comentários.
#
#     self_angle  'número'  --- Quanto de um ângulo cada sombra terá.
#     self_opacity 'número' --- O quanto escura a sombra será.
#
#     Após isso, seus personagens podem mover-se e gerar sombras.
#
#  -- Outros Eventos
#     Os eventos não sabem que podem gerar sombras. Para deixá-los gerar uma
#     sombra, tudo que você precisa fazer é adicionar um comentário especial
#     na sua "Lista de Comandos do evento". Este comentário necessário é
#     meramente a frase "begin Shadow" (outra vez, sem aspas).
#
#
#------------------------------------------------------------------------------
#
# Notas da revisão:
#
#  1) Adicionado o cabeçalho formatado e comentários em todo o script.
#  2) Embutindo um código de comentário/parâmetro em um módulo XPML.
#  3) Ajustando o array da sombrado sol em valor de instância para reduzir o resource.
#  4) Compatabilidade com o sistema Near Fantastica's Squad Movement.
#  5) Compatabilidade com o sistema Ccoa's Caterpillar.
#  6) Compatabilidade com o sistema Trickster's Caterpillar.
#  7) Adicionado o ajuste de sombra padrão na seção de configuração.
#
#==============================================================================



   #========================================================================
   #     C  O  N  F  I  G  U  R  A  Ç  à O   D O   S  I  S  T  E  M  A    #
   #========================================================================
    # Sistemas Caterpillar
    CATERPILLAR_COMPATIBLE      = true    # Ativação para Fukuyama's original   
    SQUAD_MOVE_COMPATIBLE       = false   # Ativação para Near Fantastica's SBABS
    CCOA_CATER_COMPATIBLE       = false   # Ativação para Ccoa's Caterpillar
    TRICKSTER_CATER_COMPATIBLE  = false   # Ativação para Trickster's Caterpillar
   
    # Sistema de Sol Específico
    SUN_WARN                    = true    # Verificações para o sistema de sol
    SUN_ANGLE                   = 45      # Ângulo para a sombra do sol gerada
    SUN_OPACITY                 = 128     # Nível da escuridão da sombra

   
   #========================================================================
   #            F I M   D A   C  O  N  F  I  G  U  R  A  Ç  à O           #
   #========================================================================
   
   

#==============================================================================
# Game_Temp
#------------------------------------------------------------------------------
# Esta classe controla dados que não são salvos pelo jogo, os dados temporários
# Pode ser acessada utilizando $game_temp.
#==============================================================================

class Game_Temp
  #--------------------------------------------------------------------------
  # Variáveis públicas
  #--------------------------------------------------------------------------
  attr_accessor :sun_spriteset        # prende spritesets para sombras do "sol"
end

#==============================================================================
# Game_Party
#------------------------------------------------------------------------------
# Classe que trata do Grupo. Inclui informações sobre dinheiro, itens, etc.
# Pode ser acessada utilizando $game_party.
#==============================================================================

class Game_Party
  #--------------------------------------------------------------------------
  # Variáveis públicas
  #--------------------------------------------------------------------------
  attr_reader :characters
end

#==============================================================================
# ** Sprite_Sun
#------------------------------------------------------------------------------
#  Este sprite é usado para posicionar no mapa as sombras do caráter.
#  Observa a classe de Game_Character e muda automaticamente o sprite
#  conforme circunstâncias.
#==============================================================================

class Sprite_Sun < Sprite_Base
  #--------------------------------------------------------------------------
  # Variáveis públicas
  #--------------------------------------------------------------------------
  attr_accessor :character           
  #--------------------------------------------------------------------------
  # Inicialização do objeto
  #     viewport  : viewport
  #     character : personagem (Game_Character)
  #     id        : id
  #--------------------------------------------------------------------------
  def initialize(viewport, character = nil, id=0)
    super(viewport)
    @character = character
    params=$game_temp.sun_spriteset.sun[id]
    self_angle    = SUN_ANGLE
    self_opacity  = SUN_OPACITY
    self_angle    = params[0]   if params.size > 0
    self_opacity  = params[1]   if params.size > 1
    @self_angle   = self_angle
    @self_opacity = self_opacity
    update
  end
  #--------------------------------------------------------------------------
  # Atualização da tela
  #-------------------------------------------------------------------------- 
  def update
    super
    # Se a ID do tile, o nome de arquivo, ou a matiz são diferentes da atual
    if @tile_id != @character.tile_id or
       @character_name != @character.character_name or
       @character_index != @character.character_index
      @tile_id = @character.tile_id
      @character_name = @character.character_name
      @character_index = @character.character_index
      if @tile_id > 0
        sx = (@tile_id / 128 % 2 * 8 + @tile_id % 8) * 32;
        sy = @tile_id % 256 / 8 % 16 * 32;
        set_number = @tile_id / 256
        self.bitmap = Cache.system("TileB") if set_number == 0
        self.bitmap = Cache.system("TileC") if set_number == 1
        self.bitmap = Cache.system("TileD") if set_number == 2
        self.bitmap = Cache.system("TileE") if set_number == 3
        self.src_rect.set(sx, sy, 32, 32)
        self.ox = 16
        self.oy = 32
      else
        self.bitmap = Cache.character(@character_name)
        sign = @character_name[/^[\!\$]./]
        if sign != nil and sign.include?('$')
          @cw = bitmap.width / 3
          @ch = bitmap.height / 4
        else
          @cw = bitmap.width / 12
          @ch = bitmap.height / 8
        end
        self.ox = @cw / 2
        self.oy = @ch
      end
    end
    # Situação visível ajustada
    self.visible = (not @character.transparent)
    # Se o gráfico é do personagem
    if @tile_id == 0
      index = @character.character_index
      pattern = @character.pattern < 3 ? @character.pattern : 1
      # Transferência retangular ajustada
      sx = (index % 4 * 3 + pattern) * @cw
      @direct = @character.direction
      if self.angle > 90 or angle < -90
        sy = ( 4 - 2) / 2 * @ch                   if @direct == 6
        sy = ( 6 - 2) / 2 * @ch                   if @direct == 4
        sy = (@character.direction - 2) / 2 * @ch if @direct != 4 and @direct != 6
      else
        sy = (index / 4 * 4 + (@character.direction - 2) / 2) * @ch
      end
      self.src_rect.set(sx, sy, @cw, @ch)
    end
    # Ajustar côordenadas do sprite   
    self.x = @character.screen_x
    self.y = @character.screen_y-5
    self.z = @character.screen_z- 1
    # Método da mistura e profundidade ajustados do arbusto
    self.opacity = @self_opacity
    self.blend_type = @character.blend_type
    self.bush_depth = @character.bush_depth
    # Animação
    if @character.animation_id != 0
      animation = $data_animations[@character.animation_id]
      animation(animation, true)
      @character.animation_id = 0
    end
    self.angle = @self_angle.to_i - 90
    self.color = Color.new(0, 0, 0)
  end
end

#==============================================================================
# Sprite_Character
#------------------------------------------------------------------------------
# Classe que gerencia os gráficos de personagens a serem exibidos.
# Esta classe está vinculada à classe Game_Character, que a monitora e
# automaticamente muda o status do sprite.
#==============================================================================

class Sprite_Character < Sprite_Base
  #--------------------------------------------------------------------------
  # Lista Alias
  #-------------------------------------------------------------------------- 
  alias sun_initialize initialize
  alias sun_update update
  #--------------------------------------------------------------------------
  # Iniialização do objeto
  #     viewport  : "camada"
  #     character : Personagem (Game_Character)
  #--------------------------------------------------------------------------
  def initialize(viewport, character = nil)
    @viewport0 = Viewport.new(0, 0, 544, 416)
    @viewport0.z = 1
    @character = character
    super(viewport)
    @sunlist=[]
    if character.is_a?(Game_Event) and $game_temp.sun_spriteset.sun != []
      params = XPML.XPML_read("Shadow", @character.id, 2)
      if params != nil
        for i in 0...$game_temp.sun_spriteset.sun.size
          @sunlist.push(Sprite_Sun.new(@viewport0, @character, i))
        end
      end
    end
    if character.is_a?(Game_Player) and $game_temp.sun_spriteset.sun != []
      for i in 0...$game_temp.sun_spriteset.sun.size
        @sunlist.push(Sprite_Sun.new(@viewport0, $game_player, i))
      end
      #===================================================
      # Compatibilidade com Funções Caterpillar
      #===================================================
      if CATERPILLAR_COMPATIBLE and $game_party.characters != nil
        for member in $game_party.characters
          for i in 0...$game_temp.sun_spriteset.sun.size
            @sunlist.push(Sprite_Sun.new(@viewport0, member, i))
          end
        end
      end
      if SQUAD_MOVE_COMPATIBLE and $game_allies.values != nil
        for member in $game_allies.values
          for i in 0...$game_temp.sun_spriteset.sun.size
            @sunlist.push(Sprite_Sun.new(@viewport0, member, i))
          end
        end
      end
      if CCOA_CATER_COMPATIBLE and $game_train.actors != nil
        for member in $game_train.actors
          for i in 0...$game_temp.sun_spriteset.sun.size
            @sunlist.push(Sprite_Sun.new(@viewport0, member, i))
          end
        end
      end
      if TRICKSTER_CATER_COMPATIBLE and $game_party.followers != nil
        for member in $game_party.followers
          for i in 0...$game_temp.sun_spriteset.sun.size
            @sunlist.push(Sprite_Sun.new(@viewport0, member, i))
          end
        end
      end
      #===================================================
      # Fim da compatibilidade
      #===================================================       
    end
    # Perform the original call
    sun_initialize(viewport, @character)
  end
  #--------------------------------------------------------------------------
  # Atualização da tela
  #-------------------------------------------------------------------------- 
  def update
    sun_update
    if @sunlist != []
      for i in 0...@sunlist.size
        @sunlist[i].update
      end
    end
  end 
end

#==============================================================================
# Game_Event
#------------------------------------------------------------------------------
# Esta classe controla os eventos. Verifica as condições para mudar de página
# e funções, como processo paralelo. Utiliza a classe Game_Map.
#==============================================================================

class Game_Event < Game_Character
  #--------------------------------------------------------------------------
  # Variáveis públicas
  #--------------------------------------------------------------------------
  attr_accessor :id
end

#==============================================================================
# Sprite_Character
#------------------------------------------------------------------------------
# Classe que gerencia os gráficos de personagens a serem exibidos.
# Esta classe está vinculada à classe Game_Character, que a monitora e
# automaticamente muda o status do sprite.
#==============================================================================

class Spriteset_Map
  #--------------------------------------------------------------------------
  # Variáveis públicas
  #-------------------------------------------------------------------------- 
  attr_accessor :sun
  #--------------------------------------------------------------------------
  # Lista Alias
  #--------------------------------------------------------------------------   
  alias sun_initialize initialize
  #--------------------------------------------------------------------------
  # Inicialização do objeto
  #--------------------------------------------------------------------------   
  def initialize
    @sun = []
    $game_temp.sun_spriteset = self
    warn = false
    for k in $game_map.events.keys.sort
      if ($game_map.events[k].list != nil and
          $game_map.events[k].list[0].code == 108 and
          ($game_map.events[k].list[0].parameters == ["sun"] or
          $game_map.events[k].list[0].parameters == ["o"]))
        warn = true
      end
      params = XPML.XPML_read("Sun", k, 2)
      $game_temp.sun_spriteset.sun.push(params) if params != nil
    end
    if warn == true and SUN_WARN
      p "Aviso : Pelo menos um evento neste mapa usa uma maneira obsoleta de adicionar um efeito do sol"
    end
    # Executar a chamada original
    sun_initialize
  end 
end

#==============================================================================
# ** module XPML
#------------------------------------------------------------------------------
#  Este módulo segura a leitura e a passagem de parâmetros do "comentário"
#
#  O método principal de XPML é usado para verificar e ler comentários do evento.
#  * Retorna 'nil' se o texto da "verificação" da markup não está presente.
#  * Retorna [] se nenhum parâmetro é passado
#  * Retorna uma lista de parâmetro com o "int" convertido como o int.
#       ex :
#       begin first
#       begin second
#       param1 1
#       param2 two
#       begin third
#       anything 3
#
#   p XPML_read("first", event_id) -> []
#   p XPML_read("second", event_id) -> [1,"two"]
#   p XPML_read("third", event_id) -> [3]
#   p XPML_read("forth", event_id) -> nil
#===================================================

module XPML
  module_function
  #--------------------------------------------------------------------------
  # * XPML_read
  #     markup           : verificar texto no comentário do evento
  #     event_id         : ID do evento
  #     max_param_number : número máximo de parametros/comentários para carregar
  #-------------------------------------------------------------------------- 
  def XPML_read(markup, event_id, max_param_number = 0)
    parameter_list = nil
    event = $game_map.events[event_id]
    return if event.list == nil
      for i in 0...event.list.size
        if event.list[i].code == 108 and
          event.list[i].parameters[0].downcase == "begin " + markup.downcase
          parameter_list = [] if parameter_list == nil
          for j in i + 1...event.list.size
            if event.list[j].code == 108
              parts = event.list[j].parameters[0].split
              if parts.size != 1 and parts[0].downcase != "begin"
                if parts[1].to_i != 0 or parts[1] == "0"
                  parameter_list.push(parts[1].to_i)
                else
                  parameter_list.push(parts[1])
                end
              else
                return parameter_list
              end
            else
              return parameter_list
            end
            if max_param_number != 0 and j == i + max_param_number
              return parameter_list
            end
          end
        end
      end
    return parameter_list
  end
end

Patch de Correção

Código: [Selecionar]

#==============================================================================
# Spriteset_Map
#------------------------------------------------------------------------------
#  Esta classe evita os problemas causados por Sprite_Shadow e Sprite_Sun
#==============================================================================

class Spriteset_Map
  #--------------------------------------------------------------------------
  # Lista Alias
  #-------------------------------------------------------------------------- 
  alias create_viewports_original create_viewports
  alias dispose_viewports_original dispose_viewports
  alias update_viewports_original update_viewports
  alias update_tilemap_original update_tilemap
  alias dispose_tilemap_original dispose_tilemap
  alias create_tilemap_original create_tilemap
  #--------------------------------------------------------------------------
  # Criação dos viewports
  #--------------------------------------------------------------------------
  def create_viewports
    create_viewports_original
    @viewport0 = Viewport.new(0, 0, 544, 416)
    @viewport0.z = 1
    @viewport1.z = 20
  end
  #--------------------------------------------------------------------------
  # Criação dos tiles
  #--------------------------------------------------------------------------
  def create_tilemap
    create_tilemap_original
    @tilemap0 = Tilemap.new(@viewport0)
    @tilemap0.bitmaps[0] = Cache.system("TileA1")
    @tilemap0.bitmaps[1] = Cache.system("TileA2")
    @tilemap0.bitmaps[4] = Cache.system("TileA5")
    @tilemap = Tilemap.new(@viewport1)
    @tilemap.bitmaps[2] = Cache.system("TileA3")
    @tilemap.bitmaps[3] = Cache.system("TileA4")
    @tilemap.bitmaps[5] = Cache.system("TileB")
    @tilemap.bitmaps[6] = Cache.system("TileC")
    @tilemap.bitmaps[7] = Cache.system("TileD")
    @tilemap.bitmaps[8] = Cache.system("TileE")
    @tilemaps = [@tilemap, @tilemap0]
    @tilemaps.each {|x| x.map_data = $game_map.data}
    @tilemaps.each {|x| x.passages = $game_map.passages}
    reset_shadows
  end
  #--------------------------------------------------------------------------
  # Resetar Sombras Automáticas
  #--------------------------------------------------------------------------
  def reset_shadows
    data = @tilemap0.map_data
    # Cada quadrado no mapa
    for x in 0...data.xsize
      for y in 0...data.ysize
        # Verificar se há sombra sutomática
        if data[x,y,1] == 0
          # Substituir a sombra automática
          @tilemap0.map_data[x,y,1] = data[x,y,0] == 0 ? 25 : @tilemap0.map_data[x,y,0]
        end
      end
    end
  end
  #--------------------------------------------------------------------------
  # Dispose dos tiles
  #--------------------------------------------------------------------------
  def dispose_tilemap
    dispose_tilemap_original
    @tilemap0.dispose
  end
  #--------------------------------------------------------------------------
  # Dispose dos Viewports
  #--------------------------------------------------------------------------
  def dispose_viewports
    @viewport0.dispose
    dispose_viewports_original
  end
  #--------------------------------------------------------------------------
  # Atualização dos tiles
  #--------------------------------------------------------------------------
  def update_tilemap
    update_tilemap_original
    @tilemap0.ox = $game_map.display_x / 8
    @tilemap0.oy = $game_map.display_y / 8
    @tilemap0.update
  end
  #--------------------------------------------------------------------------
  # Atualização dos viewports
  #--------------------------------------------------------------------------
  def update_viewports
    update_viewports_original
    @viewport0.tone = $game_map.screen.tone
    @viewport0.ox = $game_map.screen.shake
    @viewport0.update
  end
end



as instruções estão no script
tem também essa demo aqui


espero que ajude

[Giba]

Putz , ajudar até ajudou só tem um problema.

Ele precisa ser configurado o angulo e talz , e como se trata de uma parte onde a iluminação vem de luzes isso não fica legal.

Esperando que alguém consiga uma conversão .-.

[Alex Crosslight]

Pronto tio Giba, o básico das instruções.

Cole o script acima do main, para criar uma luminosidade, crie um evento com o comentário Shadow, para fazer um evento ter sombra, crie um evento com o comentário o.

Qualquer duvida, me avise.

PS: Eu quase ia me esquecendo, você deve usar apenas charsets de um unico personagem, se usar o de 8 personagens, ele irá gerar 4 sombras ao invés de uma.

Iterashai!

Código: [Selecionar]

#==============================================================================
# ** Dynamic Shadows
#------------------------------------------------------------------------------
# Rataime
# Version 4.0
# 06/05/2007 (2007-05-06)
# Version 1.0 was based on Genzai Kawakami's shadows, extra features Boushy
#==============================================================================

#==============================================================================
# Here's the brand new free configuration feature
# The comments will be compared to the pattern using Regexp, except that I did
# the entire work for you, so you don't have to know regexps at all.
# Just choose the trigger ('s', 'begin shadow' or whatever), and the pattern
# The pattern can be one line or a list to use multiple comment lines.
# arg1 is the minimum angle
# arg2 is the maximum angle
# arg3 is the maximum distance
# The only thing you must do is using 'trigger' before the arguments
# Examples :
#
# SHADOWS_SOURCE_COMMENT_TRIGGER = 's'
# SHADOWS_SOURCE_COMMENT_PATTERN = ['trigger','arg1','arg2','arg3']
# SHADOWS_CHAR_COMMENT_TRIGGER = 'o'
# SHADOWS_CHAR_COMMENT_PATTERN = 'trigger'
# is the old way to use shadows, with a single 's' in the first line, and the
# arguments in following lines
#
# SHADOWS_SOURCE_COMMENT_TRIGGER = 'begin shadow source'
# SHADOWS_SOURCE_COMMENT_PATTERN =
# ['trigger','anglemin arg1','anglemax arg2','distancemax arg3']
# SHADOWS_CHAR_COMMENT_TRIGGER = 'begin shadow'
# SHADOWS_CHAR_COMMENT_PATTERN = 'trigger'
# will work with :
# Comment "begin shadow source"
# Comment "anglemin 0"
# Comment "anglemax 0"
# Comment "distancemax 250"
#
# Take the time to choose something you like, and something compatible with other
# scripts.
# Note that the comments will be detected even if they aren't in the beginning
# of the event's action list. Ah, and you can switch the arguments if you like
#==============================================================================

#==============================================================================
# Here is the method I like best, because of its compatibility with other
# scripts. But don't hesitate to change it.
# It will react to something like Shadow|0|0|250
#==============================================================================

 SHADOWS_SOURCE_COMMENT_TRIGGER = 'Shadow'
 SHADOWS_SOURCE_COMMENT_PATTERN = 'trigger|arg1|arg2|arg3'
 SHADOWS_CHAR_COMMENT_TRIGGER = 'o'
 SHADOWS_CHAR_COMMENT_PATTERN = 'trigger'

#==============================================================================
# An important option : if you set it to true, the shadows will get longer if
# you are far from the source. Nice, but induces lag : it will eat your CPU,
# and quite possibly your first born if you try that on a big map.
#==============================================================================
 
 SHADOW_GETS_LONGER = true

#==============================================================================
# Misc options
# If an event has its opacity below SHADOWS_OPACITY_THRESHOLD, no shadow will
# be displayed.
# Set SHADOWS_CATERPILLAR_COMPATIBLE to true if you uses the caterpillar script
#==============================================================================

 SHADOWS_OPACITY_THRESHOLD = 254
 SHADOWS_CATERPILLAR_COMPATIBLE = true

#==============================================================================
# You probably won't need to touch this : it's the 'map' of how to display the
# shadow depending on the event's direction and his relative position to the
# source. a minus means the shadow is mirrored. It seems complex, and it is.
# Complain to Enterbrain (why didn't they use something clockwise or counter-
# clockwise ? I suspect it's because of the rm2k legacy. More explanations
# below.
#==============================================================================

SHADOWS_DIRECTION_ARRAY = Array.new
SHADOWS_DIRECTION_ARRAY[2] = [ -3, 3, -2, 1 ]
SHADOWS_DIRECTION_ARRAY[4] = [ 4, -2, 1, -3 ]
SHADOWS_DIRECTION_ARRAY[6] = [ 1, -3, 4, -2 ]
SHADOWS_DIRECTION_ARRAY[8] = [ -2, 1, -3, 4 ]

#==============================================================================
# ** Game_Party, for compatibility with the caterpillar script.
#==============================================================================

class Game_Party
  attr_reader :characters
end

#==============================================================================
# ** Sprite_Shadow, the meat of this script
#==============================================================================

class Sprite_Shadow < Sprite

  attr_accessor :character
 
  #--------------------------------------------------------------------------
  # * Initialize
  #--------------------------------------------------------------------------
  def initialize(viewport, character = nil,source = nil,anglemin=0, \
                 anglemax=0,distancemax=700)
    super(viewport)
    @anglemin=anglemin.to_f
    @anglemax=anglemax.to_f
    @distancemax=distancemax.to_f
    @character = character
    @source = source
    self.color = Color.new(0, 0, 0)
    update
  end
 
  #--------------------------------------------------------------------------
  # * Update
  #--------------------------------------------------------------------------
  def update
    if @character.transparent or @character.opacity <= SHADOWS_OPACITY_THRESHOLD
      self.visible = false
      return
    end
    @deltax=(@source.real_x-@character.real_x)/4
    @deltay= (@source.real_y-@character.real_y)/4
    @distance = (((@deltax ** 2) + (@deltay ** 2))** 0.5)
    if @distancemax !=0 and @distance>@distancemax
      self.visible = false
      return
    end
    self.angle = 57.3*Math.atan2(@deltax, @deltay )
    @angle_trigo= (self.angle+90) % 360
    if @anglemin !=0 or @anglemax !=0
      if (@angle_trigo<@anglemin or @angle_trigo>@anglemax) and \
          @anglemin<@anglemax
        self.visible = false
        return
      elsif (@angle_trigo<@anglemin and @angle_trigo>@anglemax) and \
             @anglemin>@anglemax
        self.visible = false
        return
      end     
    end
    super
    if @tile_id != @character.tile_id or
       @character_name != @character.character_name or
       @character_index != @character.character_index
      @tile_id = @character.tile_id
      @character_name = @character.character_name
      @character_index = @character.character_index
      if @tile_id >= 384
        self.bitmap = Cache.tile($game_map.tileset_name,
        @tile_id, @character.character_index)
        self.src_rect.set(0, 0, 32, 32)
        self.ox = 17
        self.oy = 32
      else
        self.bitmap = Cache.character(@character.character_name)
        @cw = bitmap.width / 3
        @ch = bitmap.height / 4
        self.ox = @cw / 2
        self.oy = @ch
      end
    end
    self.visible = true
    self.x = @character.screen_x
    self.y = @character.screen_y-5
    self.z = @character.screen_z- 1
    if @character.animation_id != 0
      animation = $data_animations[@character.animation_id]
      animation(animation, true)
      @character.animation_id = 0
    end
    if @tile_id == 0
      sx = @character.pattern * @cw
      quarter = ((@angle_trigo/90+0.5).floor)%4
      # The quarter is the position of the event relative to the source.
      # Imagine the source is the o point (0,0). Trace the 2 lines
      # y=x and y=-x : you get something like a big X
      # On the right, quarter=0. Up, quarter = 1, and so on
      # Take the @character.direction row (2,4,6,8), and the quarter
      # column (0,1,2,3) (remember, it starts at 0), and you'll get
      # a number between 1 and 4. It correspond to the row of the charset
      # the shadow will be, and mirrored if negative.
      # Yes, it isn't obvious, but I didn't find any simple operation to
      # get those.
      magic = SHADOWS_DIRECTION_ARRAY[@character.direction][quarter]
      magic = -magic
      if magic < 0
        self.mirror = true
        magic = -magic
      else
        self.mirror = false
      end
      sy = (magic-1)*@ch
      self.src_rect.set(sx, sy, @cw, @ch)
    end
    # This is the formula of the opacity in function of the distance
    # ** 2 means square
    self.opacity = 1200/((@distance ** 2)/ 1000 + 6)
    # This is the formula of the size in function of the distance
    # The 0.75 is here so you have a size of 1:1 when next to the source.
    self.zoom_y=0.75 + @distance / 256 if SHADOW_GETS_LONGER
  end
 
end

#======================================================================
# ** Sprite_Character EDIT
#======================================================================
#    All those things could go somewhere else, but they
#    work quite well here.
#======================================================================

class Sprite_Character < Sprite_Base
 
  @@regexp_source = nil
  @@regexp_source_short = nil
  @@regexp_char = nil
  @@regexp_char_short = nil
 
  alias rataime_shadow_initialize initialize
 
  #--------------------------------------------------------------------------
  # * Initialize
  #--------------------------------------------------------------------------
  def initialize(viewport, character = nil)
   
    if @@regexp_source == nil
      regexp_initialize
    end
    @character = character
    super(viewport)
    @ombrelist=[]
    if (character.is_a?(Game_Event) and character.list!=nil)
      # Let's check the comments in our event list
      for j_list in 0..character.list.size-1
        #p [@@regexp_source_short, character.list[j_list].parameters[0]]
        if (character.list[j_list].code == 108 and \
            @@regexp_source_short.match(character.list[j_list].parameters[0])!= nil)
          # Haha ! We found a trigger tag ! Time to retrieve the parameters !
          parameter_string = character.list[j_list].parameters[0]
          j_list += 1
          while j_list < character.list.size and \
                (character.list[j_list].code == 108 or \
                 character.list[j_list].code == 408)
            parameter_string = parameter_string + "\n" + \
                               character.list[j_list].parameters[0]
            j_list += 1
          end
          # The following line is a nifty piece of code. Really.
          @anglemin,@anglemax,@distancemax = \
          (regexp_get_parameters(parameter_string, true)+[nil]*3)[0..2]
          # We have our source parameters. Let's find which events we should
          # make have a shadow
          for i in $game_map.events.keys.sort
            if ($game_map.events[i].is_a?(Game_Event) and \
                $game_map.events[i].list!=nil)
              for i_list in 0..$game_map.events[i].list.size-1 
                if (($game_map.events[i].list[i_list].code == 108 or \
                     $game_map.events[i].list[i_list].code == 408 )and \
                    @@regexp_char_short.match( \
                      $game_map.events[i].list[i_list].parameters[0])!= nil)
                  @ombrelist[i+1] = Sprite_Shadow.new(viewport, $game_map.events[i],\
                                              self,@anglemin,@anglemax,@distancemax)
                  break # no need to add more than one shadow per source per event
                end
              end # end for                               
            end                                 
          end # end for
          @ombrelist[1] = Sprite_Shadow.new(viewport, $game_player,self,@anglemin,\
                                             @anglemax,@distancemax)
          #===================================================
          # Compatibility with fukuyama's caterpillar script
          #===================================================
          if SHADOWS_CATERPILLAR_COMPATIBLE and $game_party.characters!=nil
         
            for member in $game_party.characters
              @ombrelist.push(Sprite_Shadow.new(viewport, member,self,@anglemin,\
                                                @anglemax,@distancemax))
            end
         
          end
          #===================================================
          # End of the compatibility
          #===================================================
        end
        break # We don't need to go further in the source's list
      end # end for
    end
    rataime_shadow_initialize(viewport, @character)
  end
 
  alias rataime_shadow_update update
  #--------------------------------------------------------------------------
  # * Update
  #--------------------------------------------------------------------------
  def update
    rataime_shadow_update
    if @ombrelist!=[]
      for i in 1..@ombrelist.size
        if @ombrelist[i]!=nil
          @ombrelist[i].update
        end
      end
    end
  end 
 
  #--------------------------------------------------------------------------
  # * Real_x : it just returns the character's real_x
  #--------------------------------------------------------------------------
  def real_x
    return @character.real_x
  end
 
  #--------------------------------------------------------------------------
  # * Real_y : it just returns the character's real_y
  #--------------------------------------------------------------------------
  def real_y
    return @character.real_y
  end
 
  #--------------------------------------------------------------------------
  # * regexp_initialize : the brand new configuration function
  #   This function generate the regexps based on the configuration
  #--------------------------------------------------------------------------
  def regexp_initialize
    @@regexp_source = regexp_generate(true)
    @@regexp_char = regexp_generate(false)
    @@regexp_source_short = @@regexp_source
    @@regexp_char_short = @@regexp_char
    if SHADOWS_SOURCE_COMMENT_PATTERN.is_a?(Array)
      @@regexp_source_short = regexp_generate_short(@@regexp_source)
    end
    if SHADOWS_CHAR_COMMENT_PATTERN.is_a?(Array)
      @@regexp_char_short = regexp_generate_short(@@regexp_char)
    end
  end
  #--------------------------------------------------------------------------
  # * regexp_generate generate a full length regexp including the arguments
  #   detection.
  #--------------------------------------------------------------------------
  def regexp_generate(source = false)
    if source
      pattern = SHADOWS_SOURCE_COMMENT_PATTERN
      trigger = SHADOWS_SOURCE_COMMENT_TRIGGER
      @@argument_indexes_source = []
      indexes = @@argument_indexes_source
    else
      pattern = SHADOWS_CHAR_COMMENT_PATTERN
      trigger = SHADOWS_CHAR_COMMENT_TRIGGER
      @@argument_indexes_char = []
      indexes = @@argument_indexes_char
    end
    if pattern.is_a?(Array)
      string = Regexp.escape(pattern.join("\n"))
    else
      string = Regexp.escape(pattern)
    end
    string = string.gsub('trigger',')('+trigger+')(')
    splitted = string.split('arg')
    regexp = '\A(' + splitted[0] + '(\d+)){0,1}'
    for i in 1..splitted.size-1
      if splitted[i][0..0].to_i == 0
        p 'Error : You probably forgot a digit after an arg'
        raise
      else
        indexes.push(splitted[i][0..0].to_i)
        regexp = regexp + '(' + splitted[i][1..splitted[i].size-1] + '(\d+)){0,1}'
      end
    end
    return Regexp.new(regexp.chomp('(\d+)){0,1}') + ')')
  end
  #--------------------------------------------------------------------------
  # * Will return a shorter regexp, but still able to identify the trigger
  #--------------------------------------------------------------------------
  def regexp_generate_short(regexp)
    string = regexp.inspect
    string = string.split('\n')[0]
    string = string[1..string.size-2]
    return Regexp.new(string)
  end
  #--------------------------------------------------------------------------
  # * regexp_get_parameters is called whenever a trigger has been identify,
  #   and the script wants to know the arguments. It returns an array in the
  #   right orger [arg1,arg2,arg3]
  #--------------------------------------------------------------------------
  def regexp_get_parameters(string, source = false)
    if source
      regexp = @@regexp_source
      indexes = @@argument_indexes_source.dup
    else
      regexp = @@regexp_char
      indexes = @@argument_indexes_char.dup
    end
    indexes = indexes.reverse!
    match_array = regexp.match(string).captures
    return_array = Array.new
    if match_array.size > 3
      for i in 2..match_array.size-1
        if ((i.to_f/2).ceil)*2 != i and match_array[i]!=nil
          return_array[indexes.pop-1] = match_array[i]
        end
      end
    end
    return return_array
  end
 
end

[Giba]

Valeu Akime.

Problema Resolvido ^^