Videojuego censurado;

Adelanto video de mi ultimo videojuego a publicar en unas semanas en itch.io, actualmente en desarrollo, juego con la censura, y la toreo, sera un juego grotesco, y surrealista y humoristico a la vez......pertenecera a mi coleccion de juegos de baño. una serie que esta gustando bastante....

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