[Yoshi]

Sprite Sun

Feito por: Syvkal

Maker Utilizado: RMVX

|Versão: 1.0|

---

Descrição:

Este sistema permite que você e todos os eventos "preparados" gerem sombras
no mapa.

---

Funções:

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.

---

Intruções

Copie os scripts e cole-os acima do main.

.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).

---

ScreenShot

---

Download:

LINK PROTEGIDO!

REGISTRE-SE ou faça o LOGIN para visualizar o link.

---

Script 1:

Spoiler

#==============================================================================
# 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

---

Script 2:

Spoiler

#==============================================================================
# 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

Créditos

Baseado em Sprite Shadow
.Modificado por Rataime
.Novas edições por DerVVulfman
.Modificado para VX por Syvkal
.Traduzido por Bennamy :: Amy Productions

[Avatar]

bem interessante e ficou visualmente legal, mas repare...

a sombra dos prédios vão do oeste para o leste e a sombra dos eventos vai do sudoeste para o nordeste.

não sei se eu sou meio chato, mas.... sombras diferentes geradas pela mesma fonte de luz, fica estranho.

ps. eu sei... sou chato mesmo... e nem uso o VX, então desconsidere...

[Yoshi]

Tem razão Avatar, as dimensões das sombras realmente não batem
Acho que esse sistema é melhor para ser usado em dungeons, fica mais certo assim.

[zecomeia]

Aquela sombra da casa é efeito do tile e não do script, XD.

Show de bola o script, bem legal o efeito.

T+

[Yoshi]

Uma boa idéia seria usar esse script junto com um que remove as sombras automáticas (essas dos tiles), dessa forma, a dimenção das sombras não ficaria estranha. Se não tiver esse script aqui eu posto já já

[Rafael_Sol_MAKER]

Legal pacas!
Bem, dá para preparar charsets com sombrinhas na transparência, mas não para ter o luxo de fazer um solzinho e todo o resto. Vou pegar para estudar que filtro ele usou (aposto que tirou toda a luminância) e como ele distorceu a imagem dado o ângulo e a posição do Sol (aposto que ele deve ter usado senos/cossenos pré-calculados, mas não sei manipular imagens )

edit-----

Pff, ele é bom, mas é basicão, pelo menos é compatível com outros. Não chega nem perto de um script de sombra que vi no RPG Maker XP. Outra, ele não distorce imagens, apenas gira elas.
Pelo menos a sombra é por frame de animação, não é estática. mas bem que o cara podia dar um 'blurzinho' para melhorar isso (eu sei que é uma função recursiva!) O meu Photoshop faz o mesmo com apenas um clique... mas mesmo assim parabéns pros caras que escreveram, eles são muito bons, tenho certeza!

Este post foi editado por Rafael_Sol_MAKER: 09 February 2010 - 10:06 PM

[Hurgete]

Bom, o problema das sombras das casas e dos eventos que não batem, poderiam se facilmente resolvidos colocando o sol gerando a luminosidade do leste para oeste, assim todas as sombras dos jogo estariam na mesma direção...