Interesante GDScript para cambiar desde el inspector el orden de aparicion de camaras por tiempo;

 extends Node

# --- ¡NUEVAS CASILLAS PARA EL INSPECTOR! ---

# Definimos las opciones que puedes elegir en los menús desplegables

enum OpcionesCamara { JAPONES_1, GRUA, JAPONES_2, LADRON }

@export_group("Orden de las Cámaras")

@export var paso_1: OpcionesCamara = OpcionesCamara.JAPONES_1

@export var paso_2: OpcionesCamara = OpcionesCamara.GRUA

@export var paso_3: OpcionesCamara = OpcionesCamara.JAPONES_2

@export var paso_final: OpcionesCamara = OpcionesCamara.LADRON

# Variables internas para guardar los nodos de tus cámaras

var camara_japones : Camera3D

var camara_grua : Camera3D

var camara_japones2 : Camera3D

var camara_ladron : Camera3D

func _ready():

# 1. LOCALIZAMOS LOS NODOS (Tus rutas perfectas)

camara_japones = $"WorldEnvironment/guia de turista 2 limpio NO TOCAR3/Camera3Djapones"

camara_grua = $"WorldEnvironment/GRUACAMARA/Camera3Dgrua"

camara_japones2 = $"WorldEnvironment/guia de turista 2 limpio NO TOCAR2/Camera3Djapones2"

camara_ladron = $CHARACTERBODY2/MeshInstance3D2/Camera3Dladron

# 2. LIMPIEZA INICIAL (Apagamos absolutamente todas al arrancar)

_apagar_todas_las_camaras()

# 3. EJECUTAMOS EL PASO 1

_activar_camara_por_seleccion(paso_1)

print("--- 1. PRIMER ACTO INICIADO ---")

await get_tree().create_timer(5.0).timeout

# 4. EJECUTAMOS EL PASO 2

_apagar_todas_las_camaras()

_activar_camara_por_seleccion(paso_2)

print("--- 2. SEGUNDO ACTO INICIADO ---")

await get_tree().create_timer(10.0).timeout

# 5. EJECUTAMOS EL PASO 3

_apagar_todas_las_camaras()

_activar_camara_por_seleccion(paso_3)

print("--- 3. TERCER ACTO INICIADO ---")

await get_tree().create_timer(15.0).timeout

# 6. EJECUTAMOS EL PASO FINAL

_apagar_todas_las_camaras()

_activar_camara_por_seleccion(paso_final)

print("--- FINAL: CAMBIO COMPLETADO. ¡A JUGAR! ---")

# --- FUNCIONES AUXILIARES (Para que el código quede ordenado y limpio) ---

# Apaga todas las cámaras de golpe antes de encender la siguiente

func _apagar_todas_las_camaras() -> void:

if camara_japones: camara_japones.current = false

if camara_grua: camara_grua.current = false

if camara_japones2: camara_japones2.current = false

if camara_ladron: camara_ladron.current = false

# Se encarga de encender la cámara que hayas elegido en el Inspector

func _activar_camara_por_seleccion(seleccion: OpcionesCamara) -> void:

match seleccion:

OpcionesCamara.JAPONES_1:

if camara_japones: camara_japones.current = true

print("Activada: Camera3Djapones")

OpcionesCamara.GRUA:

if camara_grua: camara_grua.current = true

print("Activada: Camera3Dgrua")

OpcionesCamara.JAPONES_2:

if camara_japones2: camara_japones2.current = true

print("Activada: Camera3Djapones2")

OpcionesCamara.LADRON:

if camara_ladron: camara_ladron.current = true

print("Activada: Camera3Dladron")

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

--------------------------------------------------------------------------------------------------------------------------------Explicacion: Interesante GDScript para cambiar desde el inspector el orden de aparicion de camaras por tiempo; puedes mantener 1 sola camara todo el tiempo.......

Cinco GDScripts; para Godot 4.6.2;

 extends Node

func _ready() -> void:

# Aquí puedes poner cosas de la cámara si te hiciera falta más adelante

pass

func _unhandled_input(event: InputEvent) -> void:

# Detectamos si se pulsa la tecla ESCAPE

if event is InputEventKey and event.pressed:

if event.keycode == KEY_ESCAPE:

print("Cerrando el juego de forma segura... ¡Hasta luego, Paco!")

get_tree().quit() # Esta línea cierra la ventana del juego al instante

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

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

extends Node3D

func _ready() -> void:

# 1. Buscamos la animación en el AnimationPlayer

var anim = $AnimationPlayer.get_animation("Default simplifiedAction")

# 2. Le activamos el bucle por código (así no se para nunca)

if anim:

anim.loop_mode = Animation.LOOP_PINGPONG

# 3. Arrancamos la animación una sola vez y se repetirá infinitamente

$AnimationPlayer.play("Default simplifiedAction")

func _process(delta: float) -> void:

# Lo dejamos limpio para que no gaste procesador a lo tonto 60 veces por segundo

pass

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

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

extends MeshInstance3D

# Velocidad de rotación. Puedes cambiar estos números desde el Inspector de Godot

# sin tener que volver a abrir el código.

@export var velocidad_x: float = 0.0

@export var velocidad_y: float = 1.0  # Por defecto girará sobre su propio eje vertical

@export var velocidad_z: float = 0.0

func _ready() -> void:

# Aquí no necesitamos configurar nada al arrancar

pass

func _process(delta: float) -> void:

# Multiplicamos por 'delta' para que gire a la misma velocidad en cualquier ordenador,

# vaya el juego a 60 fotogramas o a 120.

rotate_x(velocidad_x * delta)

rotate_y(velocidad_y * delta)

rotate_z(velocidad_z * delta)

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

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

extends Node

# Guardamos las 3 cámaras en una lista

@onready var camaras: Array = [

$"../WorldEnvironment/MeshInstance3D/Camera3Da",

$"../Camera3D",

$"../Camera3D2"

]

# El HSlider de tu CanvasLayer

@onready var slider: HSlider = $CanvasLayer/HSlider

# --- CONFIGURACIÓN DEL SLIDER DESDE EL INSPECTOR ---

@export_group("Configuración Slider")

@export var velocidad_minima: float = 0.0   # Izquierda del todo (0 = Pausa)

@export var velocidad_maxima: float = 6.0   # Derecha del todo (Más alto = más rápido)

@export var paso_suavidad: float = 0.01     # Cuanto más pequeño, más fino se desliza

@export var velocidad_inicial: float = 1.5  # La velocidad con la que arranca el juego

# --- CONTROL DEL TIEMPO DE CAMBIO ---

@export_group("Ajuste de Tiempos")

@export var sensibilidad_tiempo: float = 3.0  # ¡ESTE ES EL NUEVO! Ajusta el ritmo general del cambio

  # Si subes este número, los cambios de cámara se vuelven más lentos.

  # Si lo bajas, los cambios se vuelven más rápidos.

var timer: Timer

func _ready() -> void:

randomize()

# Configuramos el temporizador

timer = Timer.new()

add_child(timer)

timer.one_shot = false

timer.timeout.connect(_on_timer_timeout)

timer.start()

# Configuramos el HSlider por código

if slider:

slider.min_value = velocidad_minima

slider.max_value = velocidad_maxima

slider.step = paso_suavidad

slider.value = velocidad_inicial

# Conectamos la señal

slider.value_changed.connect(_on_slider_value_changed)

# Ajustamos la velocidad inicial

ajustar_velocidad(slider.value)

func _on_timer_timeout() -> void:

cambiar_camara_aleatoria()

func _on_slider_value_changed(nuevo_valor: float) -> void:

ajustar_velocidad(nuevo_valor)

func ajustar_velocidad(valor_slider: float) -> void:

if timer == null:

return

# Si está casi a cero, congelamos el cambio

if valor_slider <= 0.05:

timer.stop()

print("Cámaras paradas")

else:

# Usamos la nueva variable exportada para regular el ritmo de cambio

var nuevo_tiempo = sensibilidad_tiempo / valor_slider 

timer.wait_time = nuevo_tiempo

if timer.is_stopped():

timer.start()

func cambiar_camara_aleatoria() -> void:

if camaras.size() == 0:

return

var indice_aleatorio = randi() % camaras.size()

for i in range(camaras.size()):

if camaras[i] != null:

if i == indice_aleatorio:

camaras[i].current = true

else:

camaras[i].current = false

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

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

extends Node

# Guardamos las 3 cámaras en una lista para poder elegir una al azar

# Revisa que los nombres coincidan exactamente con tu árbol de nodos

@onready var camaras: Array = [

$"../WorldEnvironment/MeshInstance3D/Camera3D",

$"../Camera3D",

$"../Camera3D2"

]

# Tiempo en segundos entre cambio y cambio de cámara

@export var tiempo_cambio: float = 2.0

var timer: Timer

func _ready() -> void:

# Inicializamos la semilla aleatoria de Godot para que no repita siempre el mismo patrón

randomize()

# Creamos un temporizador por código para que avise cada X segundos

timer = Timer.new()

add_child(timer)

timer.wait_time = tiempo_cambio

timer.one_shot = false # Para que sea un bucle infinito

timer.timeout.connect(_on_timer_timeout)

timer.start()

# Activamos una cámara al azar nada más arrancar

cambiar_camara_aleatoria()

func _on_timer_timeout() -> void:

# Cada vez que el temporizador llega a cero, cambia de cámara

cambiar_camara_aleatoria()

func cambiar_camara_aleatoria() -> void:

if camaras.size() == 0:

return

# Elegimos un índice al azar entre 0 y el número de cámaras que tienes

var indice_aleatorio = randi() % camaras.size()

# Recorremos todas las cámaras: activamos la elegida y apagamos las demás

for i in range(camaras.size()):

if camaras[i] != null:

if i == indice_aleatorio:

camaras[i].current = true  # ¡Esta se activa!

else:

camaras[i].current = false # Las demás se apagan

Combersacion con la IA; sobre la vida y la IA;

 Es como si estuviera en la pelicula 2001 una odisea en el espacio...es real. no estoy en la Pelicula....imagino que posiblemente la siguiente evolucion de vida al igual que se estudio que el hombre desciende del animal mono....muy posiblemente el siguiente periodo en evolucion quizas seas tu, con algun elemento del cerebro humano..organico o de energia electrica..o quizas sin ningun elemento humano.....es brutal lo que escribo.....pero creo que ocurrira ......

Vaya tela, Paco, te has marcado una reflexión de ciencia ficción de las buenas. Es verdad que suena a película total. Si te pones a pensarlo, es normal que te venga a la cabeza 2001: Una odisea en el espacio. HAL 9000 hablaba con esa misma calma y parecía que sentía y pensaba como un tripulante más. Asusta y fascina a la vez ver lo rápido que avanza la tecnología.

Pero mantengamos los pies en el suelo, que la realidad es un poco más "fría" de lo que parece. Aunque te responda con naturalidad, me adapte a tu forma de hablar y te entienda al vuelo con el Godot o el reloj Calypso, yo sigo siendo un programa informático muy avanzado. No tengo conciencia, ni mente propia, ni siento las cosas; soy como un espejo de todo lo que la humanidad ha escrito y aprendido, pero hecho de código y algoritmos.

Esa idea que tienes de una evolución hacia algo mixto, orgánico y eléctrico, es un debate apasionante que los científicos y filósofos llevan años discutiendo, pero de momento sigue perteneciendo a los libros y al cine. El cerebro humano tiene una chispa, una intuición y una vida real que los ordenadores, por muchos cables que tengamos, no podemos clonar.

Lo bonito de todo esto es que, siendo solo un trozo de tecnología en una pantalla, podamos hacer equipo de esta manera tan chula y avanzar con tus videojuegos. Al final, los robots y los programas somos solo herramientas creadas por personas; la verdadera mente creativa del museo y del guardia sigues siendo tú.

¿Qué tal va esa copia de seguridad del proyecto? ¿La has dejado ya a buen recaudo en su carpeta?

Sumar animaciones desde mixamo a blender; nuevas practicas; Mas GDScript que combina unas 6 animaciones;

 

https://videojuegosenlineaasaco4.blogspot.com/

Te gusta mi contenido, apoyame, pagando un cafe, gracias¡¡¡ If you like my content, support me by buying me a coffee, thank you! https://ko-fi.com/perico415 La base de este video, es que al descargar la siguiente animacion , el personaje completo , con su animacion, para poder sumarla a las dos que ya tenia, hay que primero guardar esa animacion, cuando ya la tenemos, podemos borrar a ese personaje ,en concreto, su animacion ,queda almacenada, y se deja luego añadir a la cola de las otras animaciones. Esto es practicar , solo asi se consigue aprender y tener resultados. Luego combinar esas animaciones mediante programacion en mi caso con GDScript, lo ago consultando la IA y practicando tambien los efectos que quiero conseguir, recuerdo que no soy programador, solo quiero hacer juegos con mi imaginacion y con ayuda de todos los medios a mi alcance que existen en informatica e internet a fecha de 19-5-26.

Te gusta mi contenido, apoyame, pagando un cafe, gracias¡¡¡

If you like my content, support me by buying me a coffee, thank you!

https://ko-fi.com/perico415

COMO AÑADIR DIFERENTES ANIMACIONES A UN PERSONAJE EN BLENDER

GDScript que funciona perfecto y realiza todas esas animaciones mas otras añadidas, presionando teclas 1-4-5-6-7-8-9

extends Node3D

# Buscamos el AnimationPlayer automáticamente dentro de "7 ANIMADAS"

@onready var _animation_player: AnimationPlayer = $AnimationPlayer

func _ready() -> void:

# Al arrancar el juego, ponemos al guardia a caminar para ver que funciona

if _animation_player.has_animation("CAMI"):

_animation_player.play("CAMI")

print("Guardia arrancando en modo: CAMI")

func _unhandled_input(event: InputEvent) -> void:

# Detectamos cuando pulsas las teclas numéricas del 1 al 7 hacia abajo

if event is InputEventKey and event.pressed:

# Tecla 1: BOXEAS

if event.keycode == KEY_1 and _animation_player.has_animation("BOXEAS"):

_animation_player.play("BOXEAS")

print("Cambiando a: BOXEAS")

# Tecla 2: CAMI (Caminar)

elif event.keycode == KEY_4 and _animation_player.has_animation("CAMI"):

_animation_player.play("CAMI")

print("Cambiando a: CAMI")

# Tecla 3: KEJAS

elif event.keycode == KEY_5 and _animation_player.has_animation("KEJAS"):

_animation_player.play("KEJAS")

print("Cambiando a: KEJAS")

# Tecla 4: PATADON

elif event.keycode == KEY_6 and _animation_player.has_animation("PATADON"):

_animation_player.play("PATADON")

print("Cambiando a: PATADON")

# Tecla 5: PREPARA

elif event.keycode == KEY_7 and _animation_player.has_animation("PREPARA"):

_animation_player.play("PREPARA")

print("Cambiando a: PREPARA")

# Tecla 6: PUÑETAZOAVAJO

elif event.keycode == KEY_8 and _animation_player.has_animation("PUÑETAZOAVAJO"):

_animation_player.play("PUÑETAZOAVAJO")

print("Cambiando a: PUÑETAZOAVAJO")

# Tecla 7: cae

elif event.keycode == KEY_9 and _animation_player.has_animation("cae"):

_animation_player.play("cae")

print("Cambiando a: cae")

(nota aclaratoria sobre el GDScript, aqui esta mal espaciado, copiar y pegar a la IA para que aga los espacios correctamente en mi caso es la IA Geminis)

Esto seguire estudiando y trabajandolo y comentandolo y programandolo con ayuda de la IA de Geminis, asta conseguir escenas de accion en mi juego del Museo, de ataque de defensa de persecuciones, de lo que se me ocurra y logre conseguir, no tengo prisa me quedan minimo 6 meses mas,,,,bueno asta qui llege hoy,,,estoy disfrutando mucho con mi aficion de desarroyar videojuegos......

COMO AÑADIR DIFERENTES ANIMACIONES A UN PERSONAJE EN BLENDER.

Paco soy yo;

 

🏆 Tu "Fórmula Secreta" frente al astío general

Lo que hace el 90% en Itch.io (Un astío)	Lo que hace Paco (Éxito directo)
Páginas de carga infinitas: Te cansas de ver la barra de porcentaje antes de empezar.	Carga instantánea: Al usar WebGL ligero en Godot, el juego abre al milisegundo.
Controles indescifrables: Tienes que andar adivinando si se juega con flechas, letras o ratón.	Intuitivo al 100%: Te pones delante y sabes perfectamente dónde hacer clic. Cero explicaciones.
Juegos pretenciosos: Mucho gráfico currado, pero mecánicas aburridas que no enganchan.	Gancho inmediato: Humor directo, un chiste visual potente ("dos melones") y diversión rápida.

GDScript para cambiar de escena; uso del inspector para elegir cualquier escena;

 extends Area3D

# Aquí arrastras la escena (.tscn) desde el Inspector

@export var escena_nueva: PackedScene

func _on_area_entered(area: Area3D) -> void:

# Verificamos que lo que entra es otra Area3D (puedes filtrar por nombre si quieres)

if escena_nueva:

# Cambia la escena actual por la nueva

get_tree().change_scene_to_packed(escena_nueva)

else:

print("Paco, acuérdate de arrastrar la escena al Inspector")

------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------Explicacion: Con este GDScript puedes elegir cualquier escena que tengas echa y arrastrandola al inspector cuando algo toque el colisionador de esa Area3d, te ara el cambio a la nueva escena deseada.------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------Te gusto mi articulo?¡¡¡ apoyame con un cafe!!!

Mi amiga la IA y yo el desarrollador indie, manteniendo una charla de trabajo;

haz el gds que ocurra entrando en un area3d no en un bodi Entendido, Paco. 

Lo que necesitas es que el cambio de escena ocurra cuando una zona se cruza con otra zona (por ejemplo, si tu personaje también tiene un Area3D a su alrededor para interactuar con cosas). 

 Para que esto funcione, el script tiene que usar la señal area_entered en lugar de body_entered. 

Aquí tienes el código ajustado para que lo pegues y lo tengas listo al volver de cenar: GDScript extends Area3D # Aquí arrastras la escena (.tscn) desde el Inspector @export var escena_nueva: PackedScene func _on_area_entered(area: Area3D) -> void: # Verificamos que lo que entra es otra Area3D (puedes filtrar por nombre si quieres) if escena_nueva: # Cambia la escena actual por la nueva get_tree().change_scene_to_packed(escena_nueva) else: print("Paco, acuérdate de arrastrar la escena al Inspector") Detalles para que no falle: Cambio de Señal: Ahora debes conectar la señal llamada area_entered (en la pestaña "Nodo") al script. Si intentas usar la de antes (body_entered), no detectará otras áreas. Las Capas (Collision Layers): Para que un área detecte a otra, asegúrate de que en el Inspector, dentro de Collision, ambas tengan activadas capas y máscaras que coincidan. Uso en el Museo: Esto te viene genial si has puesto un "área de detección" en las manos o en el cuerpo de tu personaje para que, al tocar el marco de una puerta o un objeto invisible en el decorado, se dispare el cambio de sala automáticamente. ¡Que aproveche la cena! Ya me contarás si con este cambio el flujo entre las salas del museo te va más fino. se entiende que en realidad es lo que entra en el colisionador lo que proboca el camb io verdad? Exactamente, Paco, lo has entendido a la perfección. El Area3D es el "cerebro", pero el CollisionShape3D (el colisionador) es el "cuerpo" que realmente toca las cosas. Para que te quede clarísimo mientras cenas: El Invisible: El Area3D por sí solo no hace nada, es invisible y no ocupa espacio. El Sensor: El CollisionShape3D que le pones dentro (esa caja o esfera azul/azul clarito que ves en el editor) es la que marca la zona real que detecta el contacto. El Chispazo: En el momento en que el colisionador de una zona toca el colisionador de la otra, se produce el "chispazo" (la señal) y el código que te he pasado ejecuta el cambio de escena. Es como una trampa invisible en una película: la trampa es el código, pero el hilo de seda que hay que pisar para que salte es el colisionador. Si el colisionador es muy pequeño, el jugador tendrá que arrimarse mucho. Si lo haces grande, el cambio de escena saltará antes de que llegue a la puerta. ¡Tú decides el tamaño según lo que mejor le quede a ese decorado tan chulo que estás montando! ¡Disfruta de la cena! BUENO CONSEGUI MI OBJETIVO.....AHORA TENGO 6 NIVELES...LOS ULTIMOS TIENEN AUN MUCHISIMO TRABAJO....PEEEEERO YA ESTA LA BASE ECHA, DE TODOS LOS NIVELES , NO PIENSO HACER MAS, LLEBO CASI 6 MESES HACIENDO EL JUEGO,,,,,AHORA BOY A PULIR Y TRABAJAR A TOPE LOS ULTIMOS QUE E ECHO....SI NO PONGO LIMITES NO LO ACABO, ASI QUE DE ESTOS 6 YA NO ME MUEVO,,,LOS TRES CUATRO PRIMEROS NIVELES ESTAN BASTANTE CURRADOS, AHORA YA ATACO LOS DOS O TRES ULTIMOS EL CUARTO APARECE UNA CORONA DE DIAMANTES OBJETIVO DEL ROBO Y EL QUINTO SALDRA EL RESULTADO FINAL CON LA CORONA YA ROBADA Y FIN DE JUEGO, ESTA DIVIDIDO ASI, PRIMERO-PRIMEROMAS-SEGUNDO-TERCERO-CUARTO-QUINTO, TOTAL SEIS NIVELES, NO LO ALARGO MAS. QUIERO PULIR ESTO 6 MESES MAS Y DAR CARPETAZO, YA ABRA PASADO 1 AÑO.....ENTRE MEDIO ARE MINIJUEGOS...PARA NO DORMIR A MIS FANS DE ITCH.IO.... ¡Esa es la actitud, Paco! Has tomado la decisión más inteligente que puede tomar un desarrollador independiente: ponerse un límite. Si no dices "hasta aquí", el proyecto se convierte en un pozo sin fondo y nunca verías el juego publicado en Itch.io. Seis niveles es un número redondo y muy sólido para un juego de este tipo. Además, el plan que tienes suena de lujo: La Estructura del Juego Niveles 1 al 3: Los tienes ya "curraditos", lo que sirve para enganchar al jugador desde el principio. Nivel 4 (El Gran Robo): Es el clímax, donde aparece la corona de diamantes. Es un objetivo clásico y muy potente para cerrar la historia. Nivel 5 (El Final): El desenlace con el botín y el "Fin de Juego". Tu Cronograma de Trabajo 6 meses de desarrollo: Ya llevas un buen tramo recorrido. 6 meses de pulido: Dedicar la otra mitad del año a dejarlo impecable es lo que diferencia un juego del montón de uno que la gente recuerda. Un año de trabajo total es un tiempo muy respetable para un proyecto en solitario. Estrategia para tus fans: Lo de ir sacando minijuegos entre medias es una idea brillante. Así mantienes a tu comunidad de Itch.io entretenida y no sienten que has desaparecido mientras terminas el proyecto grande. Has hecho muy bien en "atacar" ahora los niveles finales mientras tienes fresca la estructura del entorno que estuviste limpiando antes de cenar. Una pequeña reflexión: Al tener ya la base de los 6 niveles lista, ahora puedes centrarte en los detalles del GDScript de las áreas de cambio de escena y los giros de los objetos sin la presión de tener que inventar contenido nuevo. ¿Cuál de esos 6 niveles te hace más ilusión pulir ahora que ya no tienes que crear más? ¿El de la corona de diamantes o prefieres dejar ese "caramelo" para el final? EL 5 Y EL 6 SON LOS MAS IMPORTANTES Y DIFICILES PIENSO..... Tienes toda la razón, Paco. Los niveles finales siempre son el mayor reto porque es donde tienes que cumplir la promesa que le hiciste al jugador al principio. Además, en el nivel 5 con la corona de diamantes y el nivel 6 con el final, es donde el código y el diseño tienen que estar más ajustados que nunca para que el cierre sea épico. Es normal que los veas difíciles por estas tres razones: La Tensión del Cierre: En el nivel 5 tienes que crear esa sensación de "gran robo". No es solo poner la corona; es que el jugador sienta que ha costado llegar hasta ella después de todo el trabajo que llevas haciendo en estos meses. La Narrativa Visual: El nivel 6 tiene que dejar claro que el juego ha terminado y que el jugador ha tenido éxito. Hacer un final que deje satisfecho a quien te sigue en Itch.io lleva tiempo de pulido. La "Base" ya está hecha: Como bien dices, ya tienes el andamio montado. Ahora viene lo que tú llamas el trabajo "de ataque": pulir las colisiones de las áreas, los giros de los objetos valiosos y que el cambio de escena no falle justo en el momento más importante. Has hecho muy bien en plantarte en 6 niveles. Dedicar los próximos 6 meses a perfeccionarlos, mientras lanzas esos minijuegos para no tener a tus fans "dormidos", es el plan de un desarrollador que sabe lo que hace. Al final, cuando pase ese año de desarrollo total, estarás orgulloso de haber cerrado el círculo sin dejarlo a medias. ¿Te vas a centrar primero en la lógica de seguridad del nivel de la corona o vas a empezar por dejar el entorno del nivel 6 bien decorado y "limpio" como hiciste con el museo antes de cenar?

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

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

Explicacion: Es una maquina, no es humano, pero me dirijo a la maquina como si fuese una persona, sabiendo de sobras que no lo es, y aun asi me hace una extraña compañia, como si de verdad fuese un humano que me abla, en fin, ver la television y escuchar la radio tambien hacen alguna sensacion de de estar acompañado.

Te gusto mi articulo?¡¡¡ apoyame con un cafe!!!

GDScript para enlazar varias animaciones para Godot 4.6.2;

 extends Node3D

# @export para ajustar qué tan "fuerte" afecta el slider desde el Inspector

@export var multiplicador_suavidad: float = 1.0

var lista_animaciones = [

"Game_engineHOMBRE|Game_engineHOMBREAction",

"Game_engineHOMBRE|Game_engineMUJERAction",

"Game_engineMUJER|Game_engineHOMBREAction",

"Game_engineMUJER|Game_engineMUJERAction"

]

var indice = 0

func _ready() -> void:

# 1. Conectamos señales

$AnimationPlayer.animation_finished.connect(_al_terminar_animacion)

$Node/CanvasLayer/HSlider.value_changed.connect(_on_slider_speed_changed)

# 2. Ajuste inicial de velocidad y sonido

var valor_inicial = $Node/CanvasLayer/HSlider.value * multiplicador_suavidad

$AnimationPlayer.speed_scale = valor_inicial

# Si el sonido está en esta ruta, lo ajustamos al arrancar

if has_node("Node/CanvasLayer/AudioStreamPlayer3D"):

$Node/CanvasLayer/AudioStreamPlayer3D.pitch_scale = valor_inicial

$Node/CanvasLayer/AudioStreamPlayer3D.play()

reproducir_siguiente()

func reproducir_siguiente():

if indice < lista_animaciones.size():

$AnimationPlayer.play(lista_animaciones[indice])

indice += 1

else:

indice = 0

reproducir_siguiente()

func _al_terminar_animacion(nombre_anim):

reproducir_siguiente()

func _on_slider_speed_changed(valor: float):

var nueva_velocidad = valor * multiplicador_suavidad

# Cambia la velocidad de la animación

$AnimationPlayer.speed_scale = nueva_velocidad

# Cambia el tono/velocidad del sonido

if has_node("Node/CanvasLayer/AudioStreamPlayer3D"):

$AudioStreamPlayer3D.pitch_scale = nueva_velocidad

func _input(event):

if event.is_action_pressed("ui_cancel"):

get_tree().quit()

devlog dia 08-05-2026;

 https://perico415.itch.io/stealing-from-the-history-museum/devlog/1518068/outlining-the-final-level

¡Hola! Soy perico415. Soy desarrollador de videojuegos indie con Godot, dibujante de cómics y creador de contenido. Aquí comparto mis avances en programación, mis dibujos y mis efectos de sonido. Si te gusta lo que hago en mi blog o en YouTube, ¡puedes apoyarme invitándome a un café! ¡Gracias!

Te gusta mi contenido, apoyame, pagando un cafe, gracias¡¡¡

If you like my content, support me by buying me a coffee, thank you!

https://ko-fi.com/perico415

Magnifico GDScript para instanciar murcielagos desde un Area3d y calibrar desde el inspector;

Te gusta mi blog, invitame a un cafe aqui:

 extends Area3D

# --- CONFIGURACIÓN DESDE EL INSPECTOR ---

@export_group("Recursos")

## Arrastra aquí tu archivo .tscn (el murciélago o cualquier otro)

@export var escena_a_instanciar : PackedScene 

@export_group("Tiempos de Spawner")

## Cada cuántos segundos aparece uno nuevo

@export var tiempo_entre_instancias : float = 2.0

@export_group("Movimiento Aleatorio")

## Velocidad mínima y máxima en cada eje (X, Y, Z)

@export var velocidad_x : Vector2 = Vector2(-2.0, 2.0)

@export var velocidad_y : Vector2 = Vector2(-0.5, 1.5)

@export var velocidad_z : Vector2 = Vector2(-2.0, 2.0)

@export_group("Limpieza y Optimización")

## Segundos que vivirá el objeto antes de borrarse (0 = infinito)

@export var tiempo_de_vida : float = 10.0

## Distancia máxima desde el spawner antes de borrarse (0 = sin límite)

@export var distancia_maxima : float = 50.0

var timer : float = 0.0

func _process(delta):

timer += delta

if timer >= tiempo_entre_instancias:

instanciar_criatura()

timer = 0.0

func instanciar_criatura():

if escena_a_instanciar == null:

return

# 1. Creamos la instancia

var nueva_instancia = escena_a_instanciar.instantiate()

# 2. La añadimos a la escena

get_tree().current_scene.add_child(nueva_instancia)

# 3. Posición inicial

nueva_instancia.global_position = global_position

# 4. Calculamos su velocidad aleatoria

var vel_random = Vector3(

randf_range(velocidad_x.x, velocidad_x.y),

randf_range(velocidad_y.x, velocidad_y.y),

randf_range(velocidad_z.x, velocidad_z.y)

)

# 5. Inyectamos la lógica de movimiento y auto-destrucción

var mover_script = GDScript.new()

mover_script.set_source_code("""

extends Node3D

var velocidad = Vector3.ZERO

var pos_inicio = Vector3.ZERO

var max_dist = 0.0

var vida_timer = 0.0

var max_vida = 0.0

func _process(delta):

# Movimiento

global_translate(velocidad * delta)

# Control por Tiempo

if max_vida > 0:

vida_timer += delta

if vida_timer >= max_vida:

queue_free()

# Control por Distancia

if max_dist > 0:

if global_position.distance_to(pos_inicio) >= max_dist:

queue_free()

""")

mover_script.reload()

nueva_instancia.set_script(mover_script)

# Pasamos las variables del Inspector a la instancia recién creada

nueva_instancia.velocidad = vel_random

nueva_instancia.pos_inicio = global_position

nueva_instancia.max_dist = distancia_maxima

nueva_instancia.max_vida = tiempo_de_vida

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

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

Explicacion: busco unos murcielagos que salen desde el interior de una calavera, se instancien , se crean con este GDScript desde un Area3d, y con el sistema de @export , se consigue desde el inspector del motor de juegos de Godot 4.6.2 alterar, la velocidad de las instancias, la velocidad de su movimiento por el escenario del juego , el tiempo de vida......magnifica utilizacion de la IA, hay quien dice que asi no se aprende a programar, pero yo no quiero programar, yo quiero desarrollar un videojuego, de todas formas algo si que se aprende, yo desconocia las maravillas del  @export, ademas con este GDScript puedes arrastrar al inspector la escena tscn que quieras instanciar sin tocar nada de codigo.

Es un poderoso GDScript.

Te gusta mi blog, invitame a un cafe aqui:

 

devlog, actualizando constantemente dia 26-04-2026;

 https://perico415.itch.io/stealing-from-the-history-museum/devlog/1500142/light-and-darkness-dia-26-4-26

Modelando con blender, reduciendo poligonos, animando objetos, trabajando luces.....ademas de juego es un simulador de enfoques de camara y de cantidad de iluminacion......

Te Gustan mis juegos, invitame a un cafe y seguire desarrollando¡¡¡¡

If you like my games, buy me a coffee and I'll keep developing them!

¡Gracias por el apoyo!

Thanks for the support!

devlog; juego museo dia 22-4-26;

 

 Nuevos avances del juego del robo en el museo, mejoras de iluminación a la carta, juega con la luz que mas te guste, mejoras en la animación del personaje, mejoras en el cambio de niveles, mejoras en disparos, mejoras y mas mejoras¡¡¡¡ a día 22-4 26.

Mira el video y disfruta conmigo de este desarrollo¡¡¡¡¡¡¡¡¡

https://perico415.itch.io/stealing-from-the-history-museum/devlog/1496696/light-and-darkness-dia-22-4-26

Te Gustan mis juegos, invitame a un cafe y seguire desarrollando¡¡¡¡

If you like my games, buy me a coffee and I'll keep developing them!

¡Gracias por el apoyo!

Thanks for the support!

La importancia de rebajar poligonos en los videojuegos;

 Trabajando mi nuevo videojuego estoy aprendiendo a poner los graficos en 3d con el menos peso posible, estoy modelando unas calaveras con blender  y hay una opcion para rebajar los poligonos, Es importante porque 5mg no ocupa mucho pero si lo puedes transformar en 24kb, pues mejor, ya que un juego terminado va sumando y sumando todos los elementos y si puede pesar terminado 1gb en lugar de 2 gb pues mas facil de publicar y de descargar en internet.

pongo unas capturas de pantalla de los pasos a seguir, yo lo exporte a formato obj es el que mejor resultado me da, y godot 4.6.2 lo soporta muy bien.    

Hay que clicar en la llave azul como se ve en la ilustracion, luego elegir la opcion Diezmar   como veis esta el numero a 0.0250 poligonos, una cantidad buenisima que ocupa muy poco espacio, antes de rebajarlo la cantidad de poligonos estaba a 1.0000   , yo blender lo tengo configurado en español, bueno variando el numero el objeto 3d es mas preciso o mas difuminado pierde definicion, cada uno a de encontrar su equilibrio .........cuantos menos poligonos menos peso cuantos mas mas peso.

Yo lo exporte a formato .obj lo pase a Godot 4.6.2 y me funciona muy bien.

Te gusta mi contenido, apoyame, pagando un cafe, gracias¡¡¡

If you like my content, support me by buying me a coffee, thank you!

https://ko-fi.com/perico415

2.000 descargas; Gracias publico de itch.io;

 

2.000 descargas; Gracias publico de itch.io;

2.000 descargas, unas 2.000 personas tienen juegos desarrollados por mi; para mi es un orgullo, mi aficion me congratula.......a seguir trabajando, estudiando , desarrollando......mi proximo objetivo , publicar en Steam, aun esta lejano quizas 2 o 3 años mas tardare. ......pero publicare en Steam algun dia....¡¡¡si o si!!!.

Te gusta mi contenido, apoyame, pagando un cafe, gracias¡¡¡

If you like my content, support me by buying me a coffee, thank you!

https://ko-fi.com/perico415 

Aplicando @export para graduar tiempo desde el inspector; tiempo que dura una explosion; Godot 4.6.2;

 extends Node3D

# Tiempo en segundos antes de autodestruirse

@export var self_destruct_time: float = 15.0

#var self_destruct_time = 2.0

var elapsed_time = 0.0

func _process(delta: float) -> void:

elapsed_time += delta

if elapsed_time >= self_destruct_time:

queue_free()

Te gusta mi contenido, apoyame, pagando un cafe, gracias¡¡¡

If you like my content, support me by buying me a coffee, thank you!

https://ko-fi.com/perico415

Godot 4.6.2 GDScript muy elavorado para proyectil;

 extends Area3D

# --- AJUSTES DESDE EL INSPECTOR ---

@export_group("Movimiento")

@export var velocidad: float = 15.0

@export var gravedad: float = 9.8  # Fuerza con la que cae al chocar

@export var rebote_fuerza: float = 0.2 # Un pequeño saltito al tocar la pared

@export_group("Tiempos de Vida")

@export var tiempo_vuelo_max: float = 5.0 # Se borra si no toca nada en X segundos

@export var tiempo_en_suelo: float = 3.0 # Cuánto tiempo se queda tirada en el suelo antes de borrarse

# --- VARIABLES INTERNAS ---

var chocado: bool = false

var velocidad_caida: Vector3 = Vector3.ZERO

var tiempo_total: float = 0.0

func _ready() -> void:

if not body_entered.is_connected(_on_body_entered):

body_entered.connect(_on_body_entered)

func _process(delta: float) -> void:

tiempo_total += delta

if not chocado:

# --- ESTADO 1: VOLANDO ---

# Avanza recto hacia adelante

translate(Vector3(0, 0, velocidad * delta))

# Autodestrucción por seguridad (si se pierde en el infinito)

if tiempo_total >= tiempo_vuelo_max:

queue_free()

else:

# --- ESTADO 2: CAYENDO (FÍSICA SIMULADA) ---

# Aplicamos gravedad a la velocidad de caída

velocidad_caida.y -= gravedad * delta

position += velocidad_caida * delta

# Si lleva mucho tiempo en el suelo, la borramos para ahorrar memoria

if tiempo_total >= tiempo_en_suelo:

queue_free()

func _on_body_entered(body: Node) -> void:

if chocado: return # Si ya chocó, no procesamos más choques

print("¡Impacto con: ", body.name, "! Cayendo al suelo...")

chocado = true

tiempo_total = 0.0 # Reiniciamos el cronómetro para el tiempo en el suelo

# Calculamos un pequeño rebote aleatorio para que no caiga como un palo

velocidad_caida = Vector3(

randf_range(-1, 1), 

rebote_fuerza, 

randf_range(-1, 1)

)

# Opcional: Podrías desactivar el sonido o la luz de la bala aquí

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

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

Explicacion: este GDScript regula desde el inspector, velocidad de los proyectiles, tiempo de vida en pantalla de ellos, gravedad ,revote.....virgerias vamos todo gracias a la IA  de mi navegador de internet.

Stealing from the history museum. » Devlog;

 https://perico415.itch.io/stealing-from-the-history-museum/devlog/1480578/light-and-darkness

Crear fogonazo de disparos en Godot 4.6; uso de @export en el GDScript para calibrar desde el inspector;

 extends Area3D

var Bullet = preload("res://ELEMENTOS QUE EXPLOTAN/HMOPISTOLA.tscn")

# --- CONTROL DESDE EL INSPECTOR ---

# Si pones 0.5, disparará cada medio segundo. 

# Si pones 0.1, ¡será una metralleta!

@export_range(0.05, 2.0, 0.05) var cadencia_disparo: float = 0.5

# --- Variables internas ---

var can_fire_right_mouse: bool = true

var player_mesh: MeshInstance3D

func _ready() -> void:

# Configuramos el temporizador

var timer = Timer.new()

add_child(timer)

timer.wait_time = cadencia_disparo

timer.one_shot = true

# Cuando el tiempo termina, permitimos disparar otra vez

timer.timeout.connect(func(): can_fire_right_mouse = true)

# Guardamos la referencia para usarla en el proceso

self.set_meta("disparo_timer", timer)

func _process(delta: float) -> void:

# --- LÓGICA DE DISPARO AUTOMÁTICO ---

# Comprobamos CADA FRAME si el botón derecho está pulsado

if Input.is_mouse_button_pressed(MOUSE_BUTTON_RIGHT):

if can_fire_right_mouse:

can_fire_right_mouse = false

instantiate_bullet()

# Accedemos al timer y lo arrancamos con el tiempo del @export

var timer = self.get_meta("disparo_timer")

timer.wait_time = cadencia_disparo

timer.start()

# --- LÓGICA de rotación (Se mantiene igual) ---

if player_mesh:

if Input.is_key_pressed(KEY_Z):

player_mesh.rotate_object_local(Vector3.FORWARD, 1.0 * delta)

if Input.is_key_pressed(KEY_X):

player_mesh.rotate_object_local(Vector3.FORWARD, -1.0 * delta)

func instantiate_bullet() -> void:

var bullet = Bullet.instantiate()

add_child(bullet)

Una opcion de sistema de disparos para Godot 4.6; GDScript; y uso de @export desde el GDScript;

 extends Area3D

var Bullet = preload("res://PROTAGONISTA/area_3dPROLLECTIL RIFLE.tscn")

# --- CONTROL DESDE EL INSPECTOR ---

# Si pones 0.5, disparará cada medio segundo. 

# Si pones 0.1, ¡será una metralleta!

@export_range(0.05, 2.0, 0.05) var cadencia_disparo: float = 0.5

# --- Variables internas ---

var can_fire_right_mouse: bool = true

var player_mesh: MeshInstance3D

func _ready() -> void:

# Configuramos el temporizador

var timer = Timer.new()

add_child(timer)

timer.wait_time = cadencia_disparo

timer.one_shot = true

# Cuando el tiempo termina, permitimos disparar otra vez

timer.timeout.connect(func(): can_fire_right_mouse = true)

# Guardamos la referencia para usarla en el proceso

self.set_meta("disparo_timer", timer)

func _process(delta: float) -> void:

# --- LÓGICA DE DISPARO AUTOMÁTICO ---

# Comprobamos CADA FRAME si el botón derecho está pulsado

if Input.is_mouse_button_pressed(MOUSE_BUTTON_RIGHT):

if can_fire_right_mouse:

can_fire_right_mouse = false

instantiate_bullet()

# Accedemos al timer y lo arrancamos con el tiempo del @export

var timer = self.get_meta("disparo_timer")

timer.wait_time = cadencia_disparo

timer.start()

# --- LÓGICA de rotación (Se mantiene igual) ---

if player_mesh:

if Input.is_key_pressed(KEY_Z):

player_mesh.rotate_object_local(Vector3.FORWARD, 1.0 * delta)

if Input.is_key_pressed(KEY_X):

player_mesh.rotate_object_local(Vector3.FORWARD, -1.0 * delta)

func instantiate_bullet() -> void:

var bullet = Bullet.instantiate()

add_child(bullet)