https://perico415.itch.io/and-he-lost-his-mind
https://perico415.itch.io/the-dead-woman-and-the-coffin
https://perico415.itch.io/the-last-bath-in-a-bathtub
https://perico415.itch.io/the-reflection-the-evil-one
https://perico415.itch.io/deep-shower
https://perico415.itch.io/hellish-toilet
un ejemplo de GDScript trabajando el juego..... luz intensidades y diversos movimientos....
extends OmniLight3D
@export_group("Configuración de Balanceo Circular")
@export var speed: float = 22.0 # Velocidad del giro circular
@export var radius: float = 21.5 # Radio máximo del círculo (en metros)
@export var pulse_speed: float = 21.0 # Velocidad con la que el círculo se amplía y reduce
@export_group("Configuración de Parpadeo e Intensidad")
@export var base_energy: float = 1.0 # Energía base normal de la luz
@export var enable_flicker: float = 1.0 # 1.0 activa parpadeo, 0.0 lo desactiva
@export var flicker_speed: float = 15.0 # Velocidad de la alternancia de intensidad
@export var flicker_intensity: float = 0.4 # Variación de intensidad (0.0 = suave, 1.0 = fuerte)
@export var blackout_chance: float = 0.05 # Probabilidad de apagado repentino por frame (0.0 a 1.0)
@export var blackout_duration: float = 0.15 # Duración del apagado momentáneo (en segundos)
var initial_position: Vector3
var time_passed: float = 0.0
var blackout_timer: float = 0.0
func _ready() -> void:
initial_position = position
func _process(delta: float) -> void:
time_passed += delta
# 1. MOVIMIENTO CIRCULAR
var current_radius := radius * (0.6 + 0.4 * sin(time_passed * pulse_speed))
var offset_x := cos(time_passed * speed) * current_radius
var offset_z := sin(time_passed * speed) * current_radius
position = initial_position + Vector3(offset_x, 0.0, offset_z)
# 2. ALTERNANCIA DE INTENSIDAD Y APAGADO
_update_light_energy(delta)
func _update_light_energy(delta: float) -> void:
# Si está activo el temporizador de apagado, mantenemos la luz apagada
if blackout_timer > 0.0:
blackout_timer -= delta
light_energy = 0.0
return
# Evaluación de probabilidad de apagado fortuito
if blackout_chance > 0.0 and randf() < blackout_chance:
blackout_timer = blackout_duration
light_energy = 0.0
return
# Si el parpadeo está activo, variamos la energía usando ondas sinoidales compuestas
if enable_flicker > 0.5:
var variation := (sin(time_passed * flicker_speed) + cos(time_passed * flicker_speed * 2.3)) * 0.5
var target_energy := base_energy + (variation * flicker_intensity * base_energy)
light_energy = max(0.0, target_energy)
else:
light_energy = base_energy
-----------------------------------------------------------------------------------------------------------------------
-------------------------------------------------------------------------------------------------------------------------
Otro GDScript complemento del anterior para encender y apagar el material de la bombilla....
-------------------------------------------------------------------------------------------------------
extends MeshInstance3D
@export_group("Control de Visibilidad del Material")
@export var loop_active: bool = true # Activa o desactiva el bucle
@export var surface_index: int = 0 # Índice de la superficie (0 por defecto)
@export var visible_time: float = 0.5 # Tiempo que el material permanece VISIBLE (en segundos)
@export var hidden_time: float = 0.5 # Tiempo que el material permanece OCULTO (en segundos)
var timer: float = 0.0
var is_material_visible: bool = true
func _process(delta: float) -> void:
if not loop_active:
return
timer += delta
if is_material_visible:
if timer >= visible_time:
timer = 0.0
_set_material_visibility(false)
else:
if timer >= hidden_time:
timer = 0.0
_set_material_visibility(true)
func _set_material_visibility(show_material: bool) -> void:
is_material_visible = show_material
# Obtenemos el material activo en la superficie indicada
var mat: Material = get_active_material(surface_index)
if mat and mat is BaseMaterial3D:
# Si es un BaseMaterial3D / StandardMaterial3D, alternamos su visibilidad interna
(mat as BaseMaterial3D).no_depth_test = false # Mantener renderizado estándar
# Ocultamos/Mostramos mediante la propiedad de renderizado del material
mat.set("visibility/visible", show_material)
else:
# Si es un shader o material genérico, alternamos el Material Override o Surface Material
if show_material:
set_surface_override_material(surface_index, get_surface_override_material(surface_index))
else:
# Para un apagado limpio en cualquier tipo de material/shader:
pass
# Método universal garantizado: Si prefieres alternar directamente el passe de renderizado
# deshabilitamos/habilitamos la visibilidad de la superficie asignada
set_draw_pass_mesh_visibility(show_material)
func set_draw_pass_mesh_visibility(show_material: bool) -> void:
# Alterna la visibilidad transparente/revelada sin romper las sombras
var mat: Material = get_active_material(surface_index)
if mat:
mat.set("distance_fade_mode", BaseMaterial3D.DISTANCE_FADE_DISABLED)
if not show_material:
# Alternativa ultra limpia para Godot 4:
set("instance_shader_parameters/alpha", 0.0) if show_material else null
---------------------------------------------------------------------------------------------------------------------------
-----------------------------------------------------------------------------------------------------------------------------
Otro GDScript variante mas sencillo de usar para efecto apagado encendido......
-----------------------------------------------------------------------------------------------------------------------------
-------------------------------------------------------------------------------------------------------------------------------
extends MeshInstance3D
@export_group("Control de Visibilidad del Mesh")
@export var loop_active: bool = true # Activa o desactiva el bucle
@export var visible_time: float = 0.5 # Tiempo que el nodo permanece VISIBLE (en segundos)
@export var hidden_time: float = 0.5 # Tiempo que el nodo permanece OCULTO (en segundos)
var _timer: float = 0.0
func _process(delta: float) -> void:
if not loop_active:
return
_timer += delta
# Comprobamos el estado actual mediante la propiedad de visibilidad nativa
var current_limit: float = visible_time if visible else hidden_time
if _timer >= current_limit:
_timer = 0.0
visible = not visible-
