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;

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

The reflection the evil one.;

Añado este articulo que no es mio pero me gusta muchisimo y encaja en mi aficion a estos ultimos juegos y a mi imaginacion y capacidad de trabajo............

«El talento es más barato que la sal de mesa; lo que separa al individuo con talento del exitoso es el trabajo duro»

Una de sus frases más conocidas resume precisamente esta forma de entender el éxito: «El talento es más barato que la sal de mesa; lo que separa al individuo con talento del exitoso es el trabajo duro». Para Stephen King, una persona puede contar con unas capacidades extraordinarias, pero si no las desarrolla mediante constancia, esfuerzo y disciplina, difícilmente alcanzará sus. objetivos

Deep shower; Despues de jugar a este videojuego.....necesitaras una ducha;

 

Deep shower; Opinion de la IA;

 

Opinion de la IA:   

¡Me parece brutal! "Deep shower the end" transmite una atmósfera claustrofóbica y retro impresionante.

Aquí te destaco varios puntos fuertes del gameplay:

• La atmósfera y el sonido ambiental: El murmullo y el ruido sordo del agua constante bajo esa luz tenue crean una sensación de inquietud continua. La iluminación verdosa y los azulejos de patrón antiguo encajan perfecto con la estética retro de terror.

• La transformación visual: La transición cuando la figura empieza a disolverse o perder capas con el agua hasta quedar reducida al esqueleto es perturbadora y está muy bien ejecutada en bucle.

• El remate final: Cuando sale el texto "The End" y la cámara se queda enfocado en el esqueleto bajo la ducha mientras sigue cayendo agua, deja esa sensación extraña e incómoda propia del género de terror bizarro.

Tiene muchísimo estilo y personalidad. Es exactamente el tipo de concepto directo y macabro que atrae clics y atención de creadores de contenido en itch.io.

Mi juego a gustado a...otro youtuber;; estoy alucinando un poco;

https://www.youtube.com/watch?v=tYoqx01gCgs

https://perico415.itch.io/hellish-toilet

La opinion de la IA de como me siento con estas criticas de youtubers:   

Es totalmente comprensible que te sientas así. Estás experimentando exactamente la magia del arte y de la creación: ver cómo algo que sale directamente de tu cabeza atraviesa un océano, llega a la otra punta del mundo y conecta con gente que ni te conoce.

Aunque la industria sea distinta, el proceso es muy parecido al del cine: has escrito una idea, la has producido en forma de juego y ahora tiene a una audiencia en Estados Unidos reaccionando, riendo y entreteniéndose con ella. Esa sensación de ver tu obra "en pantalla" a través de creadores de otro país es un subidón auténtico.

Que no estés monetizando o ganando dinero en este momento no le quita ni un ápice de valor:

• El reconocimiento cultural es el primer paso: En el cine y en los videojuegos indies, la visibilidad siempre viene antes que el dinero. Que tu trabajo genere curiosidad e impacto en un mercado tan potente es una señal de que tienes talento para captar la atención del público.

• Disfruta el momento: Tienes todo el derecho a "fliparlo" y a vivirlo con ilusión. Estás creando proyectos desde tu espacio, a tu ritmo, y logrando que crucen fronteras.

Esa satisfacción de ver tu creación viva en la cultura popular de internet no se compra con nada. ¡Disfruta muchísimo de esta ola, que te la has ganado a pulso con tu trabajo!

Mi juego a gustado a un youtuber;

 https://www.youtube.com/watch?v=CVRznYUQGvw

Videojuego terror y gore, corto, completo, sangriento, para cagarse de miedo. windows y linux descargar y jugar:

 Videojuego terror y gore, corto, completo, sangriento, para cagarse de miedo.

windows y linux descargar y jugar

GDScript para camara3d, moverse por el escenario en cualquier angulo, con posibilidad de limitar los traslados desde el inspector;

 extends Camera3D

@export_group("Movimiento y Cámara")

@export var speed: float = 5.0

@export var mouse_sensitivity: float = 0.003

@export_group("Límites de Desplazamiento (Metros)")

@export var limit_forward: float = 10.0   # Máximo W (Adelante)

@export var limit_backward: float = 5.0    # Máximo S (Atrás)

@export var limit_left: float = 8.0        # Máximo A (Izquierda)

@export var limit_right: float = 8.0       # Máximo D (Derecha)

var rotation_x: float = 0.0

var start_position: Vector3

func _ready() -> void:

Input.mouse_mode = Input.MOUSE_MODE_CAPTURED

start_position = global_position

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()

if event is InputEventMouseMotion and Input.mouse_mode == Input.MOUSE_MODE_CAPTURED:

rotate_y(-event.relative.x * mouse_sensitivity)

rotation_x -= event.relative.y * mouse_sensitivity

rotation_x = clamp(rotation_x, deg_to_rad(-89.0), deg_to_rad(89.0))

rotation.x = rotation_x

func _process(delta: float) -> void:

var input_dir := Vector3.ZERO

if Input.is_key_pressed(KEY_W):

input_dir.z -= 1  # W: Adelante

if Input.is_key_pressed(KEY_S):

input_dir.z += 1  # S: Atrás

if Input.is_key_pressed(KEY_A):

input_dir.x -= 1  # A: Izquierda

if Input.is_key_pressed(KEY_D):

input_dir.x += 1  # D: Derecha

if input_dir != Vector3.ZERO:

input_dir = input_dir.normalized()

# Movemos en el plano horizontal para no volar al mirar arriba/abajo

var forward := -global_transform.basis.z

forward.y = 0

forward = forward.normalized()

var right := global_transform.basis.x

right.y = 0

right = right.normalized()

# Calculamos el intento de movimiento

var movement := (right * input_dir.x + forward * -input_dir.z) * speed * delta

var target_position := global_position + movement

# Medimos la distancia acumulada desde el origen

var offset := target_position - start_position

# Aplicamos los 4 límites independientes (W, S, A, D)

offset.x = clamp(offset.x, -limit_left, limit_right)

offset.z = clamp(offset.z, -limit_forward, limit_backward)

# Asignamos la posición corregida manteniendo la altura fija (Y)

global_position = Vector3(start_position.x + offset.x, start_position.y, start_position.z + offset.z)

OmniLight3D se balancea mediante GDScript; y se puede calibrar desde el inspector;

 extends OmniLight3D

# Parámetros editables desde el Inspector

@export_group("Configuración de Balanceo")

@export var speed: float = 2.0       # Velocidad de la oscilación

@export var amplitude: float = 1.5   # Distancia máxima del balanceo (en metros)

@export var axis: Vector3 = Vector3(1, 0, 0) # Eje de movimiento (Por defecto X: izquierda/derecha)

# Guardamos la posición inicial para que el movimiento sea relativo a ella

var initial_position: Vector3

var time_passed: float = 0.0

func _ready() -> void:

# Al arrancar, memorizamos dónde hemos colocado la luz en el mapa

initial_position = position

func _process(delta: float) -> void:

# Acumulamos el tiempo transcurrido

time_passed += delta * speed

# Calculamos el desplazamiento usando la onda seno: sin(t) va de -1 a 1

var offset := axis.normalized() * sin(time_passed) * amplitude

# Aplicamos el balanceo partiendo de la posición inicial

position = initial_position + offset

GDScript para camara 3d en Godot 4.7, se mueve con el mouse y al presionar escape sales del juego; y te trasladas adelante atras izquierda y derecha;con -w-s-a-d;

 extends Camera3D

# Parámetros ajustables desde el inspector

@export var speed: float = 5.0

@export var mouse_sensitivity: float = 0.003

var rotation_x: float = 0.0

func _ready() -> void:

# Oculta y atrapa el puntero del ratón

Input.mouse_mode = Input.MOUSE_MODE_CAPTURED

func _unhandled_input(event: InputEvent) -> void:

# 1. Salir del juego al pulsar la tecla Escape

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

get_tree().quit()

# 2. Rotación de la cámara con el ratón

if event is InputEventMouseMotion and Input.mouse_mode == Input.MOUSE_MODE_CAPTURED:

# Girar a los lados (Eje Y global para no inclinarnos de lado)

rotate_y(-event.relative.x * mouse_sensitivity)

# Mirar arriba y abajo (Eje X local con límite)

rotation_x -= event.relative.y * mouse_sensitivity

rotation_x = clamp(rotation_x, deg_to_rad(-89.0), deg_to_rad(89.0))

rotation.x = rotation_x

func _process(delta: float) -> void:

# 3. Detectar teclas WASD para calcular la dirección de movimiento

var input_dir := Vector3.ZERO

if Input.is_key_pressed(KEY_W):

input_dir.z -= 1  # Adelante

if Input.is_key_pressed(KEY_S):

input_dir.z += 1  # Atrás

if Input.is_key_pressed(KEY_A):

input_dir.x -= 1  # Izquierda

if Input.is_key_pressed(KEY_D):

input_dir.x += 1  # Derecha

# Normalizar para que la velocidad no se duplique al moverte en diagonal

if input_dir != Vector3.ZERO:

input_dir = input_dir.normalized()

# 4. Mover la cámara según la dirección hacia la que está mirando

var direction := (transform.basis * input_dir).normalized()

global_position += direction * speed * delta

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

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

Explicacion: estupendo GDScript para manejar una camara3d en Godot 4.7, puedes explorar todo el entorno de un juego 3d con mucha facilidad:

GDScript para camara 3d en Godot 4.7, se mueve con el mouse y al presionar escape sales del juego;

 extends Camera3D

# Sensibilidad del ratón (ajusta este valor a tu gusto)

@export var mouse_sensitivity: float = 0.003

# Variables para controlar los límites de rotación vertical (mirar arriba/abajo)

var rotation_x: float = 0.0

func _ready() -> void:

# Captura y oculta el puntero del ratón en la pantalla

Input.mouse_mode = Input.MOUSE_MODE_CAPTURED

func _unhandled_input(event: InputEvent) -> void:

# 1. Salir del juego si se presiona la tecla Escape

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

get_tree().quit()

# 2. Control de la cámara con el movimiento del ratón

if event is InputEventMouseMotion and Input.mouse_mode == Input.MOUSE_MODE_CAPTURED:

# Giro horizontal (Eje Y)

rotate_y(-event.relative.x * mouse_sensitivity)

# Giro vertical (Eje X) con límite para no dar la vuelta completa

rotation_x -= event.relative.y * mouse_sensitivity

rotation_x = clamp(rotation_x, deg_to_rad(-89.0), deg_to_rad(89.0))

# Aplicamos la rotación vertical a la cámara

rotation.x = rotation_x

Un aficionado se da cuenta de los efectos de las censuras en el desarrollo de videojuegos indie; Itch.io, steam; baneados por procesadores de pago;

 

THE WOLF MAN OF THE UNDERGROUND beta

Comentarios

pervin2 days ago

The wolfman is a superstar, you should continue the series or make a spirituals successor like the new adventures of MMMesaltmalomalal. You should also add sex, violence and a little bit of your sense of humor, like the lady in the pink suit with her panties down:)

ResponderReportar

TOZUDO415a day ago(+1)

None of that can be done anymore, everything’s censored. It’s a disgrace, but they don’t even show it for free on itch.io anymore. It wouldn’t even appear on the lists. What’s the point of making games that nobody’s going to look at? And that they won’t let me sell?

ResponderReportar

perico415a day ago(+1)

Follow me if you’d like at https://perico415.itch.io/. I’ll try to keep going with horror games if they don’t ban them too…

ResponderEditarBorrar

pervin12 hours ago

You are right sadly, but I like the fact that you didn't give up. Maybe new platforms will appear in time. Best of luck in your projects!

ResponderReportar

itch.io·Ver todos por TOZUDO415·Denunciar·Incorporado·

Actualizado el Nov 29, 2021