868 lines
29 KiB
Ruby
868 lines
29 KiB
Ruby
# 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!
|