Files
LonaRPG-Online-Games/ModScripts/129_AnimatedTitleBackground.rb
T
2026-10-29 21:59:06 +04:00

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!