Início
Entrar
Cadastre-se
Mensagens
MoedasHOR (Halo, Ombre e Reflet)
por Fabien
tutorial em portugues por phcs666 a.k.a Czarine
Introdução por Fabien
tutorial em portugues por phcs666 a.k.a Czarine
Script que possibilita utilizar efeitos no mapa como halo, sombra e reflexo.
Características
- Cria halo em volta dos eventos / personagem (um contorno brilhante)
- Cria uma sombra que se estica conforme o evento / personagem se distancia do ponto de luz
- Cria um reflexo simples do evento no chão, simulando estar na aguá ou em um piso espelhado
Screenshots
Como usar
Copie e cole o script acima do main.
Instruções de uso no cabeçalho do script.
Demo
Em Anexo.
Script
- Código:
#================================================================
# HOR (Halo, Ombre e Reflet) v0.99a
#----------------------------------------------------------------
# por Fabien (rpgmakerxp-factory.net)
# tutorial em portugues por phcs666 a.k.a Czarine (phcs@live.com)
#================================================================
# Para ligar o efeito de halo use:
#
# halo(id, opacity, flou, cor, zoom)
#
# onde:
#
# id = ID do evento (0 para o heroi)
# opacity = opacidade do brilho
# flou = semelhança na forma do brilho com o evento
# cor = cor do brilho, no formato Color.new(255,255,255,255)
# zoom = tamanho do brilho
#
# para desligar o efetio de halo use:
#
# $game_map.halos.delete(id) // id = ID do evento (0 para o heroi)
#----------------------------------------------------------------
# Para ligar o efeito de sombra use:
#
# ombre(id, source, opacity, flou, desop, altitude)
#
# onde:
#
# id = ID do evento (0 para o heroi)
# source = ID do evento fonte de luz (0 para o heroi)
# opacity = opacidade da sombra
# flou = semelhança na forma da sombra com o evento
# desop = distancia da luz que a sombra começa a sumir
# altitude = simula a altitude da fonte de luz (quanto maior, menor a sombra)
#
# para desligar o efeito de sombra use:
#
# $game_map.ombres.delete(id) // id = ID do evento (0 para o heroi)
#----------------------------------------------------------------
# Para ligar o efeito de reflexo use:
#
# reflet(id, opacity, flou)
#
# onde:
#
# id = ID do evento (0 para o heroi)
# opacity = opacidade do reflexo
# flou = semelhança na forma do reflexo com o evento
#
# para desligar o efetio de reflexo use:
#
# $game_map.reflets.delete(id) // id = ID do evento (0 para o heroi)
#================================================================
#--------------------------------------------------------------
# halo
#--------------------------------------------------------------
def halo(ref, opacity = 100, flou = 5, color = Color.new(255,255,255,255), zoom = 1)
if ref.is_a?(Array)
ref.each{|a|halo(a,opacity,flou,color,zoom)}
return
end
$game_map.halos[ref] = Hor.new if not $game_map.halos.has_key?(ref)
$game_map.halos[ref].type = "halos"
$game_map.halos[ref].id = ref
$game_map.halos[ref].ref = ref
$game_map.halos[ref].opacity = opacity
$game_map.halos[ref].zoom = zoom
$game_map.halos[ref].flou = flou
$game_map.halos[ref].color = color
true
end
#--------------------------------------------------------------
# ombre
#--------------------------------------------------------------
def ombre(ref, source, opacity = 150, flou = 3, desop = 50, altitude = 80)
if ref.is_a?(Array)
ref.each{|a|ombre(a,source,opacity,flou,desop,altitude)}
return
end
$game_map.ombres[ref]=Hor.new if not $game_map.ombres.has_key?(ref)
$game_map.ombres[ref].type="ombres"
$game_map.ombres[ref].id=ref
$game_map.ombres[ref].source=source
$game_map.ombres[ref].opacity=opacity
$game_map.ombres[ref].flou=flou
$game_map.ombres[ref].desop=desop
$game_map.ombres[ref].altitude=altitude
true
end
#------------------------
def reflets(*ids)
ids.each{|id|reflet id}
end
#------------------------
#--------------------------------------------------------------
# reflet
#--------------------------------------------------------------
def reflet(ref, opacity = 150, flou = 3, dz = -100)
if ref.is_a?(Array)
ref.each{|a|reflet(a,opacity,flou,z)}
return
end
$game_map.reflets[ref] = Hor.new if not $game_map.reflets.has_key?(ref)
$game_map.reflets[ref].type = "reflets_sol"
$game_map.reflets[ref].id = ref
$game_map.reflets[ref].opacity = opacity
$game_map.reflets[ref].flou = flou
$game_map.reflets[ref].dz = dz
true
end
#================================================================
# Game_Map
#================================================================
class Game_Map
attr_accessor :halos, :ombres, :reflets # declaração
#--------------------------------------------------------------
# setup
#--------------------------------------------------------------
alias setup_hor setup
def setup(map_id)
setup_hor(map_id)
@halos = Hash.new #elt = [evts_concernés,type,p1,p2,...]
@ombres = Hash.new
@reflets = Hash.new
end
#--------------------------------------------------------------
end
#================================================================
# Classe de armazenamento de informações sobre as luzes
#----------------------------------------------------------------
# Permite um acesso mais intuitivo
#================================================================
Hor
= Struct.new( "Hor", :type, :ref, :id, :opacity, :zoom, :flou, :color,
:stock, :source, :angle, :desop, :altitude, :effacer, :dz, :chara_name)
#================================================================
# HOR
#================================================================
class HOR
#--------------------------------------------------------------
# inicialização
#--------------------------------------------------------------
def initialize(viewport, ref, original)
@ref = ref
@sprite = Sprite_Character.new(viewport, original.character)
@sprite.visible = false
end
#--------------------------------------------------------------
# dispose
#--------------------------------------------------------------
def dispose
@sprite.dispose
end
#--------------------------------------------------------------
# maj_hor
#--------------------------------------------------------------
def maj_hor(original, hor)
a = "hor" + @ref.to_s
original.character.character_name += a
if original.character.character_name != @chara_name
RPG::Cache.stocker_bitmap("Graphics/Characters/", original.character.character_name, chara_flou(original.bitmap,hor.flou))
@chara_name = original.character.character_name
end
@sprite.character = original.character
@sprite.update
original.character.character_name = original.character.character_name[0...-a.size]
end
#--------------------------------------------------------------
# maj_halo
#--------------------------------------------------------------
def maj_halo(original, hor)
maj_hor(original, hor)
@sprite.angle = 0
@sprite.opacity = eval(hor.opacity.to_s)
@sprite.z -= 1
@sprite.blend_type = 1
@sprite.zoom_x = eval(hor.zoom.to_s)
@sprite.zoom_y = eval(hor.zoom.to_s)
@sprite.color = hor.color
@sprite.oy = @sprite.src_rect.height / 2
@sprite.y -= original.src_rect.height / 2
end
#--------------------------------------------------------------
# maj_reflet
#--------------------------------------------------------------
def maj_reflet(original, hor)
maj_hor(original, hor)
@sprite.mirror = true
@sprite.opacity = hor.opacity
@sprite.z += hor.dz
@sprite.angle = 180
end
#--------------------------------------------------------------
# maj_ombre
#--------------------------------------------------------------
def maj_ombre(original, hor)
maj_hor(original, hor)
ev1 = (hor.source == 0 ? $game_player : $game_map.events[hor.source] )
id = original.character.id
ev2 = (id == 0 ? $game_player : $game_map.events[id] )
angle = Math.atan2(ev1.screen_y - ev2.screen_y, ev1.screen_x - ev2.screen_x)
@sprite.angle = -57.3 * angle + 90
distance = Math.hypot(ev1.screen_y - ev2.screen_y, ev1.screen_x - ev2.screen_x)
@sprite.opacity = hor.opacity - distance * hor.desop / 100
@sprite.opacity = 0 if distance == 0
@sprite.tone = Tone.new(255,255,255)
@sprite.blend_type = 2
@sprite.z -= 1
dh = (hor.altitude - original.src_rect.height)
if dh <= 0
@sprite.zoom_y = 10
else
@sprite.zoom_y = distance / dh
@sprite.zoom_y = 10 if @sprite.zoom_y > 10
end
angle = @sprite.angle / 90
a = (ev2.direction * (angle.to_i * 2)) % 10
a = ev2.direction if angle.to_i == 0
@sprite.src_rect.y = (a - 2) / 2 * @sprite.src_rect.height
end
#--------------------------------------------------------------
end
#================================================================
# Spriteset_Map
#================================================================
class Spriteset_Map
#--------------------------------------------------------------
# update
#--------------------------------------------------------------
alias update_hor update
def update
update_hor
@halos=Hash.new if @halos==nil
@ombres=Hash.new if @ombres==nil
@reflets=Hash.new if @reflets==nil
$game_map.halos.each{|ref,value|@halos[ref]=HOR.new(@viewport1,ref,@character_sprites[value.id-1])
if not @halos.has_key?(ref)}
$game_map.ombres.each{|ref,value|@ombres[ref]=HOR.new(@viewport1,ref,@character_sprites[value.id-1])
if not @ombres.has_key?(ref)}
$game_map.reflets.each{|ref,value|@reflets[ref]=HOR.new(@viewport1,ref,@character_sprites[value.id-1])
if not @reflets.has_key?(ref)}
@halos.each{|ref,hor|hor.maj_halo(spri($game_map.halos,ref),$game_map.halos[ref]) if effacer?($game_map.halos,@halos,ref)}
@ombres.each{|ref,hor|
hor.maj_ombre(spri($game_map.ombres,ref),$game_map.ombres[ref]) if
effacer?($game_map.ombres,@ombres,ref)}
@reflets.each{|ref,hor|hor.maj_reflet(spri($game_map.reflets,ref),$game_map.reflets[ref])
if effacer?($game_map.reflets,@reflets,ref)}
end
#--------------------------------------------------------------
# effacer?
#--------------------------------------------------------------
def effacer?(hors_data,hors,ref)
if not hors_data.has_key?(ref)
hors[ref].dispose
hors.delete(ref)
return false
end
return true
end
#--------------------------------------------------------------
# spri
#--------------------------------------------------------------
def spri(hash,ref) # renvoie le sprite
return @character_sprites[hash[ref].id-1]
end
#--------------------------------------------------------------
end
#--------------------------------------------------------------
# chara_flow
#
# Preparação da imagem de base, se já não for um bitmap
#--------------------------------------------------------------
def chara_flou(original, intensite = 1)
original = RPG::Cache.picture(original) if original.is_a?(String)
if original.is_a?(Numeric)
original = 0 ? original = $game_player.character_name : original = $game_map.events[original].character_name
original = RPG::Cache.character(original, 0)
end
return original if intensite==0
# flou horizontal
bitmap1 = Bitmap.new(original.width + 4 * 2 * intensite, original.height)
for n in 0..2 * intensite
for x in 0...4
bitmap1.blt(x * bitmap1.width / 4 + n, 0, original, Rect.new(x *
original.width / 4, 0, original.width / 4, original.height), 255 / (2 *
intensite))
end
end
# flou vertical
bitmap2 = Bitmap.new(bitmap1.width, original.height + 4 * 2 * intensite)
for n in 0..2 * intensite
for y in 0...4
bitmap2.blt(0, y * bitmap2.height / 4 + n, bitmap1, Rect.new(0, y
* bitmap1.height / 4,bitmap1.width, bitmap1.height / 4), 255 / (2 *
intensite))
end
end
# retrição de opacidade original
bitmapf = Bitmap.new(original.width + 4 * 2 * intensite, original.height + 4 * 2 * intensite)
2 * intensite.times do
bitmapf.blt(0, 0, bitmap2, bitmap2.rect)
end
bitmap1.dispose
bitmap2.dispose
return bitmapf
end
#================================================================
# RPG
#================================================================
module RPG
#--------------------------------------------------------------
# Cache
#--------------------------------------------------------------
module Cache
def self.stocker_bitmap(folder_name, filename,bitmap)
path = folder_name + filename
@cache[path] = bitmap if filename != ""
end
end
#--------------------------------------------------------------
end
#================================================================
# Game_Character
#================================================================
class Game_Character
attr_accessor :character_name
#--------------------------------------------------------------
end
#--------------------------------------------------------------
# lumhalo
#
# Ligação dinamica de lums, halos, sombras e reflexos
#--------------------------------------------------------------
def lumhalo
$lum.lums.each_value{|lum|
next if lum.nom != "lum_base" or not lum.id.is_a?(Numeric)
halo(lum.id, "$lum.lums[" << lum.id.to_s << "].op/2")}
end
#--------------------------------------------------------------
# grp_reflet
#--------------------------------------------------------------
def grp_reflet
reflet 0
groupe.each{|id| reflet id }
end
Créditos e Agradecimentos
- Feito por Fabien
- tutorial em portugues por phcs666 a.k.a Czarine
