Release 0.0.1.8.8.7
This commit is contained in:
1 parent
3c8a17aa78
commit
c7beab414c
16283 files changed
+768761
-2
No files matched your search
@@ -0,0 +1,867 @@
|
||||
# encoding: UTF-8
|
||||
#==============================================================================
|
||||
# 129_AnimatedTitleBackground.rb — 2.2.0 POOL-SPAWN-MASK
|
||||
# Для кастомного TitleMenu из ModScripts/120_Scene_MapTitle.rb
|
||||
#------------------------------------------------------------------------------
|
||||
# Установка:
|
||||
# положить этот файл в: ModScripts/129_AnimatedTitleBackground.rb
|
||||
#
|
||||
# Никаких дополнительных картинок не нужно.
|
||||
# Скрипт НЕ заменяет меню и НЕ создаёт новый Scene_Title/Scene_MapTitle.
|
||||
# Он использует уже существующий @sprite1, который у тебя загружает:
|
||||
# Graphics/Online/titleOptBg
|
||||
#
|
||||
# Эффекты:
|
||||
# - очень плавное дыхание/дрейф камеры;
|
||||
# - холодное свечение воды;
|
||||
# - расходящиеся ряби на воде;
|
||||
# - мягкое красное свечение корней;
|
||||
# - световые лучи в глубине пещеры;
|
||||
# - голубые пылинки над водой и красные искры у корней;
|
||||
# - редкое естественное мерцание света;
|
||||
# - небольшой импульс света при смене пункта меню.
|
||||
#
|
||||
# Сам TitleMenu, nickname, online-кнопка, foreground, Title.png и т. д.
|
||||
# не меняются.
|
||||
#==============================================================================
|
||||
|
||||
module OnlineTitleBackgroundFX
|
||||
# ---------------------------------------------------------------------------
|
||||
# НАСТРОЙКИ
|
||||
# ---------------------------------------------------------------------------
|
||||
ENABLE_CAMERA = true
|
||||
ENABLE_POOL_GLOW = true
|
||||
ENABLE_RIPPLES = true
|
||||
ENABLE_ROOT_GLOW = true
|
||||
ENABLE_LIGHT_RAYS = true
|
||||
ENABLE_PARTICLES = true
|
||||
ENABLE_AMBIENT_MIST = true
|
||||
ENABLE_MENU_PULSE = true
|
||||
|
||||
# Координаты рассчитаны под присланный titleOptBg.png (1920x1080).
|
||||
# Это доли изображения: 0.5 = центр.
|
||||
POOL_X = 0.500
|
||||
POOL_Y = 0.645
|
||||
|
||||
CAVE_LIGHT_X = 0.500
|
||||
CAVE_LIGHT_Y = 0.285
|
||||
|
||||
ROOT_LEFT_X = 0.385
|
||||
ROOT_LEFT_Y = 0.420
|
||||
ROOT_RIGHT_X = 0.615
|
||||
ROOT_RIGHT_Y = 0.420
|
||||
|
||||
# Чем больше, тем заметнее эффект движения камеры.
|
||||
# Фон всегда рисуется в режиме cover с небольшим запасом. Запас не даёт
|
||||
# камере открыть пустую полосу ни слева, ни справа на нестандартном экране.
|
||||
SAFE_OVERSCAN = 0.018
|
||||
CAMERA_EXTRA_ZOOM = 0.004
|
||||
CAMERA_BREATH = 0.0018
|
||||
CAMERA_MOVE_X = 1.6
|
||||
CAMERA_MOVE_Y = 1.0
|
||||
INTRO_FRAMES = 45.0
|
||||
|
||||
CYAN_PARTICLES = 22
|
||||
RED_PARTICLES = 30
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# Вспомогательные функции
|
||||
# ---------------------------------------------------------------------------
|
||||
def self.safe_dispose(obj)
|
||||
return if obj.nil?
|
||||
begin
|
||||
obj.dispose unless obj.disposed?
|
||||
rescue
|
||||
begin
|
||||
obj.dispose
|
||||
rescue
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
def self.clamp(value, min_value, max_value)
|
||||
value = min_value if value < min_value
|
||||
value = max_value if value > max_value
|
||||
value
|
||||
end
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# Контроллер эффектов конкретного TitleMenu
|
||||
# ---------------------------------------------------------------------------
|
||||
class Controller
|
||||
Particle = Struct.new(
|
||||
:sprite, :vx, :vy, :phase, :kind, :base_opacity, :age, :lifetime
|
||||
)
|
||||
|
||||
def initialize(menu)
|
||||
@menu = menu
|
||||
@frame = 0
|
||||
@disposed = false
|
||||
@sprites = []
|
||||
@bitmaps = []
|
||||
@ripples = []
|
||||
@particles = []
|
||||
@selection_pulse = 0.0
|
||||
@last_index = read_menu_index
|
||||
@layout_width = nil
|
||||
@layout_height = nil
|
||||
|
||||
@background = fetch_ivar(menu, :@sprite1)
|
||||
@title_layer = fetch_ivar(menu, :@sprite2)
|
||||
|
||||
return unless valid_sprite?(@background)
|
||||
|
||||
@original_background_bitmap = @background.bitmap
|
||||
install_clean_background
|
||||
remember_background_transform
|
||||
refresh_cover_layout(true)
|
||||
create_effects
|
||||
create_character_layer
|
||||
rescue => e
|
||||
debug_log("init", e)
|
||||
end
|
||||
|
||||
def active?
|
||||
valid_sprite?(@background)
|
||||
end
|
||||
|
||||
def update
|
||||
return if @disposed
|
||||
return unless active?
|
||||
|
||||
@frame += 1
|
||||
t = @frame.to_f
|
||||
|
||||
refresh_cover_layout
|
||||
detect_menu_selection
|
||||
update_camera(t) if ENABLE_CAMERA
|
||||
update_pool_glow(t) if ENABLE_POOL_GLOW
|
||||
update_ripples(t) if ENABLE_RIPPLES
|
||||
update_root_glow(t) if ENABLE_ROOT_GLOW
|
||||
update_light_rays(t) if ENABLE_LIGHT_RAYS
|
||||
update_particles(t) if ENABLE_PARTICLES
|
||||
update_ambient_mist(t) if ENABLE_AMBIENT_MIST
|
||||
update_character_layer(t)
|
||||
|
||||
@selection_pulse *= 0.90
|
||||
@selection_pulse = 0.0 if @selection_pulse < 0.002
|
||||
rescue => e
|
||||
debug_log("update", e)
|
||||
end
|
||||
|
||||
def dispose
|
||||
return if @disposed
|
||||
@disposed = true
|
||||
|
||||
restore_background_transform
|
||||
@background.bitmap = @original_background_bitmap if valid_sprite?(@background)
|
||||
|
||||
@particles.each do |p|
|
||||
OnlineTitleBackgroundFX.safe_dispose(p.sprite)
|
||||
end
|
||||
@particles.clear
|
||||
|
||||
@ripples.each do |s|
|
||||
OnlineTitleBackgroundFX.safe_dispose(s)
|
||||
end
|
||||
@ripples.clear
|
||||
|
||||
@sprites.each do |s|
|
||||
OnlineTitleBackgroundFX.safe_dispose(s)
|
||||
end
|
||||
@sprites.clear
|
||||
|
||||
@bitmaps.each do |b|
|
||||
OnlineTitleBackgroundFX.safe_dispose(b)
|
||||
end
|
||||
@bitmaps.clear
|
||||
rescue => e
|
||||
debug_log("dispose", e)
|
||||
end
|
||||
|
||||
# -------------------------------------------------------------------------
|
||||
# Получение существующего фона меню
|
||||
# -------------------------------------------------------------------------
|
||||
def fetch_ivar(obj, name)
|
||||
obj.instance_variable_get(name)
|
||||
rescue
|
||||
nil
|
||||
end
|
||||
|
||||
def valid_sprite?(sprite)
|
||||
return false if sprite.nil?
|
||||
return false if sprite.bitmap.nil?
|
||||
begin
|
||||
return false if sprite.disposed?
|
||||
return false if sprite.bitmap.disposed?
|
||||
rescue
|
||||
end
|
||||
true
|
||||
end
|
||||
|
||||
def read_menu_index
|
||||
@menu.instance_variable_get(:@index).to_i
|
||||
rescue
|
||||
0
|
||||
end
|
||||
|
||||
def detect_menu_selection
|
||||
return unless ENABLE_MENU_PULSE
|
||||
index = read_menu_index
|
||||
if !@last_index.nil? && index != @last_index
|
||||
@selection_pulse = 1.0
|
||||
end
|
||||
@last_index = index
|
||||
end
|
||||
|
||||
def install_clean_background
|
||||
@background.bitmap = Cache.load_bitmap("Graphics/Online/", "titleOptBg_clean")
|
||||
@clean_background_loaded = true
|
||||
rescue => e
|
||||
@clean_background_loaded = false
|
||||
debug_log("clean background", e)
|
||||
@background.bitmap = @original_background_bitmap
|
||||
end
|
||||
|
||||
# -------------------------------------------------------------------------
|
||||
# Базовый transform уже созданного @sprite1
|
||||
# -------------------------------------------------------------------------
|
||||
def remember_background_transform
|
||||
@original_x = @background.x.to_f
|
||||
@original_y = @background.y.to_f
|
||||
@original_zoom_x = @background.zoom_x.to_f
|
||||
@original_zoom_y = @background.zoom_y.to_f
|
||||
@original_tone = Tone.new(
|
||||
@background.tone.red,
|
||||
@background.tone.green,
|
||||
@background.tone.blue,
|
||||
@background.tone.gray
|
||||
)
|
||||
end
|
||||
|
||||
def restore_background_transform
|
||||
return unless valid_sprite?(@background)
|
||||
@background.x = @original_x
|
||||
@background.y = @original_y
|
||||
@background.zoom_x = @original_zoom_x
|
||||
@background.zoom_y = @original_zoom_y
|
||||
@background.tone.set(
|
||||
@original_tone.red,
|
||||
@original_tone.green,
|
||||
@original_tone.blue,
|
||||
@original_tone.gray
|
||||
) if @original_tone
|
||||
rescue
|
||||
end
|
||||
|
||||
# Uniform cover вместо независимого растягивания X/Y. Картинка сохраняет
|
||||
# пропорции, центр остаётся неподвижным, а края всегда уходят за экран.
|
||||
def refresh_cover_layout(force = false)
|
||||
width = Graphics.width
|
||||
height = Graphics.height
|
||||
return if !force && width == @layout_width && height == @layout_height
|
||||
|
||||
bmp = @background.bitmap
|
||||
@layout_width = width
|
||||
@layout_height = height
|
||||
cover_x = width.to_f / bmp.width.to_f
|
||||
cover_y = height.to_f / bmp.height.to_f
|
||||
@base_scale = [cover_x, cover_y].max * (1.0 + SAFE_OVERSCAN)
|
||||
|
||||
@background.zoom_x = @base_scale
|
||||
@background.zoom_y = @base_scale
|
||||
@background.x = (width - bmp.width * @base_scale) * 0.5
|
||||
@background.y = (height - bmp.height * @base_scale) * 0.5
|
||||
|
||||
# При реальном изменении разрешения старые координаты частиц уже невалидны.
|
||||
if !force && @particles
|
||||
@particles.each { |p| reset_particle(p, true) }
|
||||
end
|
||||
end
|
||||
|
||||
def update_camera(t)
|
||||
breath = Math.sin(t / 105.0) * CAMERA_BREATH
|
||||
zoom = @base_scale * (1.0 + CAMERA_EXTRA_ZOOM + breath)
|
||||
bmp = @background.bitmap
|
||||
drift_x = Math.sin(t / 145.0) * CAMERA_MOVE_X * @base_scale
|
||||
drift_y = Math.cos(t / 188.0) * CAMERA_MOVE_Y * @base_scale
|
||||
|
||||
@background.zoom_x = zoom
|
||||
@background.zoom_y = zoom
|
||||
@background.x = (Graphics.width - bmp.width * zoom) * 0.5 + drift_x
|
||||
@background.y = (Graphics.height - bmp.height * zoom) * 0.5 + drift_y
|
||||
|
||||
# Едва заметное изменение температуры кадра.
|
||||
cold = Math.sin(t / 170.0)
|
||||
red = Math.sin(t / 230.0 + 0.8)
|
||||
@background.tone.set(
|
||||
@original_tone.red + red * 1.0,
|
||||
@original_tone.green + cold * 0.4,
|
||||
@original_tone.blue + cold * 1.5,
|
||||
@original_tone.gray
|
||||
)
|
||||
end
|
||||
|
||||
# Перевод координаты из titleOptBg в экран с учётом текущего zoom/offset.
|
||||
def image_point(rx, ry)
|
||||
bmp = @background.bitmap
|
||||
x = @background.x + bmp.width * rx * @background.zoom_x
|
||||
y = @background.y + bmp.height * ry * @background.zoom_y
|
||||
[x, y]
|
||||
end
|
||||
|
||||
def effect_z
|
||||
# Тот же Z, что у @sprite1: эффект создаётся позже него, поэтому оказывается
|
||||
# поверх фона, но остаётся ниже @sprite2/foreground изменённого меню.
|
||||
@background.z + 1
|
||||
rescue
|
||||
0
|
||||
end
|
||||
|
||||
# -------------------------------------------------------------------------
|
||||
# Создание эффектов
|
||||
# -------------------------------------------------------------------------
|
||||
def create_effects
|
||||
create_pool_effects if ENABLE_POOL_GLOW || ENABLE_RIPPLES
|
||||
create_root_effects if ENABLE_ROOT_GLOW
|
||||
create_light_ray_effects if ENABLE_LIGHT_RAYS
|
||||
create_particle_effects if ENABLE_PARTICLES
|
||||
create_ambient_mist if ENABLE_AMBIENT_MIST
|
||||
end
|
||||
|
||||
def create_character_layer
|
||||
return unless @clean_background_loaded
|
||||
bitmap = Cache.load_bitmap("Graphics/Online/", "titleOptBg_devocka")
|
||||
@character = new_sprite(bitmap)
|
||||
@character.z = effect_z + 1
|
||||
@character.opacity = 0
|
||||
rescue => e
|
||||
@character = nil
|
||||
debug_log("character layer", e)
|
||||
end
|
||||
|
||||
def create_pool_effects
|
||||
if ENABLE_POOL_GLOW
|
||||
@pool_glow_bitmap = radial_bitmap(112, Color.new(70, 225, 255, 255), 2.0)
|
||||
keep_bitmap(@pool_glow_bitmap)
|
||||
|
||||
@pool_glow = new_sprite(@pool_glow_bitmap)
|
||||
center_origin(@pool_glow)
|
||||
@pool_glow.blend_type = 1
|
||||
@pool_glow.opacity = 0
|
||||
|
||||
@pool_core_bitmap = radial_bitmap(72, Color.new(130, 245, 255, 255), 1.7)
|
||||
keep_bitmap(@pool_core_bitmap)
|
||||
|
||||
@pool_core = new_sprite(@pool_core_bitmap)
|
||||
center_origin(@pool_core)
|
||||
@pool_core.blend_type = 1
|
||||
@pool_core.opacity = 0
|
||||
end
|
||||
|
||||
if ENABLE_RIPPLES
|
||||
@ripple_bitmap = ring_bitmap(96, Color.new(120, 235, 255, 255))
|
||||
keep_bitmap(@ripple_bitmap)
|
||||
|
||||
4.times do |i|
|
||||
s = Sprite.new(@background.viewport)
|
||||
s.bitmap = @ripple_bitmap
|
||||
center_origin(s)
|
||||
s.z = effect_z
|
||||
s.blend_type = 1
|
||||
s.opacity = 0
|
||||
s.instance_variable_set(:@fx_offset, i / 4.0)
|
||||
@ripples << s
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
def create_root_effects
|
||||
@red_glow_bitmap = radial_bitmap(96, Color.new(225, 38, 34, 255), 2.15)
|
||||
keep_bitmap(@red_glow_bitmap)
|
||||
|
||||
@root_left = new_sprite(@red_glow_bitmap)
|
||||
center_origin(@root_left)
|
||||
@root_left.blend_type = 1
|
||||
|
||||
@root_right = new_sprite(@red_glow_bitmap)
|
||||
center_origin(@root_right)
|
||||
@root_right.blend_type = 1
|
||||
end
|
||||
|
||||
def create_light_ray_effects
|
||||
@ray_bitmap = vertical_ray_bitmap(24, 160, Color.new(105, 175, 195, 255))
|
||||
keep_bitmap(@ray_bitmap)
|
||||
|
||||
@ray_left = new_sprite(@ray_bitmap)
|
||||
@ray_left.ox = @ray_bitmap.width / 2
|
||||
@ray_left.oy = 0
|
||||
@ray_left.blend_type = 1
|
||||
@ray_left.angle = -7
|
||||
|
||||
@ray_right = new_sprite(@ray_bitmap)
|
||||
@ray_right.ox = @ray_bitmap.width / 2
|
||||
@ray_right.oy = 0
|
||||
@ray_right.blend_type = 1
|
||||
@ray_right.angle = 7
|
||||
end
|
||||
|
||||
def create_particle_effects
|
||||
@cyan_particle_bitmap = soft_dot_bitmap(Color.new(120, 240, 255, 255))
|
||||
@red_particle_bitmap = soft_dot_bitmap(Color.new(255, 90, 72, 255))
|
||||
keep_bitmap(@cyan_particle_bitmap)
|
||||
keep_bitmap(@red_particle_bitmap)
|
||||
|
||||
CYAN_PARTICLES.times { create_particle(:cyan) }
|
||||
RED_PARTICLES.times { create_particle(:red) }
|
||||
end
|
||||
|
||||
def create_particle(kind)
|
||||
s = Sprite.new(@background.viewport)
|
||||
s.bitmap = (kind == :cyan ? @cyan_particle_bitmap : @red_particle_bitmap)
|
||||
center_origin(s)
|
||||
s.z = effect_z
|
||||
s.blend_type = 1
|
||||
s.opacity = 0
|
||||
|
||||
p = Particle.new(s, 0.0, 0.0, rand * Math::PI * 2.0, kind, 0, 0, 1)
|
||||
reset_particle(p, true)
|
||||
@particles << p
|
||||
end
|
||||
|
||||
# Два очень слабых слоя тумана над водой. Они двигаются в противофазе,
|
||||
# поэтому фон выглядит живым, но меню остаётся читаемым.
|
||||
def create_ambient_mist
|
||||
@mist_bitmap = radial_bitmap(128, Color.new(92, 205, 220, 255), 2.6)
|
||||
keep_bitmap(@mist_bitmap)
|
||||
@mist_left = new_sprite(@mist_bitmap)
|
||||
@mist_right = new_sprite(@mist_bitmap)
|
||||
[@mist_left, @mist_right].each do |s|
|
||||
center_origin(s)
|
||||
s.blend_type = 1
|
||||
s.opacity = 0
|
||||
end
|
||||
end
|
||||
|
||||
# -------------------------------------------------------------------------
|
||||
# Обновление света воды
|
||||
# -------------------------------------------------------------------------
|
||||
def update_pool_glow(t)
|
||||
return unless @pool_glow && @pool_core
|
||||
|
||||
x, y = image_point(POOL_X, POOL_Y)
|
||||
pulse = Math.sin(t / 24.0)
|
||||
slow = Math.sin(t / 83.0 + 0.7)
|
||||
flicker = light_flicker(t)
|
||||
menu_boost = @selection_pulse * 20.0
|
||||
|
||||
scale = screen_scale
|
||||
|
||||
@pool_glow.x = x
|
||||
@pool_glow.y = y
|
||||
@pool_glow.zoom_x = scale * (2.95 + pulse * 0.11)
|
||||
@pool_glow.zoom_y = scale * (0.82 + pulse * 0.035)
|
||||
@pool_glow.opacity = (OnlineTitleBackgroundFX.clamp(
|
||||
34 + pulse * 8 + slow * 4 + flicker + menu_boost,
|
||||
16, 78
|
||||
) * intro_factor).to_i
|
||||
|
||||
@pool_core.x = x
|
||||
@pool_core.y = y + 3
|
||||
@pool_core.zoom_x = scale * (2.05 + slow * 0.08)
|
||||
@pool_core.zoom_y = scale * (0.52 + pulse * 0.025)
|
||||
@pool_core.opacity = (OnlineTitleBackgroundFX.clamp(
|
||||
18 + pulse * 6 + menu_boost * 0.35,
|
||||
8, 46
|
||||
) * intro_factor).to_i
|
||||
end
|
||||
|
||||
def light_flicker(t)
|
||||
# Несколько синусов дают менее механическое мерцание без rand каждый кадр.
|
||||
Math.sin(t / 13.0) * 1.7 +
|
||||
Math.sin(t / 31.0 + 1.2) * 2.2 +
|
||||
Math.sin(t / 71.0 + 0.4) * 1.5
|
||||
end
|
||||
|
||||
# -------------------------------------------------------------------------
|
||||
# Рябь воды
|
||||
# -------------------------------------------------------------------------
|
||||
def update_ripples(t)
|
||||
x, y = image_point(POOL_X, POOL_Y + 0.006)
|
||||
scale = screen_scale
|
||||
|
||||
@ripples.each do |s|
|
||||
offset = s.instance_variable_get(:@fx_offset).to_f
|
||||
phase = ((t / 165.0) + offset) % 1.0
|
||||
|
||||
# В начале кольцо маленькое и яркое, затем расширяется и растворяется.
|
||||
expansion = 0.70 + phase * 1.70
|
||||
s.x = x
|
||||
s.y = y
|
||||
s.zoom_x = scale * expansion * 2.00
|
||||
s.zoom_y = scale * expansion * 0.47
|
||||
s.opacity = ((((1.0 - phase) ** 1.8) * 33) * intro_factor).to_i
|
||||
end
|
||||
end
|
||||
|
||||
# -------------------------------------------------------------------------
|
||||
# Красный свет корней
|
||||
# -------------------------------------------------------------------------
|
||||
def update_root_glow(t)
|
||||
return unless @root_left && @root_right
|
||||
|
||||
lx, ly = image_point(ROOT_LEFT_X, ROOT_LEFT_Y)
|
||||
rx, ry = image_point(ROOT_RIGHT_X, ROOT_RIGHT_Y)
|
||||
scale = screen_scale
|
||||
|
||||
pulse_l = Math.sin(t / 72.0 + 0.4)
|
||||
pulse_r = Math.sin(t / 81.0 + 2.0)
|
||||
|
||||
@root_left.x = lx
|
||||
@root_left.y = ly
|
||||
@root_left.zoom_x = scale * (2.5 + pulse_l * 0.10)
|
||||
@root_left.zoom_y = scale * (2.15 + pulse_l * 0.07)
|
||||
@root_left.opacity = ((13 + pulse_l * 5) * intro_factor).to_i
|
||||
|
||||
@root_right.x = rx
|
||||
@root_right.y = ry
|
||||
@root_right.zoom_x = scale * (2.4 + pulse_r * 0.10)
|
||||
@root_right.zoom_y = scale * (2.05 + pulse_r * 0.07)
|
||||
@root_right.opacity = ((12 + pulse_r * 5) * intro_factor).to_i
|
||||
end
|
||||
|
||||
# -------------------------------------------------------------------------
|
||||
# Лучи света из глубины
|
||||
# -------------------------------------------------------------------------
|
||||
def update_light_rays(t)
|
||||
return unless @ray_left && @ray_right
|
||||
|
||||
x, y = image_point(CAVE_LIGHT_X, CAVE_LIGHT_Y)
|
||||
scale = screen_scale
|
||||
sway = Math.sin(t / 150.0)
|
||||
pulse = Math.sin(t / 65.0 + 0.8)
|
||||
|
||||
@ray_left.x = x - 22 * scale + sway * 3
|
||||
@ray_left.y = y - 8 * scale
|
||||
@ray_left.zoom_x = scale * 1.55
|
||||
@ray_left.zoom_y = scale * 1.55
|
||||
@ray_left.angle = -7 + sway * 1.4
|
||||
@ray_left.opacity = ((8 + pulse * 3) * intro_factor).to_i
|
||||
|
||||
@ray_right.x = x + 18 * scale - sway * 2
|
||||
@ray_right.y = y - 6 * scale
|
||||
@ray_right.zoom_x = scale * 1.45
|
||||
@ray_right.zoom_y = scale * 1.50
|
||||
@ray_right.angle = 7 - sway * 1.2
|
||||
@ray_right.opacity = ((7 + pulse * 3) * intro_factor).to_i
|
||||
end
|
||||
|
||||
# -------------------------------------------------------------------------
|
||||
# Частицы
|
||||
# -------------------------------------------------------------------------
|
||||
def update_particles(t)
|
||||
@particles.each do |p|
|
||||
s = p.sprite
|
||||
next unless s
|
||||
|
||||
p.age += 1
|
||||
|
||||
sway = Math.sin(t / 34.0 + p.phase) * (p.kind == :cyan ? 0.055 : 0.080)
|
||||
s.x += p.vx + sway
|
||||
s.y += p.vy
|
||||
|
||||
twinkle = Math.sin(t / 18.0 + p.phase)
|
||||
opacity = p.base_opacity + twinkle * (p.kind == :cyan ? 28 : 22)
|
||||
if p.kind == :red
|
||||
life = OnlineTitleBackgroundFX.clamp(
|
||||
1.0 - p.age.to_f / p.lifetime.to_f, 0.0, 1.0
|
||||
)
|
||||
# Искра сначала мягко появляется, затем всё быстрее растворяется.
|
||||
appear = OnlineTitleBackgroundFX.clamp(p.age.to_f / 22.0, 0.0, 1.0)
|
||||
opacity *= appear * (life ** 1.45)
|
||||
end
|
||||
minimum = (p.kind == :red ? 0 : 5)
|
||||
s.opacity = (OnlineTitleBackgroundFX.clamp(opacity, minimum, 176) * intro_factor).to_i
|
||||
|
||||
if particle_outside?(p) || p.age >= p.lifetime
|
||||
reset_particle(p, false)
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
def particle_outside?(p)
|
||||
s = p.sprite
|
||||
if p.kind == :cyan
|
||||
s.y < Graphics.height * 0.43 ||
|
||||
s.x < Graphics.width * 0.30 ||
|
||||
s.x > Graphics.width * 0.70
|
||||
else
|
||||
s.y < Graphics.height * 0.12 ||
|
||||
s.x < Graphics.width * 0.16 ||
|
||||
s.x > Graphics.width * 0.84
|
||||
end
|
||||
end
|
||||
|
||||
def reset_particle(p, initial)
|
||||
s = p.sprite
|
||||
scale = screen_scale
|
||||
|
||||
if p.kind == :cyan
|
||||
cx, cy = image_point(POOL_X, POOL_Y)
|
||||
# Точка рождения выбирается внутри эллипса самой воды, а не внутри
|
||||
# прежнего прямоугольника, который захватывал красную землю по бокам.
|
||||
# sqrt(rand) даёт равномерное распределение по площади эллипса.
|
||||
angle = rand * Math::PI * 2.0
|
||||
radius = Math.sqrt(rand) * 0.82
|
||||
pool_rx = @background.bitmap.width * @background.zoom_x * 0.066
|
||||
pool_ry = @background.bitmap.height * @background.zoom_y * 0.030
|
||||
s.x = cx + Math.cos(angle) * pool_rx * radius
|
||||
s.y = cy + Math.sin(angle) * pool_ry * radius
|
||||
p.vx = (rand - 0.5) * 0.16
|
||||
p.vy = -(0.085 + rand * 0.140)
|
||||
p.base_opacity = 72 + rand(68)
|
||||
p.lifetime = 420 + rand(260)
|
||||
z = 0.82 + rand * 0.90
|
||||
else
|
||||
# Красные искры рождаются в нижней части кадра по обе стороны лужи,
|
||||
# поднимаются вверх и исчезают по собственному времени жизни.
|
||||
side = rand(2) == 0 ? -1.0 : 1.0
|
||||
cx, cy = image_point(0.5 + side * (0.12 + rand * 0.18), 0.76 + rand * 0.17)
|
||||
s.x = cx
|
||||
s.y = cy
|
||||
p.vx = -side * (0.010 + rand * 0.040) + (rand - 0.5) * 0.070
|
||||
p.vy = -(0.120 + rand * 0.180)
|
||||
p.base_opacity = 68 + rand(76)
|
||||
p.lifetime = 260 + rand(260)
|
||||
z = 0.70 + rand * 1.00
|
||||
end
|
||||
|
||||
s.zoom_x = scale * z
|
||||
s.zoom_y = scale * z
|
||||
p.phase = rand * Math::PI * 2.0
|
||||
p.age = initial ? rand(p.lifetime) : 0
|
||||
s.y += p.vy * p.age if initial && p.kind == :red
|
||||
end
|
||||
|
||||
def update_ambient_mist(t)
|
||||
return unless @mist_left && @mist_right
|
||||
x, y = image_point(POOL_X, POOL_Y - 0.006)
|
||||
scale = screen_scale
|
||||
sway = Math.sin(t / 190.0)
|
||||
pulse = Math.sin(t / 115.0 + 0.7)
|
||||
|
||||
@mist_left.x = x - (78 - sway * 18) * scale
|
||||
@mist_left.y = y - 8 * scale
|
||||
@mist_left.zoom_x = scale * 2.20
|
||||
@mist_left.zoom_y = scale * 0.34
|
||||
@mist_left.opacity = ((5.5 + pulse * 1.8) * intro_factor).to_i
|
||||
|
||||
@mist_right.x = x + (74 - sway * 16) * scale
|
||||
@mist_right.y = y + 2 * scale
|
||||
@mist_right.zoom_x = scale * 2.05
|
||||
@mist_right.zoom_y = scale * 0.30
|
||||
@mist_right.opacity = ((4.5 - pulse * 1.5) * intro_factor).to_i
|
||||
end
|
||||
|
||||
def update_character_layer(t)
|
||||
return unless @character && valid_sprite?(@character)
|
||||
# Персонаж следует за фоном, но движется чуть меньше: получается мягкий
|
||||
# параллакс. Водные эффекты имеют меньший Z и всегда остаются за телом.
|
||||
@character.zoom_x = @background.zoom_x
|
||||
@character.zoom_y = @background.zoom_y
|
||||
center_x = (Graphics.width - @character.bitmap.width * @character.zoom_x) * 0.5
|
||||
center_y = (Graphics.height - @character.bitmap.height * @character.zoom_y) * 0.5
|
||||
drift_x = @background.x - center_x
|
||||
drift_y = @background.y - center_y
|
||||
@character.x = center_x + drift_x * 0.82
|
||||
@character.y = center_y + drift_y * 0.82 + Math.sin(t / 92.0) * 0.45 * screen_scale
|
||||
@character.opacity = (255 * intro_factor).to_i
|
||||
end
|
||||
|
||||
def intro_factor
|
||||
value = OnlineTitleBackgroundFX.clamp(@frame.to_f / INTRO_FRAMES, 0.0, 1.0)
|
||||
value * value * (3.0 - 2.0 * value)
|
||||
end
|
||||
|
||||
# -------------------------------------------------------------------------
|
||||
# Bitmap helpers
|
||||
# -------------------------------------------------------------------------
|
||||
def new_sprite(bitmap)
|
||||
s = Sprite.new(@background.viewport)
|
||||
s.bitmap = bitmap
|
||||
s.z = effect_z
|
||||
s.opacity = 0
|
||||
@sprites << s
|
||||
s
|
||||
end
|
||||
|
||||
def keep_bitmap(bitmap)
|
||||
@bitmaps << bitmap
|
||||
bitmap
|
||||
end
|
||||
|
||||
def center_origin(sprite)
|
||||
return unless sprite && sprite.bitmap
|
||||
sprite.ox = sprite.bitmap.width / 2
|
||||
sprite.oy = sprite.bitmap.height / 2
|
||||
end
|
||||
|
||||
def screen_scale
|
||||
@background.zoom_x.to_f
|
||||
end
|
||||
|
||||
def radial_bitmap(size, color, power)
|
||||
bmp = Bitmap.new(size, size)
|
||||
c = (size - 1) / 2.0
|
||||
r = size / 2.0
|
||||
|
||||
y = 0
|
||||
while y < size
|
||||
x = 0
|
||||
while x < size
|
||||
dx = (x - c) / r
|
||||
dy = (y - c) / r
|
||||
d = Math.sqrt(dx * dx + dy * dy)
|
||||
if d < 1.0
|
||||
strength = (1.0 - d) ** power
|
||||
a = (color.alpha * strength).to_i
|
||||
if a > 0
|
||||
bmp.set_pixel(x, y, Color.new(color.red, color.green, color.blue, a))
|
||||
end
|
||||
end
|
||||
x += 1
|
||||
end
|
||||
y += 1
|
||||
end
|
||||
bmp
|
||||
end
|
||||
|
||||
def ring_bitmap(size, color)
|
||||
bmp = Bitmap.new(size, size)
|
||||
c = (size - 1) / 2.0
|
||||
r = size / 2.0
|
||||
|
||||
y = 0
|
||||
while y < size
|
||||
x = 0
|
||||
while x < size
|
||||
dx = (x - c) / r
|
||||
dy = (y - c) / r
|
||||
d = Math.sqrt(dx * dx + dy * dy)
|
||||
delta = (d - 0.72).abs
|
||||
if delta < 0.045
|
||||
strength = 1.0 - delta / 0.045
|
||||
a = (color.alpha * strength).to_i
|
||||
bmp.set_pixel(x, y, Color.new(color.red, color.green, color.blue, a))
|
||||
end
|
||||
x += 1
|
||||
end
|
||||
y += 1
|
||||
end
|
||||
bmp
|
||||
end
|
||||
|
||||
def soft_dot_bitmap(color)
|
||||
size = 9
|
||||
bmp = Bitmap.new(size, size)
|
||||
center = 4
|
||||
y = 0
|
||||
while y < size
|
||||
x = 0
|
||||
while x < size
|
||||
dx = x - center
|
||||
dy = y - center
|
||||
d = Math.sqrt(dx * dx + dy * dy)
|
||||
if d <= 4.4
|
||||
strength = [1.0 - d / 4.6, 0.0].max
|
||||
# Чёткое яркое ядро и мягкий внешний ореол хорошо читаются как на
|
||||
# 720p, так и на 1080p, но не превращаются в крупные световые шары.
|
||||
power = d <= 1.25 ? 1.0 : strength ** 1.55
|
||||
a = (color.alpha * power).to_i
|
||||
bmp.set_pixel(x, y, Color.new(color.red, color.green, color.blue, a)) if a > 0
|
||||
end
|
||||
x += 1
|
||||
end
|
||||
y += 1
|
||||
end
|
||||
bmp
|
||||
end
|
||||
|
||||
def vertical_ray_bitmap(width, height, color)
|
||||
bmp = Bitmap.new(width, height)
|
||||
y = 0
|
||||
while y < height
|
||||
fy = y.to_f / (height - 1)
|
||||
# Слабый сверху, ярче в середине, затем снова исчезает.
|
||||
vertical = Math.sin(fy * Math::PI) ** 1.25
|
||||
x = 0
|
||||
while x < width
|
||||
fx = (x - (width - 1) / 2.0).abs / (width / 2.0)
|
||||
horizontal = [1.0 - fx, 0.0].max ** 1.7
|
||||
a = (color.alpha * vertical * horizontal * 0.34).to_i
|
||||
bmp.set_pixel(x, y, Color.new(color.red, color.green, color.blue, a)) if a > 0
|
||||
x += 1
|
||||
end
|
||||
y += 1
|
||||
end
|
||||
bmp
|
||||
end
|
||||
|
||||
def debug_log(where, error)
|
||||
@logged_errors ||= {}
|
||||
return if @logged_errors[where]
|
||||
@logged_errors[where] = true
|
||||
begin
|
||||
p "[TITLE-FX ERROR/#{where}] #{error.class}: #{error.message}"
|
||||
rescue
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# Патч именно ТВОЕГО изменённого TitleMenu.
|
||||
# Никакого Scene_MapTitle alias здесь нет.
|
||||
# ---------------------------------------------------------------------------
|
||||
def self.install!
|
||||
return unless defined?(TitleMenu)
|
||||
return if TitleMenu.method_defined?(:online_title_bg_fx_original_initialize)
|
||||
|
||||
TitleMenu.class_eval do
|
||||
alias online_title_bg_fx_original_initialize initialize
|
||||
alias online_title_bg_fx_original_update update
|
||||
alias online_title_bg_fx_original_dispose dispose
|
||||
|
||||
def initialize(*args, &block)
|
||||
online_title_bg_fx_original_initialize(*args, &block)
|
||||
begin
|
||||
@online_title_bg_fx = OnlineTitleBackgroundFX::Controller.new(self)
|
||||
rescue => e
|
||||
p "[OnlineTitleBackgroundFX/init hook] #{e.message}" if $TEST
|
||||
@online_title_bg_fx = nil
|
||||
end
|
||||
end
|
||||
|
||||
def update(*args, &block)
|
||||
online_title_bg_fx_original_update(*args, &block)
|
||||
begin
|
||||
@online_title_bg_fx.update if @online_title_bg_fx
|
||||
rescue => e
|
||||
p "[OnlineTitleBackgroundFX/update hook] #{e.message}" if $TEST
|
||||
end
|
||||
end
|
||||
|
||||
def dispose(*args, &block)
|
||||
begin
|
||||
@online_title_bg_fx.dispose if @online_title_bg_fx
|
||||
rescue => e
|
||||
p "[OnlineTitleBackgroundFX/dispose hook] #{e.message}" if $TEST
|
||||
ensure
|
||||
@online_title_bg_fx = nil
|
||||
end
|
||||
online_title_bg_fx_original_dispose(*args, &block)
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
OnlineTitleBackgroundFX.install!
|
||||
Reference in new issue
Block a user