THE WOLF MAN OF THE UNDERGROUND; Antiguo exito que relanzo; peticion de seguidores mios;

 

GDScript para hacer una alternancia de transparencia a un MeshInstance3D desde el inspector;

 @tool

extends MeshInstance3D

## Marca si el efecto de transparencia en bucle debe ejecutarse.

@export var activo: bool = true

## Velocidad de la transición (a mayor valor, más rápido cambia).

@export_range(0.1, 10.0, 0.1) var velocidad: float = 2.0

## Transparencia MÍNIMA (0.0 es totalmente invisible, 1.0 es completamente opaco).

@export_range(0.0, 1.0, 0.01) var opacidad_minima: float = 0.1

## Transparencia MÁXIMA (0.0 es totalmente invisible, 1.0 es completamente opaco).

@export_range(0.0, 1.0, 0.01) var opacidad_maxima: float = 1.0

var _tiempo_acumulado: float = 0.0

var _material_instanciado: StandardMaterial3D

func _ready() -> void:

_preparar_material()

func _process(delta: float) -> void:

if not activo:

return

# Si no tenemos material configurado, intentamos asignarlo

if not _material_instanciado:

_preparar_material()

if not _material_instanciado:

return

_tiempo_acumulado += delta * velocidad

# Mapeamos el seno (de -1 a 1) al rango normalizado de 0 a 1

var factor_onda: float = (sin(_tiempo_acumulado) + 1.0) / 2.0

# Interpolamos entre la opacidad mínima y máxima

var alpha_actual: float = lerp(opacidad_minima, opacidad_maxima, factor_onda)

# Aplicamos el alfa al color del material

_material_instanciado.albedo_color.a = alpha_actual

func _preparar_material() -> void:

# Obtenemos el material asignado en la primera superficie del Mesh

var mat_base = get_active_material(0)

if mat_base is StandardMaterial3D:

# Duplicamos el material para no afectar a otros objetos que compartan el mismo mesh

_material_instanciado = mat_base.duplicate() as StandardMaterial3D

# IMPORTANTE: Activamos la transparencia en el material si no lo estaba

_material_instanciado.transparency = BaseMaterial3D.TRANSPARENCY_ALPHA

# Asignamos la copia del material de nuevo al nodo

set_surface_override_material(0, _material_instanciado)

--------------------------------------------------------------------------------------------------------------------

--------------------------------------------------------------------------------------------------------------------

Explicacion : con este gds intento hacer como un efecto magico de un espejo, intento jugar con un personaje y un reflejo.....en mi nuevo juego a publicar de aqui unas semas.aqui debajo pequeño video de lo trabajado....

Videojuego censurado; mas GDScrpts para efectos de apagado encendido;

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

---------------------------------------------------------------------------------------------------------------------------

-----------------------------------------------------------------------------------------------------------------------------

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-

Magnifico GDScript para titulo de juego en Godot 4.7;MeshInstance2D;

 extends MeshInstance2D

@export_group("Control de Rotación")

@export var velocidad_rotacion: float = 1.5 ## Velocidad de giro (en radianes por segundo).

@export var rotar_continuamente: bool = true ## Si está activo, gira sin parar.

@export_group("Temporizador de Giro (Opcional)")

@export var usar_tiempo_limite: bool = false ## Activa para que deje de girar tras X segundos.

@export var tiempo_duracion_giro: float = 5.0 ## Tiempo en segundos antes de detener el giro.

@export_group("Auto-Borrado / Desaparición")

@export var auto_borrar: bool = false ## Si se activa, el nodo se eliminará solo.

@export var tiempo_para_borrar: float = 8.0 ## Tiempo en segundos desde el inicio hasta borrarse.

@export var desvanecer_al_borrar: bool = true ## Si es true, se desvanece suavemente al final.

@export var tiempo_desvanecimiento: float = 1.5 ## Duración en segundos del desvanecimiento suave.

var _tiempo_transcurrido_giro: float = 0.0

var _tiempo_transcurrido_total: float = 0.0

var _esta_girando: bool = true

var _iniciando_desvanecimiento: bool = false

func _ready() -> void:

_esta_girando = true

_tiempo_transcurrido_giro = 0.0

_tiempo_transcurrido_total = 0.0

func _process(delta: float) -> void:

_tiempo_transcurrido_total += delta

# Lógica del temporizador de giro

if usar_tiempo_limite and _esta_girando:

_tiempo_transcurrido_giro += delta

if _tiempo_transcurrido_giro >= tiempo_duracion_giro:

_esta_girando = false

# Lógica de rotación

if rotar_continuamente and _esta_girando:

rotation += velocidad_rotacion * delta

# Lógica de auto-borrado

if auto_borrar:

# Si la opción de desvanecer está activa, iniciamos el fade out un poco antes de borrar

if desvanecer_al_borrar and not _iniciando_desvanecimiento:

if _tiempo_transcurrido_total >= (tiempo_para_borrar - tiempo_desvanecimiento):

_iniciando_desvanecimiento = true

_desvanecer_y_borrar()

elif not desvanecer_al_borrar and _tiempo_transcurrido_total >= tiempo_para_borrar:

queue_free()

func _desvanecer_y_borrar() -> void:

var tween = create_tween()

# Crea una transición suave en la opacidad (modulate.a) hasta llegar a 0 (transparente)

tween.tween_property(self, "modulate:a", 0.0, tiempo_desvanecimiento)

# Cuando termina la animación suave, borra el nodo de la escena de forma segura

tween.tween_callback(queue_free)

-------------------------------------------------------------------------------------------------------------------------

--------------------------------------------------------------------------------------------------------------------------

Explicacion: se le pone textura del titulo y o titulo del juego al MeshInstance2D, y el gds se encarga de girarlo el tiempo que quieras, borrarlo cuando tu quieras y que se desvanezca lentamente cuanto tu quieras asta borrarse....todo esto desde el inspector de Godot 4.7 .

Videojuego de humor terror surrealista; And he lost his mind.;

Juega desde la web o descargatelo para windows o para linux.  Recomendado se juega mas fluido.

Paso un GDScript muy curioso es el que hace la musica del juego......

extends Node

@export_group("Ritmo Discoteca")

## Velocidad clásica de Disco (entre 115 y 128 BPM)

@export_range(90.0, 150.0, 1.0) var bpm: float = 122.0

@export_range(0.0, 1.0, 0.05) var volumen_general: float = 0.5

@export_group("Elementos de Batería Disco")

@export_range(0.0, 1.0, 0.05) var bombo_potencia: float = 0.9

@export_range(0.0, 1.0, 0.05) var caja_snare: float = 0.5

@export_range(0.0, 1.0, 0.05) var platos_contratiempo: float = 0.4

@export_range(0.0, 1.0, 0.05) var palmas_disco: float = 0.35

@export_group("Bajo Octavado (Disco Bass)")

@export_range(0.0, 1.0, 0.05) var bajo_volumen: float = 0.5

## Nota base del bajo (82 Hz es un MI grave / E2)

@export_range(50.0, 150.0, 1.0) var bajo_nota_base: float = 82.41

var audio_player: AudioStreamPlayer

var playback: AudioStreamGeneratorPlayback

var sample_rate: float = 44100.0

var time: float = 0.0

func _ready() -> void:

audio_player = AudioStreamPlayer.new()

var generator = AudioStreamGenerator.new()

generator.mix_rate = sample_rate

generator.buffer_length = 0.1

audio_player.stream = generator

add_child(audio_player)

audio_player.play()

playback = audio_player.get_stream_playback()

func _process(_delta: float) -> void:

if playback == null:

return

# Tiempo de una corchea (la base del ritmo disco)

var step_duration: float = 60.0 / bpm / 4.0

var frames_to_fill = playback.get_frames_available()

while frames_to_fill > 0:

# Patrón de 16 pasos (1 compás de 4/4)

var step = int(time / step_duration) % 16

# 1. BOMBO DISCO (Four-on-the-Floor: Pasos 0, 4, 8, 12)

var kick_env = max(0.0, 1.0 - fmod(time, step_duration * 4) / 0.14) if step % 4 == 0 else 0.0

# Golpe grave con caída rápida de frecuencia

var kick = sin(2.0 * PI * (50.0 + kick_env * 140.0) * time) * kick_env * bombo_potencia

# 2. CAJA / SNARE (Tiempos 4 y 12 -> Tiempo 2 y 4 de la música)

var snare_env = max(0.0, 1.0 - fmod(time, step_duration * 4) / 0.15) if (step == 4 or step == 12) else 0.0

var snare_noise = (randf() * 2.0 - 1.0) * 0.7 + sin(2.0 * PI * 200.0 * time) * 0.3

var snare = snare_noise * snare_env * caja_snare

# 3. PLATOS A CONTRATIEMPO (Off-beat Hi-Hat: Pasos 2, 6, 10, 14)

# Este es el sonido crucial de los platos en la discoteca

var hat_env = max(0.0, 1.0 - fmod(time, step_duration * 2) / 0.08) if step % 2 != 0 else 0.0

var hihat = (randf() * 2.0 - 1.0) * hat_env * platos_contratiempo

# 4. PALMAS / CLAP (Acompañan a la caja en los pasos 4 y 12)

var clap_env = max(0.0, 1.0 - fmod(time, step_duration * 4) / 0.07) if (step == 4 or step == 12) else 0.0

var clap = (randf() * 2.0 - 1.0) * clap_env * palmas_disco

# 5. BAJO EN OCTAVAS (El clásico "Tung-Tsing-Tung-Tsing")

# Si el paso es par -> Nota Grave; Si es impar -> Octava Aguda (frecuencia x 2)

var freq_bajo = bajo_nota_base

if step % 2 != 0:

freq_bajo *= 2.0 # Salto de octava

# Cambio de acorde básico cada 4 pasos

if step in [8, 9, 10, 11]: freq_bajo *= 1.33 # Subida a Cuarta

elif step in [12, 13, 14, 15]: freq_bajo *= 1.5 # Subida a Quinta

var bass_env = max(0.0, 1.0 - fmod(time, step_duration) / 0.1)

# Onda corta y marcada para bajo funky

var bass_wave = 1.0 if sin(2.0 * PI * freq_bajo * time) > 0 else -1.0

var bass = bass_wave * bass_env * bajo_volumen

# MEZCLA FINAL RÍTMICA

var mezcla = (kick + snare + hihat + clap + bass) * volumen_general

playback.push_frame(Vector2(mezcla, mezcla))

time += 1.0 / sample_rate

frames_to_fill -= 1

---------------------------------------------------------------------------------------------------------------------------

----------------------------------------------------------------------------------------------------------------------------

----------------------------------------------------------------------------------------------------------------------------

Explicacion : le pedi a una IA generase ella unos segundos de musica disco....pero se empeño en hacerlo por programacion , asi que le pedi que desde el inspector se pudiesen calibrar algunos parametros, y te lo hace puedes subir vajar volumen y cambiar velocidades y aspectos musicales como tonos graves y agudos creo......bueno es solo un comienzo....me resulta muy interesante que con Godot tambien se pueda programar musica, buena mas asumar en este fenomenal motor de juegos¡¡¡¡¡

----------------------------------------------------------------------------------------------------------------------------

Este videojuego pertenece a una coleccion de juegos muy cortos pero completos que intento sacar 1 cada 1 o 2 semanas y lo estoy consiguiendo, la tematica es , horror gore surrealismo humor grepy y cosas chocantes y de miedo o sorpresibas......paso enlaces de los que llevo ya echos sumando este.

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

¡¡¡¡¡¡¡¡Aprovechar ahora descargarlos....pronto pueden estar en venta.......!!!!!!!!

The Dead Woman and the Coffin.videojuego de horror;

 

Desde Itch.io;