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;

The last bath in a bathtub.;

Prueba esta version desde el navegador del juego The reflection the evil one. version corta;

 

Los GDScripts del videojuego The reflection the evil one.;

 extends Node3D

# Variable exportada para cambiar los segundos desde el Inspector (por defecto 3.0 segundos)

@export var tiempo_duracion: float = 10.0

func _ready() -> void:

# 1. Arrancamos la animación al cargar la escena

if $AnimationPlayer:

$AnimationPlayer.play("MakeHuman default skeleton|CONTRAESPEJO")

# 2. Creamos un temporizador que espere los segundos fijados y luego pare la animación

await get_tree().create_timer(tiempo_duracion).timeout

# 3. Pasados los segundos, detenemos la animación

if $AnimationPlayer:

$AnimationPlayer.stop()

extends Area3D

@export var reproductor_audio: AudioStreamPlayer3D

func _ready() -> void:

# Apaga todas las partículas hijas al arrancar

_cambiar_particulas(false)

body_entered.connect(_on_entrada)

body_exited.connect(_on_salida)

area_entered.connect(_on_entrada)

area_exited.connect(_on_salida)

func _on_entrada(_body_or_area) -> void:

# Activar sonido

if reproductor_audio:

if not reproductor_audio.playing:

reproductor_audio.play()

else:

reproductor_audio.stream_paused = false

# Encender todas las partículas hijas

_cambiar_particulas(true)

func _on_salida(_body_or_area) -> void:

# Pausar sonido

if reproductor_audio:

reproductor_audio.stream_paused = true

# Apagar todas las partículas hijas

_cambiar_particulas(false)

# Busca todos los nodos CPUParticles3D hijos y los activa o desactiva

func _cambiar_particulas(estado: bool) -> void:

for hijo in get_children():

if hijo is CPUParticles3D:

hijo.emitting = estado

extends Node3D

## Escena a la que se cambiará tras finalizar el tiempo, clic o toque

@export var siguiente_escena: PackedScene

## Tiempo de espera en segundos antes de cambiar de escena

@export var tiempo_espera: float = 115.0

## Arrastra aquí el nodo TouchScreenButton desde el árbol de escena (opcional)

@export var boton_tactil: TouchScreenButton

var _ya_cambiando: bool = false

func _ready() -> void:

#Input.mouse_mode = Input.MOUSE_MODE_VISIBLE

# Conectamos el botón táctil si se ha asignado en el Inspector

if boton_tactil:

boton_tactil.pressed.connect(_al_pulsar_boton)

# Temporizador por tiempo

var timer := get_tree().create_timer(tiempo_espera)

timer.timeout.connect(_cambiar_escena_directa)

# Detecta clics de ratón o toques en la pantalla completa (móviles/PC)

func _unhandled_input(event: InputEvent) -> void:

if event is InputEventMouseButton and event.pressed and event.button_index == MOUSE_BUTTON_LEFT:

_cambiar_escena_directa()

elif event is InputEventScreenTouch and event.pressed:

_cambiar_escena_directa()

func _al_pulsar_boton() -> void:

_cambiar_escena_directa()

func _cambiar_escena_directa() -> void:

# Evitamos que se intente cambiar más de una vez

if _ya_cambiando:

return

if not siguiente_escena:

push_warning("No se ha asignado ninguna escena en el Inspector.")

return

_ya_cambiando = true

# 1. Guardamos una referencia a la escena actual

var escena_actual := get_tree().current_scene

# 2. Instanciamos la nueva escena

var nueva_instancia := siguiente_escena.instantiate()

# 3. Añadimos la nueva escena al nodo raíz del proyecto

get_tree().root.add_child(nueva_instancia)

# 4. Establecemos la nueva escena como la escena activa

get_tree().current_scene = nueva_instancia

# 5. Eliminamos la escena vieja

if escena_actual:

escena_actual.queue_free()

extends Node3D

# Variable exportada para cambiar los segundos desde el Inspector (por defecto 3.0 segundos)

@export var tiempo_duracion: float = 110.0

func _ready() -> void:

# 1. Arrancamos la animación al cargar la escena

if $AnimationPlayer:

$AnimationPlayer.play("MakeHuman default skeleton|ESPASMADA")

# 2. Creamos un temporizador que espere los segundos fijados y luego pare la animación

await get_tree().create_timer(tiempo_duracion).timeout

# 3. Pasados los segundos, detenemos la animación

if $AnimationPlayer:

$AnimationPlayer.stop()

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

var initial_position: Vector3

var time_passed: float = 0.0

func _ready() -> void:

initial_position = position

func _process(delta: float) -> void:

time_passed += delta

# Calculamos la variación del tamaño (un factor que oscila entre 0.2 y 1.0 para que no pase por cero absoluto)

var current_radius := radius * (0.6 + 0.4 * sin(time_passed * pulse_speed))

# Usamos cos() para el eje X y sin() para el eje Z para formar el movimiento circular

var offset_x := cos(time_passed * speed) * current_radius

var offset_z := sin(time_passed * speed) * current_radius

# Aplicamos el movimiento en los ejes X y Z manteniendo la Y inicial

position = initial_position + Vector3(offset_x, 0.0, offset_z)

extends Node

func _unhandled_input(event: InputEvent) -> void:

if event.is_action_pressed("ui_cancel") or (event is InputEventKey and event.pressed and event.keycode == KEY_ESCAPE):

get_tree().quit()

extends Area3D

# Nodos exportados para arrastrar desde la escena al Inspector

@export var reproductor_audio: AudioStreamPlayer3D

@export var particulas_sangre1: CPUParticles3D

@export var particulas_sangre2: CPUParticles3D

@export var particulas_sangre3: CPUParticles3D 

@export var particulas_sangre4: CPUParticles3D # Puedes añadir particulas_sangre4, etc.

@export var particulas_sangre5: CPUParticles3D

func _ready() -> void:

# Nos aseguramos de apagar todas al arrancar el juego

_apagar_particulas()

body_entered.connect(_on_entrada)

body_exited.connect(_on_salida)

area_entered.connect(_on_entrada)

area_exited.connect(_on_salida)

func _on_entrada(_body_or_area) -> void:

# 1. SONIDO EN ON

if reproductor_audio:

if not reproductor_audio.playing:

reproductor_audio.play()

else:

reproductor_audio.stream_paused = false

# 2. PARTÍCULAS EN ON (Entra en la zona)

_encender_particulas()

func _on_salida(_body_or_area) -> void:

# 1. SONIDO EN OFF

if reproductor_audio:

reproductor_audio.stream_paused = true

# 2. PARTÍCULAS EN OFF (Sale de la zona)

_apagar_particulas()

# --- BLOQUE DE ENCENDIDO ---

func _encender_particulas() -> void:

if particulas_sangre1:

particulas_sangre1.emitting = true

if particulas_sangre2:

particulas_sangre2.emitting = true

if particulas_sangre3:

particulas_sangre3.emitting = true

if particulas_sangre4:

particulas_sangre4.emitting = true

if particulas_sangre5:

particulas_sangre5.emitting = true

# --- BLOQUE DE APAGADO ---

func _apagar_particulas() -> void:

if particulas_sangre1:

particulas_sangre1.emitting = false

if particulas_sangre2:

particulas_sangre2.emitting = false

if particulas_sangre3:

particulas_sangre3.emitting = false

if particulas_sangre4:

particulas_sangre4.emitting = false

if particulas_sangre5:

particulas_sangre5.emitting = false