CONCLUSION DE MIXAMO A BLENDER DE BLENDER A GODOT 4.4.;

 En mi ultima entrada del blog estaba divagando sobre pasar las animaciones de mixamo a mis personajes y combinarlas con los gdscript de godot,

Pero habia dificultades en la web de Mixamo no podia descargar nada ni practicar, hay videos tutoriales en youtube de como hacerlo pero siempre se olvidan de algun detalle que hace falle cualquier cosa que intente hacer, 

Hay que imitar con exactitud los tutoriales de youtube.

Bueno a la conclusion que e llegado y en el video muestra que pongo en la entrada vereis que lo FUNDAMENTAL DEL TEMA es animaciones diferentes de mixamo pero del mismo ramo, o calibre, o coleccion, si mezclais animaciones de diferentes tipos que hay en mixamo unas se acoplan y otras no, por tamaños o por temas del esqueleto o yo que se , mejor lo veis en el video lo demas es facil de aplicar , los avatares del mismo color parece que combinan bien entre si las animaciones si poneis avatares diferentes entre si no casan, e tardado 2 dias en entenderlo, bueno como todo al final es solo trabajo esfuerzo y echarle horas..........luego si pones  un personaje del mismo mixamo con blender puedes modelarlo y cambiar lo que quieras dependiendo de las horas que le dediques y del talento que tengas.

Y mi conclusion comentada a la IA:

no hay ningun misterio, las animaciones de mixamo solo funcionan las que casan entre si, los avatares del mismo color suelen ir perfectamente ,ya lo resolvi¡¡ el paso a pasarlo a blender y combinarlo alli a partir de esta conclusion es muy sencillo de relosver¡¡¡

¡Qué excelente noticia que lo hayas resuelto! Me alegra mucho saber que encontraste la clave para que tus animaciones de Mixamo funcionen bien en Blender.

Tu observación sobre que "las animaciones de Mixamo solo funcionan las que casan entre sí" y que "los avatares del mismo color suelen ir perfectamente" es muy acertada y crucial. Esto apunta directamente a la consistencia en el rig (esqueleto) y la pose base.

Cuando Mixamo genera un "avatar del mismo color" (me imagino que te refieres a los personajes pre-riggeados de Mixamo o a las variaciones del mismo rig), garantiza que la estructura ósea, la escala y la pose inicial (T-pose o A-pose) son idénticas. Esto es fundamental para que las animaciones se superpongan y mezclen sin problemas. Si bien puedes aplicar animaciones a cualquier personaje riggeado en Mixamo, la armonía es mayor cuando la base es la misma.

---

La Clave que Descubriste: Consistencia del Rig

Lo que has descubierto es la base de la combinación exitosa de animaciones:

• Rigs Idénticos: Cuando todas las animaciones se aplican a un rig que es estructural y posicionalmente idéntico, Blender tiene mucha más facilidad para interpretar y mezclar los datos de animación sin que los huesos "salten" o el personaje se "balancee".

• Pose Base Coherente: Las animaciones de Mixamo están diseñadas para un rig específico y una pose de reposo concreta. Si intentas aplicar una animación a un personaje con una pose base diferente (ej. un personaje en A-pose para una animación hecha en T-pose), se pueden producir esas desalineaciones. Los avatares "del mismo color" o de la misma familia de Mixamo suelen compartir esta pose base.

---

Tu Proceso en Blender Después de esta Conclusión

Como bien dices, una vez que tienes esta base, el paso a paso en Blender se simplifica enormemente:

1. Importación del Personaje Base: Traes tu personaje (el que tiene el rig compatible).

2. Importación de Animaciones (sin el modelo): Al importar las animaciones de Mixamo, si ya tienes el personaje base en la escena, puedes importar solo la acción de animación (sin el modelo adjunto o importando solo el armature si es necesario y luego copiando la acción).

3. Uso del NLA Editor: Empujas cada acción de animación a una Action Strip en el NLA Editor.

4. Organización y Blending: Arrastras y superpones las tiras, ajustando los "Blend In" y "Blend Out" para crear transiciones suaves. Si los rigs son consistentes, estos blends funcionarán mucho mejor.

¡Felicidades por haber resuelto el misterio! Es un aprendizaje valioso que te ahorrará muchos dolores de cabeza en futuros proyectos de animación.

Frustracion estudiando animaciones; mixamo en esta fecha del 18-6-25 da problemas para descargarse sus animaciones;

 Estoy estudiando y practicando combinar animaciones con blender y mixamo y Gogot 4.4.

Y GDScript para programar las animaciones con ayuda de la IA.

En principio las ago manuales y si son pocos movimientos funciona muy bien, andar y dar golpes se me da bastante bien, y con GDScript le asigno las teclas y me da resultados aceptables , ahora estoy intentando hacer las combinaciones de movimientos con mixamo y tengo la mala suerte que en estos momentos no deja mixamo descargarse nada.....

Ahora que empezaba a combinar movimientos y queria probarlos en Godot 4.4. y GDScript para asignarlos al teclado del pc ...sus movimientos......mixamo no me deja descargar sus animaciones , seve hay problemas desde esa aplicacion en sus servidores.......bueno a tener paciencia y a esperar mientras se resuelve.... volvere hacerlas manuales......no me puedo estancar.

Es una lastima porque ya lo tenia casi, ya tenia la base para hacer los juegos muy muy pulidos en ese aspecto.....en fin.

A seguir trabajando ya se resolvera.

Juego gotico de terror en 3d;

 

Personaje lo animo y a los 5 segundos lo borro de la escena, GDScript para Godot 4.4;

 extends Node3D

var temporizador: Timer # Creamos una variable para guardar nuestro temporizador

func _ready() -> void:

# Esto se ejecuta cuando el nodo se carga en la escena.

$AnimationPlayer.play("Human_rig|REVIENTA") # Tu animación se sigue reproduciendo.

# Paso 1: Crear el Temporizador

temporizador = Timer.new() # Creamos una nueva instancia de un nodo Timer.

add_child(temporizador) # ¡Importante! Añadimos el temporizador como hijo de este nodo.

# Necesita estar en el árbol de la escena para funcionar.

# Paso 2: Configurar el Temporizador

temporizador.wait_time = 5.0 # Le decimos al temporizador que espere 5 segundos.

temporizador.one_shot = true # Le decimos que solo se active una vez (disparo único).

# Si fuera 'false', se repetiría indefinidamente.

# Paso 3: Conectar la Señal "timeout"

# Cuando el temporizador termine de contar, emitirá una señal llamada "timeout".

# Conectamos esa señal a una función nuestra llamada "_al_terminar_temporizador".

temporizador.connect("timeout", Callable(self, "_al_terminar_temporizador"))

# Paso 4: Iniciar el Temporizador

temporizador.start() # ¡Aquí comienza la cuenta regresiva!

func _al_terminar_temporizador() -> void:

# Esta función se ejecutará automáticamente cuando el temporizador llegue a 0.

queue_free() # Esta es la función mágica: borra el nodo actual de la escena.

# Usamos 'queue_free()' para que se borre de forma segura al final del fotograma.

Un proyectil se destruye al chocar con un RigidBody;

 # Script para el Area3D PROYECTIL EN SÍ MISMO (el propio proyectil)

extends Area3D

var score = 0 # No usado directamente para la destrucción, pero se mantiene si lo necesitas para otras lógicas.

var speed = 15 # Velocidad en el eje Z (adelante)

var speed2 = 1 # Velocidad en el eje Y (hacia arriba, si lo deseas)

var tiempo_transcurrido = 0.0 # Controla el tiempo de vida del proyectil

var vida_util_segundos = 6.0 # El proyectil se destruirá después de 6 segundos

func _ready() -> void:

# Conectamos la señal 'body_entered'.

# Se activará cuando este Area3D colisione con cualquier PhysicsBody3D (ej. una pared, el suelo, un enemigo).

connect("body_entered", Callable(self, "_on_body_entered"))

print("Proyectil listo: se moverá, se destruirá por tiempo y al chocar.")

func _process(delta: float) -> void:

# Mover el proyectil

# Vector3(X, Y, Z) - ajusta el orden según la orientación de tu proyectil en 3D

# Aquí, el movimiento es ligeramente hacia arriba (Y) y principalmente hacia adelante (Z)

var movimiento = Vector3(0, speed2 * delta, speed * delta)

translate(movimiento) # Mueve el nodo en su espacio local

# Controlar el tiempo de vida del proyectil

tiempo_transcurrido += delta

if tiempo_transcurrido >= vida_util_segundos:

print("Proyectil ha alcanzado su tiempo de vida. Destruyendo...")

queue_free() # Elimina el proyectil si ha superado su tiempo de vida

func _on_body_entered(body: Node3D):

# Esta función se ejecuta cuando el proyectil colisiona con un PhysicsBody3D.

#print(f"¡Proyectil colisionó con: {body.name}! Destruyendo...")

queue_free() # Elimina el proyectil al impactar con un cuerpo

Complemento a https://videojuegosenlineaasaco4.blogspot.com/2025/06/gdscript-para-colocar-unos-sprite2d-en.html;

 # Area3DVisibilityControl.gd

extends Area3D

@onready var sprite_2d_1 = get_node("../Sprite2D") # Ajusta la ruta si es diferente

@onready var sprite_2d_2 = get_node("../Sprite2D2IMAGEN ENEMIGO FINAL") # Ajusta la ruta si es diferente

# Define cuánto se moverá sprite_2d_1 hacia abajo desde el centro.

# Puedes ajustar este valor. Un número positivo lo mueve hacia abajo.

const OFFSET_Y_SPRITE_1 = 400.0 # Por ejemplo, 400 píxeles hacia abajo

const OFFSET_Y_SPRITE_2 = 300.0 # Por ejemplo, 300 píxeles hacia abajo

# Define cuánto se moverá sprite_2d_1 en el eje X desde el centro.

# Un número positivo lo mueve hacia la derecha, un negativo hacia la izquierda.

const OFFSET_X_SPRITE_1 = -280.0

const OFFSET_X_SPRITE_2 = -280.0

func _ready():

# Conectamos la señal 'area_entered' de este Area3D.

area_entered.connect(_on_area_entered)

func _on_area_entered(area: Area3D):

print("Otro Area3D entró en este Area3D: ", area.name)

# --- Obtener el tamaño del viewport (la ventana del juego) ---

var viewport_size = DisplayServer.window_get_size()

# --- Calcular la posición central de la pantalla ---

var center_x = viewport_size.x / 2.0

var center_y = viewport_size.y / 2.0

# --- Mover el primer Sprite2D un poco por debajo y a la derecha/izquierda del centro ---

# Sumamos OFFSET_X_SPRITE_1 a la posición X central.

# Sumamos OFFSET_Y_SPRITE_1 a la posición Y central.

sprite_2d_1.position = Vector2(center_x + OFFSET_X_SPRITE_1, center_y + OFFSET_Y_SPRITE_1)

# --- Mover el segundo Sprite2D solo en el eje Y (según tu código actual) ---

sprite_2d_2.position = Vector2(center_x + OFFSET_X_SPRITE_2, center_y + OFFSET_Y_SPRITE_2)

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

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

EXPLICACION: Con este GDScript  puedo mover por pantalla variando el valor tanto en eje -y- como en eje -x- se complementa a  https://videojuegosenlineaasaco4.blogspot.com/2025/06/gdscript-para-colocar-unos-sprite2d-en.html

GDScript para colocar unos Sprite2D en la parte vaja de la pantalla del juego al ocurrir una colision;

 # Area3DVisibilityControl.gd

extends Area3D

@onready var sprite_2d_1 = get_node("../Sprite2D") # Ajusta la ruta si es diferente

@onready var sprite_2d_2 = get_node("../Sprite2D2IMAGEN ENEMIGO FINAL") # Ajusta la ruta si es diferente

# Define cuánto se moverá sprite_2d_1 hacia abajo desde el centro.

# Puedes ajustar este valor. Un número positivo lo mueve hacia abajo.

const OFFSET_Y_SPRITE_1 = 400.0 # Por ejemplo, 100 píxeles hacia abajo

const OFFSET_Y_SPRITE_2 = 300.0 # Por ejemplo, 100 píxeles hacia abajoIMBENTADO POR MIIIIIIIIIIIIIIII

func _ready():

# Conectamos la señal 'area_entered' de este Area3D.

area_entered.connect(_on_area_entered)

func _on_area_entered(area: Area3D):

print("Otro Area3D entró en este Area3D: ", area.name)

# --- Obtener el tamaño del viewport (la ventana del juego) ---

var viewport_size = DisplayServer.window_get_size() 

# --- Calcular la posición central de la pantalla ---

var center_x = viewport_size.x / 2.0

var center_y = viewport_size.y / 2.0

# --- Mover el primer Sprite2D un poco por debajo del centro ---

# Sumamos el OFFSET_Y_SPRITE_1 a la posición Y central.

sprite_2d_1.position = Vector2(center_x, center_y + OFFSET_Y_SPRITE_1)

sprite_2d_2.position = Vector2(center_x, center_y + OFFSET_Y_SPRITE_2)########3IMBENTADO POR MIIIIIIIIIIIIIIIIIIII

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

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

EXPLICACION : En mi nuevo videojuego hay una escena en la que el protagonista del juego entra en una habitacion y con este GDScript produzco que aparezcan unos sprites ala vista donde sale la imagen del malvado al que e de destruir y una barra de vida que mengua conforme lo ataco, este GDScript produce que lo situe en pantalla solamente cuando el protagonista del juego entra en la habitacion.........

Ejemplo de manipular geometrias 3d; con el propio Godot 4.4; para construir inmuebles,; recintos,; cuevas;, naves ;, tuneles ;lo que se nos ocurra;

          .(la parte superior izquierda del video esta tapada expresamente porque el videojuego sera para +18 años)

En mi nuevo juego que publicare pronto en itch.io e aprendido a ....manipular geometrias 3d; con el propio Godot 4.4; para construir inmuebles,; recintos,; cuevas;, naves ;, tuneles ;lo que se nos ocurra;

https://perico415.itch.io/

En este video podeis ver un minimo ejemplo de como poner un CSGSphere3D  una bola enorme que cubre a unos personajes esta en estado solido y con colision activada, dentro le puse un cilindro atravesado al cual le puse la opcion de sustraccion....podeis ver como el personaje puede pasar por el hueco realizado y podeis comprobar que el resto del CSGSphere3D  una bola enorme , no la puede atravesar el personaje.......e echo un simple ejemplo ahora acabo de hacerlo mas elaborado no sale en el video pero e conseguido que la bola enorme duplicarla y escalarla algo mas pequeña y hacer la sustraccion, el resultado es una pecera perfecta a la que añadi dos nuevos cilindros de entrada al interior, y queda una estructura perfectamente redondeada y con colision donde interesa....muestro unas capturas de pantalla de lo conseguido......

https://perico415.itch.io/

Videojuego 3d con visiones y planos de 360 grados con la camara, en desarrollo , pronto a la venta en itch.io a finales de junio principios de julio del 2025;

POR POLITICAS DE YOUTUBE EN EL VIDEO MANTENGO LAS DISTANCIAS DE LA CAMARAY CENSURO ALGUNAS IMAGENES, NO SON IMAGENES DE OTRO MUNDO PERO LA POLITICA DE YOUTUBE ES MUY RESTRICTIBA Y E DE RESPETARLA PARA QUE NO ME BANEEN LA CUENTA, EN ITCH,IO HAY MAS LIBERTAD Y EL QUE QUIERA DISFRUTAR EL JUEGO DEVERA ESPERAR UNAS SEMANAS Y DESCARGARLO DE perico415 - itch.ioVideojuego 3d con visiones y planos de 360 grados con la camara, en desarrollo , pronto a la venta en itch.io a finales de junio principios de julio del 2025.

T-E-R-R-O-R-I-F-I-C-O- + 18 Años https://perico415.itch.io/ perico415 - itch.io https://videojuegosenlineaasaco4.blogspot.com/

Detalles del desarrollo: sobre todo un manejo de la camara y de los planos que tendra el jugador del juego muy muy buenos, vision total del entorno en 360 º , acercar y alejar la camara asta donde quieras y no perder al Player que manejamos en ningun momento, un sonido muy terrorifico y macabro, pronto estara en Itch.io por un modico precio de alrrededor los 2$, es un desarrollo de un par de meses o tres, y es para gente adulta de mas d 18 años, estara completo, con sentido desenlace y final con coherencia en la historia, en mi web de Itch.io podeis descargar juegos completos gratuitos realizados con Godot 4.4 mi motor de juegos favorito.

Tambien los hay de pago, descargad los gratuitos, disfrutarlos y.... los de pago estan mas trabajados....jajajajaja si os llama algo la atencion no estan a precios astronomicos......visitad de todas formas......perico415 - itch.io
 

Uso de un func _on_body_entered(body: Node3D) -> void: para borrar un proyectil cuando colisiona;

 extends Area3D

var score = 0

var speed = 15 # Unidades por segundo

var speed2 = 1 # Unidades por segundo

var tiempo_transcurrido = 0.0 # Tiempo en segundos

func _ready() -> void:

# Conecta la señal 'body_entered' a una función que manejará la colisión

body_entered.connect(_on_body_entered)

func _process(delta: float) -> void:

var movimiento = Vector3(0, speed2 * delta, speed * delta)

translate(movimiento)

tiempo_transcurrido += delta

if tiempo_transcurrido >= 10.0:

queue_free()

# Esta función se llamará cuando un cuerpo entre en esta área

func _on_body_entered(body: Node3D) -> void:

print("¡Colisión detectada con: ", body.name, "!")

queue_free() # Borra el nodo cuando colisiona

GDScript simplemente anima;

 extends AnimationPlayer

func _ready() -> void:

$".".play("alas")

pass

func _process(delta: float) -> void:

pass

GDScript anima al presionar espacio;

 extends AnimationPlayer

func _ready() -> void:

pass

func _process(delta: float) -> void:

if Input.is_action_just_pressed("ui_accept"):

play("alas")

GDScript anima al presionar espacio al soltar no anima;

 extends AnimationPlayer

func _ready() -> void:

pass

func _process(delta: float) -> void:

if Input.is_action_pressed("ui_accept"):

if not is_playing():

play("alas")

else:

stop()

UN PERSONAJE CON MOVIMIENTO POR ESCENARIO ANIMACIONES PERSONALIZADAS ECHAS MANUALMENTE Y UNA CAMARA QUE ABARCA ABSOLUTAMENTE TODO EL ESCENARIO MIENTRAS JUGAMOS

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

EXPLICACION: Fantastico GDScript que mueve un MeshInstance3D que hace como de grua de una camara , la camara es el hijo, a su vez el MeshInstance3D es hijo de un CharacterBody3D.

El CharacterBody3D tiene su propio GDScript para mover al personaje,  y la camara hace una vision de todo el escenario de 360 grados que no se separa del player, puedes mover a tu personaje y darle los movimientos que desees, y a la vez ver todo lo que hay a tu alrrededor moviendo el mouse arrastrandolo de adelante hacia atras  y de izquierda a derecha, para completar esta explicacion pongo tambien el GDScript que lleva el Player protagonista de la escena......

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

extends MeshInstance3D

var rotate_speed_drag_y = 5.44# Sensibilidad de la rotación en Y

var rotate_speed_drag_x = 5.44 # Sensibilidad de la rotación en X

var smoothing_factor = 0.01 # Factor de suavizado (0.0 - 1.0, valores más bajos = más suavizado)

var target_rotation = Vector3()

var last_mouse_position = Vector2()

func _ready():

Input.set_mouse_mode(Input.MOUSE_MODE_VISIBLE)

target_rotation = rotation_degrees # Inicializa la rotación objetivo con la actual

func _process(delta):

var current_mouse_position = get_viewport().get_mouse_position()

var delta_x = current_mouse_position.x - last_mouse_position.x

var delta_y = current_mouse_position.y - last_mouse_position.y

target_rotation.y -= delta_x * rotate_speed_drag_y * 90 * delta # Ajusta la rotación objetivo en Y

target_rotation.x -= delta_y * rotate_speed_drag_x * 90 * delta # Ajusta la rotación objetivo en X

# Aplica el suavizado a la rotación actual

rotation_degrees = lerp(rotation_degrees, target_rotation, smoothing_factor)

last_mouse_position = current_mouse_position

func _input(event):

if event is InputEventMouseMotion:

last_mouse_position = event.position

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

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

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

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

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

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

EXPLICACION: Este GDScript se pone al nodo del personaje es exclusivo de su animacion de movimientos del esqueleto presionando las teclas y botones del mouse..el nodo es hijo del CharacterBody3D.

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

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

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

extends Node3D

var animacion_actual = "MakeHuman default skeleton|REPOSA"

func _ready():

$AnimationPlayer.play(animacion_actual)

func _physics_process(delta):

var alguna_tecla_pulsada = false

# Comprobamos si alguna de las acciones está siendo presionada

if Input.is_action_pressed("achazo") or \

   Input.is_action_pressed("mouse_left") or \

   Input.is_action_pressed("mouse_right") or \

   Input.is_action_pressed("RETUERCE") or \

   Input.is_action_pressed("ANDAALANTECONW") or \

   Input.is_action_pressed("A") or \

   Input.is_action_pressed("D"):

alguna_tecla_pulsada = true

# Animación de ESPADAZO

if Input.is_action_pressed("achazo") or Input.is_action_pressed("mouse_left"):

if animacion_actual != "MakeHuman default skeleton|ATACA":

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

#$AnimationPlayer/AudioStreamPlayer3D.play("MakeHuman default skeleton|ESPADAZO")

animacion_actual = "MakeHuman default skeleton|ATACA"

# Animación de ATRABESAR

elif Input.is_action_pressed("mouse_right") or Input.is_action_pressed("RETUERCE"):

if animacion_actual != "MakeHuman default skeleton|ATACA":

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

animacion_actual = "MakeHuman default skeleton|ATACA"

# Animación de ANDAR

elif Input.is_action_pressed("ANDAALANTECONW") or Input.is_action_pressed("A") or Input.is_action_pressed("D"):

if animacion_actual != "MakeHuman default skeleton|ANDA50":

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

animacion_actual = "MakeHuman default skeleton|ANDA50"

# Si no se presiona ninguna tecla, volvemos a la animación de descanso

elif not alguna_tecla_pulsada:

if animacion_actual != "MakeHuman default skeleton|REPOSA":

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

animacion_actual = "MakeHuman default skeleton|REPOSA"

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

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

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

EXPLICACION: GDScript exclusivo para trasladar y hacer saltar al CharacterBody3D padre de los elementos de los 2 anteriores GDScript

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

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

extends CharacterBody3D

var rotate_speed = 0.1  # Rotation speed

const SPEED = 0.02  # Movement speed

const JUMP_VELOCITY = 0.5  # Jump velocity

var gravity = ProjectSettings.get_setting("physics/3d/default_gravity")

func _ready():

# Replace with function body

pass

func _physics_process(delta):

#translate(Vector3(0,0,-0.01))# PARA UNA CONSTANCIA DE MOVIMIENTO CONTINUO

if not is_on_floor():

velocity.y -= gravity * delta  # Apply gravity

if Input.is_action_just_pressed("ui_accept") and is_on_floor():

velocity.y = JUMP_VELOCITY  # Jump

#var input_dir = Input.get_vector("ui_left", "ui_right", "ui_up", "ui_down")  # Get input direction

var input_dir = Input.get_vector("GIRAIZQUIERDACONA", "GIRADERECHACOND", "ANDAALANTECONW", "ANDAATRASCONS")  #ESTE FUNCIONABA ESTE FUNCIONABA

var direction = (transform.basis * Vector3(input_dir.x, 0, input_dir.y)).normalized()

if direction:

velocity.x = direction.x * SPEED  # Move in X direction

velocity.z = direction.z * SPEED  # Move in Z direction

else:

velocity.x = move_toward(velocity.x, 0, SPEED)  # Stop horizontal movement

velocity.z = move_toward(velocity.z, 0, SPEED)  # Stop vertical movement

move_and_slide()  # Apply movement and collisions

var movimiento_vector = Vector3.ZERO  # Initialize movement vector

#if Input.is_action_pressed("A"):  # Move forward

#rotate_x(0.01)  # Rotate on X axis (negative for down)

#if Input.is_action_pressed("D"):  # Move forward

#rotate_x(0.01)  # Rotate on X axis (negative for down)

if Input.is_action_pressed("giraz"):

rotate_x(0.05)  # Rotate on Z axis (positive for left)

if Input.is_action_pressed("girax"):

rotate_x(-0.05)  # Rotate on Z axis (positive for left)

#elif Input.is_action_pressed("B"):  # Move backward

#rotate_x(-0.01)  # Rotate on X axis (positive for up)

if Input.is_action_pressed("GIRAIZQUIERDACONA"):

rotate_y(0.05)  # Rotate on Z axis (positive for left)

if Input.is_action_pressed("GIRADERECHACOND"):

rotate_y(-0.05)  # Rotate on Z axis (negative for right)

#translate(Vector3(0.05,0,0))

if Input.is_action_pressed("ANDAALANTECONW"):

translate(Vector3(0.00,0,0.0004))

rotate_y(-0.00)

if Input.is_action_pressed("ANDAATRASCONS"):

translate(Vector3(0.00,0,-0.0004))

rotate_y(-0.00)

# Rotación vertical con la rueda del ratón

if Input.is_action_pressed("rodarriba"):

print("rodarriba activado")  # Añadido para depurar

rotate_x(-rotate_speed)

if Input.is_action_pressed("rodavajo"):

print("rodavajo activado")  # Añadido para depurar

rotate_x(rotate_speed)

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

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

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

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

RESUMEN: -1-UN CharacterBody3D CON SU PROPIO GDSCRIPT PADRE.

                      -2- UN NODO CON EL PLAYER CON SU PROPIO GDSCRIPT HIJO.

                       -3-UN  MeshInstance3D QUE CONTIENE LA CAMARA  CON SU PROPIO         

                         GDSCRIPT HIJO.

RESULTADO TENEMOS UN PERSONAJE CON MOVIMIENTO POR ESCENARIO ANIMACIONES PERSONALIZADAS ECHAS MANUALMENTE Y UNA CAMARA QUE ABARCA ABSOLUTAMENTE TODO EL ESCENARIO MIENTRAS JUGAMOS

Ejemplo de CharacterBody3D con Godot ;

Ejemplo de CharacterBody3D con Godot ; camina salta y mira con la rueda del raton las teclas -w-a-s-d espacion y las flechas del teclado numerico, este juego esta en desarrollo y en 1 o 2 meses lo pondre en perico415 - itch.io
 

swords-lady-and-blood;

 

GDScript camara3d se traslada a unas coordenadas especificas en unos segundos y despues en otros segundos transcurridos se borra;Godot 4.4;

 extends Camera3D

var tiempo_transcurrido: float = 0.0

var tiempo_para_trasladar: float = 21.0

var tiempo_para_borrar_despues_traslado: float = 5.0

var trasladada: bool = false

var coordenadas_destino: Vector3 = Vector3(-23.386, 108.385, -14.401)

func _process(delta: float) -> void:

tiempo_transcurrido += delta

if !trasladada:

if tiempo_transcurrido >= tiempo_para_trasladar:

global_transform.origin = coordenadas_destino

trasladada = true

tiempo_transcurrido = 0.0 # Reiniciamos el tiempo para la cuenta del borrado

else:

if tiempo_transcurrido >= tiempo_para_borrar_despues_traslado:

queue_free()

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

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

Explicacion: muy util para hacer cambios de camara de puntos de vista y enfocar por varios puntos de la escena del juego, en mi juego actual la camara cae por una torre, esta asociada a un RigidBody3D cae lentamente visionando la altura de una torre mediebal, y cuando llega al suelo enfoca lo alto de la torre un primer plano de una princesa prisionera, al pasar unos segundo se borra la camara definitivamente y utiliza la del player para seguir jugando, la que esta activada con el (current).

En el GDScript inferior ademas añade la inclinacion de rotacion del eje Y de la camara....tambien se puede variar......

extends Camera3D

var tiempo_transcurrido: float = 0.0

var tiempo_para_trasladar: float = 21.0

var tiempo_para_borrar_despues_traslado: float = 5.0

var trasladada: bool = false

var coordenadas_destino: Vector3 = Vector3(-23.386, 108.385, -14.401)

var rotacion_destino_y: float = 0.14

func _process(delta: float) -> void:

tiempo_transcurrido += delta

if !trasladada:

if tiempo_transcurrido >= tiempo_para_trasladar:

global_transform.origin = coordenadas_destino

# Establecemos la rotación en el eje Y

rotation.y = rotacion_destino_y

trasladada = true

tiempo_transcurrido = 0.0 # Reiniciamos el tiempo para la cuenta del borrado

else:

if tiempo_transcurrido >= tiempo_para_borrar_despues_traslado:

queue_free()

Con Godot 4.4 se borra en unos segundos la camara3d y hace tambien efecto de zoom;

 extends Camera3D

@export var zoom_velocidad: float = 10.0 # Velocidad a la que cambia el zoom

@export var zoom_minimo: float = 10.0 # FOV mínimo

@export var zoom_maximo: float = 300.0 # FOV máximo

var acercando: bool = true

var tiempo_transcurrido: float = 0.0

var tiempo_para_borrar: float = 10.0

func _process(delta: float) -> void:

if acercando:

fov -= zoom_velocidad * delta

if fov <= zoom_minimo:

fov = zoom_minimo

acercando = false

else:

fov += zoom_velocidad * delta

if fov >= zoom_maximo:

fov = zoom_maximo

acercando = true

tiempo_transcurrido += delta

if tiempo_transcurrido >= tiempo_para_borrar:

queue_free()

Con Godot 4.4 emite sonido al presionar boton izquierdo del raton; en GDScript;

 extends AudioStreamPlayer3D

@export var boton_accion: String = "mouse_left" # Acción del input a escuchar (por defecto: mouse_left)

@export var distancia_maxima: float = 20.0 # Distancia máxima para escuchar el sonido

func _ready():

max_distance = distancia_maxima

func _input(event):

if event is InputEventMouseButton:

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

play()

GDScript Godot 4.4 animaciones perfectas de reposo andar y ataque;

 extends Node3D

var animacion_actual = "MakeHuman default skeleton|DESCANSO"

func _ready():

$AnimationPlayer.play(animacion_actual)

func _physics_process(delta):

var alguna_tecla_pulsada = false

# Comprobamos si alguna de las acciones está siendo presionada

if Input.is_action_pressed("achazo") or \

   Input.is_action_pressed("mouse_left") or \

   Input.is_action_pressed("mouse_right") or \

   Input.is_action_pressed("RETUERCE") or \

   Input.is_action_pressed("ANDAALANTECONW") or \

   Input.is_action_pressed("A") or \

   Input.is_action_pressed("D"):

alguna_tecla_pulsada = true

# Animación de ESPADAZO

if Input.is_action_pressed("achazo") or Input.is_action_pressed("mouse_left"):

if animacion_actual != "MakeHuman default skeleton|ESPADAZO":

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

animacion_actual = "MakeHuman default skeleton|ESPADAZO"

# Animación de ATRABESAR

elif Input.is_action_pressed("mouse_right") or Input.is_action_pressed("RETUERCE"):

if animacion_actual != "MakeHuman default skeleton|ATRABESAR":

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

animacion_actual = "MakeHuman default skeleton|ATRABESAR"

# Animación de ANDAR

elif Input.is_action_pressed("ANDAALANTECONW") or Input.is_action_pressed("A") or Input.is_action_pressed("D"):

if animacion_actual != "MakeHuman default skeleton|ANDAR":

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

animacion_actual = "MakeHuman default skeleton|ANDAR"

# Si no se presiona ninguna tecla, volvemos a la animación de descanso

elif not alguna_tecla_pulsada:

if animacion_actual != "MakeHuman default skeleton|DESCANSO":

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

animacion_actual = "MakeHuman default skeleton|DESCANSO"

GDScript , instancia borra enemigo por tiempo, cambia un $CollisionShape3D2.translate(Vector3(0, 1111, 0));

 extends Area3D

# var Esferauno = preload("res://PERSONAJES MACABROS/ARAÑA/EXPLOTADA ARAÑA.tscn")

var Esferauno = preload("res://ENEMIGO MUERTO/ene_5enemigo_muerto-4-.tscn")

# var EsferaDOS = preload("res://CONSTRUCCIONES/rigid_body_3d_piedra_cae-3-.tscn")

# Called when the node enters the scene tree for the first time.

func _ready() -> void:

pass # Replace with function body.

# Called every frame. 'delta' is the elapsed time since the previous frame.

func _process(delta: float) -> void:

# translate(Vector3(0,0,-0.001))

pass

func _on_area_entered(area: Area3D) -> void:

var parent = get_parent()

var CollisionShape3Dcubo = parent.get_node("$CollisionShape3D2")

var esfera_uno_instancia = Esferauno.instantiate()

add_child(esfera_uno_instancia)

# $"." .queue_free()

#$CollisionShape3D2.queue_free()

$CollisionShape3D2.translate(Vector3(0, 1111, 0))

pass # Replace with function body.

func _on_area_exited(area: Area3D) -> void:

# $"." .queue_free()

call_deferred("_delayed_queue_free")

pass # Replace with function body.

func _delayed_queue_free():

await get_tree().create_timer(5.9).timeout

if is_instance_valid(self):

queue_free()

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

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

Explicacion: Desarrollando nuevo juego me encuentro con dificultades al destruir enemigos e instanciar la replica del mismo con otra animacion simulando su muerte, e de consultar constantemenete a la IA de programacion y e de hacer yo mismo cambios en los GDScript, por problemas y BUGS, en este caso parece logre una solucion con esta linea y moviendo en eje "y" hacia arriba un $CollisionShape3D2.translate(Vector3(0, 1111, 0))-----un CollisionShape3D2---- que me hacia bloquear el juego, al cambiarlo por un $CollisionShape3D2.translate(Vector3(0, 1111, 0)) me quitaba el problema de bloquear el juego y la linea original esta de aqui----$CollisionShape3D2.queue_free()----me lo bloqueba, seguramente es una chapuza pero si me resuelve el problema y el juego rueda con la solucion pues fenomeno.

MUMMIES, CORRIDORS AND GORE;

  MUMMIES, CORRIDORS AND GORE

Estas en el interior de una pirámide egipcia, has profanado a los faraones y sus tesoros, ahora paga las consecuencias, huye¡¡ huye¡¡ huye¡¡ sal de la pirámide y ganaras el juego¡¡.

649 MB ocupa el juego en disco duro, para windows.

GDScript para Godot 4.4 hace animaciones al presionar teclas , traslada al personaje por si solo en uno de sus ejes y a los 20 segundos lo borra;

 extends Node3D

var animacion_actual = "Default simplified|GRITANDO"

var animacion_idle = "Default simplified|GRITANDO" # ANIMACION DE ESTAR QUIETO

var velocidad_traslacion = 90.5

var tiempo_vida = 20.0

var tiempo_transcurrido: float = 0.0

func _ready():

$AnimationPlayer.play(animacion_actual)

pass

func _physics_process(delta):

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

tiempo_transcurrido += delta

if tiempo_transcurrido >= tiempo_vida:

queue_free() # Borra el nodo de forma segura

var alguna_tecla_pulsada = false

if Input.is_action_pressed("ui_accept") or \

   Input.is_action_pressed("mouse_left") or \

   Input.is_action_pressed("luzcasco") or \

   Input.is_action_pressed("ANDAATRASCONS") or \

   Input.is_action_pressed("ANDAALANTECONW") or \

   Input.is_action_pressed("ANDAALNTECONE") or \

   Input.is_action_pressed("GIRADERECHACOND") or \

   Input.is_action_pressed("A") or \

   Input.is_action_pressed("D"):

alguna_tecla_pulsada = true

if alguna_tecla_pulsada:

# Agacharse (al presionar "luzcasco")

if Input.is_action_just_pressed("luzcasco"):

if animacion_actual != "Default simplified|ANDAR":

$AnimationPlayer.play("Default simplified|ANDAR")

animacion_actual = "Default simplified|ANDAR"

# Volver a correr (al soltar "mouse_left")

if Input.is_action_just_released("mouse_left"):

if animacion_actual != "Default simplified|correr":

$AnimationPlayer.play("Default simplified|correr")

animacion_actual = "Default simplified|correr"

# Andar hacia atrás (al presionar "ANDAATRASCONS")

if Input.is_action_just_pressed("ANDAATRASCONS"):

if animacion_actual != "Default simplified|correr":

$AnimationPlayer.play("Default simplified|correr")

animacion_actual = "Default simplified|correr"

# Volver a andar normal (al presionar "ANDAALANTECONW")

if Input.is_action_just_pressed("ANDAALANTECONW"):

if animacion_actual != "Default simplified|correr":

$AnimationPlayer.play("Default simplified|correr")

animacion_actual = "Default simplified|correr"

# Volver a andar normal (al soltar "ANDAALANTECONW")

if Input.is_action_just_released("ANDAALANTECONW"):

if animacion_actual != "Default simplified|GRITAR":

$AnimationPlayer.play("Default simplified|GRITAR")

animacion_actual = "Default simplified|GRITAR"

# Otra acción para correr (al presionar "ANDAALNTECONE")

if Input.is_action_just_pressed("ANDAALNTECONE"):

if animacion_actual != "Default simplified|correr":

$AnimationPlayer.play("Default simplified|correr")

animacion_actual = "Default simplified|correr"

# Volver a gritar (al soltar "GIRADERECHACOND")

if Input.is_action_just_released("GIRADERECHACOND"):

if animacion_actual != "Default simplified|GRITANDO":

$AnimationPlayer.play("Default simplified|GRITANDO")

animacion_actual = "Default simplified|GRITANDO"

# Correr con "A" (al presionar)

if Input.is_action_just_pressed("A"):

if animacion_actual != "Default simplified|correr":

$AnimationPlayer.play("Default simplified|correr")

animacion_actual = "Default simplified|correr"

# Gritar con "A" (al soltar)

if Input.is_action_just_released("A"):

if animacion_actual != "Default simplified|GRITAR":

$AnimationPlayer.play("Default simplified|GRITAR")

animacion_actual = "Default simplified|GRITAR"

# Correr con "D" (al presionar)

if Input.is_action_just_pressed("D"):

if animacion_actual != "Default simplified|correr":

$AnimationPlayer.play("Default simplified|correr")

animacion_actual = "Default simplified|correr"

# Correr con "D" (al soltar) - REVISA ESTA LÓGICA

if Input.is_action_just_released("D"):

if animacion_actual != "Default simplified|GRITAR":

$AnimationPlayer.play("Default simplified|GRITAR")

animacion_actual = "Default simplified|GRITAR"

else:

# Si no se presiona ninguna tecla, reproduce la animación de estar quieto

if animacion_actual != animacion_idle:

$AnimationPlayer.play(animacion_idle)

animacion_actual = animacion_idle

Extends MeshInstance2D lo mueve mediante GDScript en Godot 4.4;

 extends MeshInstance2D

@export var velocidad_desplazamiento = 50.0 # Píxeles por segundo

@export var distancia_total = 1300.0

@export var tiempo_vida = 235.0

var tiempo_transcurrido = 0.0

var distancia_recorrida = 0.0

func _ready():

var viewport_rect = get_viewport_rect()

position = Vector2(viewport_rect.size.x / 2, -50) # Posición inicial arriba

func _process(delta):

position.y += velocidad_desplazamiento * delta

distancia_recorrida += velocidad_desplazamiento * delta

tiempo_transcurrido += delta

if distancia_recorrida >= distancia_total:

queue_free()

return

if tiempo_transcurrido >= tiempo_vida:

queue_free()

Resumen de lo aprendido ultimamente en Godot 4.4;

 

Resumen de lo aprendido ultimamente en Godot 4.4:

-1-Utilizar la IA para programacion.

-2- La IA apoyo complemento en generar graficos.

-3-Persecucion de enemigos.

-4-Generar barra de vida.

Ejemplo de IA persecucion de enemigos con Godot 4.4; Y GDScript que corrige que el enemigo mientras persige, no lo aga de espaldas;

 

Ejemplo de IA persecucion de enemigos con Godot 4.4;

extends CharacterBody3D

const SPEED = 9.0

const ACCELERATION = 8.5 # Ajusta este valor para la velocidad de respuesta deseada

@onready var navAgent = $NavigationAgent3D

#@onready var target = $"../Player" # Descomenta esta línea si tu jugador se llama "Player"

@onready var target = $"../CharacterBody3D" # Asegúrate de que esta ruta sea correcta para tu jugador

func _physics_process(delta: float) -> void:

# Elimina o comenta la rotación manual si quieres que siempre mire al objetivo

# rotate_y(0.11)

# Añadir gravedad.

if not is_on_floor():

velocity += get_gravity() * delta

if target: # Verifica si el objetivo existe

_update_target_position() # Actualiza la posición del objetivo primero

var currentLocation = global_transform.origin

var nextLocation = navAgent.get_next_path_position()

var nextVelocity = (nextLocation - currentLocation).normalized() * SPEED

velocity = velocity.move_toward(nextVelocity, ACCELERATION * delta) # Usa delta para suavizar la aceleración

move_and_slide()

# Orientar al enemigo hacia la dirección del movimiento (siguiente punto de la ruta)

if nextVelocity.length_squared() > 0.01: # Evita rotaciones cuando no hay movimiento significativo

look_at(global_transform.origin + nextVelocity, Vector3.UP)

else:

print("El objetivo (jugador) no existe.")

func _update_target_position():

if target:

navAgent.target_position = target.global_transform.origin

else:

print("El objetivo (jugador) no existe. No se puede actualizar la posición del NavigationAgent.")

s

solucinado el tema de que persigan de frente y no de espaldas

Ejemplo de animar por GDScript en Godot 4.4.;

 extends Node3D

var animacion_actual = "Default simplified|GRITANDO"

var animacion_idle = "Default simplified|GRITANDO" # ANIMACION DE ESTAR QUIETO

func _ready():

$AnimationPlayer.play(animacion_actual)

pass

func _physics_process(delta):

var alguna_tecla_pulsada = false

if Input.is_action_pressed("ui_accept") or \

   Input.is_action_pressed("mouse_left") or \

   Input.is_action_pressed("luzcasco") or \

   Input.is_action_pressed("ANDAATRASCONS") or \

   Input.is_action_pressed("ANDAALANTECONW") or \

   Input.is_action_pressed("ANDAALNTECONE") or \

   Input.is_action_pressed("GIRADERECHACOND") or \

   Input.is_action_pressed("A") or \

   Input.is_action_pressed("D"):

alguna_tecla_pulsada = true

if alguna_tecla_pulsada:

# Agacharse (al presionar "luzcasco")

if Input.is_action_just_pressed("luzcasco"):

if animacion_actual != "Default simplified|ANDAR":

$AnimationPlayer.play("Default simplified|ANDAR")

animacion_actual = "Default simplified|ANDAR"

# Volver a correr (al soltar "mouse_left")

if Input.is_action_just_released("mouse_left"):

if animacion_actual != "Default simplified|correr":

$AnimationPlayer.play("Default simplified|correr")

animacion_actual = "Default simplified|correr"

# Andar hacia atrás (al presionar "ANDAATRASCONS")

if Input.is_action_just_pressed("ANDAATRASCONS"):

if animacion_actual != "Default simplified|correr":

$AnimationPlayer.play("Default simplified|correr")

animacion_actual = "Default simplified|correr"

# Volver a andar normal (al soltar "ANDAALANTECONW")

if Input.is_action_just_released("ANDAALANTECONW"):

if animacion_actual != "Default simplified|ANDAR":

$AnimationPlayer.play("Default simplified|ANDAR")

animacion_actual = "Default simplified|ANDAR"

# Otra acción para correr (al presionar "ANDAALNTECONE")

if Input.is_action_just_pressed("ANDAALNTECONE"):

if animacion_actual != "Default simplified|correr":

$AnimationPlayer.play("Default simplified|correr")

animacion_actual = "Default simplified|correr"

# Volver a gritar (al soltar "GIRADERECHACOND")

if Input.is_action_just_released("GIRADERECHACOND"):

if animacion_actual != "Default simplified|GRITANDO":

$AnimationPlayer.play("Default simplified|GRITANDO")

animacion_actual = "Default simplified|GRITANDO"

# Correr con "A" (al presionar)

if Input.is_action_just_pressed("A"):

if animacion_actual != "Default simplified|correr":

$AnimationPlayer.play("Default simplified|correr")

animacion_actual = "Default simplified|correr"

# Gritar con "A" (al soltar)

if Input.is_action_just_released("A"):

if animacion_actual != "Default simplified|GRITAR":

$AnimationPlayer.play("Default simplified|GRITAR")

animacion_actual = "Default simplified|GRITAR"

# Correr con "D" (al presionar)

if Input.is_action_just_pressed("D"):

if animacion_actual != "Default simplified|correr":

$AnimationPlayer.play("Default simplified|correr")

animacion_actual = "Default simplified|correr"

# Correr con "D" (al soltar) - REVISA ESTA LÓGICA

if Input.is_action_just_released("D"):

if animacion_actual != "Default simplified|correr":

$AnimationPlayer.play("Default simplified|correr")

animacion_actual = "Default simplified|correr"

else:

# Si no se presiona ninguna tecla, reproduce la animación de estar quieto

if animacion_actual != animacion_idle:

$AnimationPlayer.play(animacion_idle)

animacion_actual = animacion_idle

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

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

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

ejemplo.2

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

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

extends Node3D

var animacion_actual = "Default simplified|GRITANDO"

var animacion_idle = "Default simplified|GRITANDO" # ANIMACION DE ESTAR QUIETO

func _ready():

$AnimationPlayer.play(animacion_actual)

pass

func _physics_process(delta):

var alguna_tecla_pulsada = false

if Input.is_action_pressed("ui_accept") or \

   Input.is_action_pressed("mouse_left") or \

   Input.is_action_pressed("luzcasco") or \

   Input.is_action_pressed("ANDAATRASCONS") or \

   Input.is_action_pressed("ANDAALANTECONW") or \

   Input.is_action_pressed("ANDAALNTECONE") or \

   Input.is_action_pressed("GIRADERECHACOND") or \

   Input.is_action_pressed("A") or \

   Input.is_action_pressed("D"):

alguna_tecla_pulsada = true

if alguna_tecla_pulsada:

# Agacharse (al presionar "luzcasco")

if Input.is_action_just_pressed("luzcasco"):

if animacion_actual != "Default simplified|ANDAR":

$AnimationPlayer.play("Default simplified|ANDAR")

animacion_actual = "Default simplified|ANDAR"

# Volver a correr (al soltar "mouse_left")

if Input.is_action_just_released("mouse_left"):

if animacion_actual != "Default simplified|correr":

$AnimationPlayer.play("Default simplified|correr")

animacion_actual = "Default simplified|correr"

# Andar hacia atrás (al presionar "ANDAATRASCONS")

if Input.is_action_just_pressed("ANDAATRASCONS"):

if animacion_actual != "Default simplified|correr":

$AnimationPlayer.play("Default simplified|correr")

animacion_actual = "Default simplified|correr"

# Volver a andar normal (al presionar "ANDAALANTECONW")

if Input.is_action_just_pressed("ANDAALANTECONW"):

if animacion_actual != "Default simplified|correr":

$AnimationPlayer.play("Default simplified|correr")

animacion_actual = "Default simplified|correr"

# Volver a andar normal (al soltar "ANDAALANTECONW")

if Input.is_action_just_released("ANDAALANTECONW"):

if animacion_actual != "Default simplified|GRITAR":

$AnimationPlayer.play("Default simplified|GRITAR")

animacion_actual = "Default simplified|GRITAR"

# Otra acción para correr (al presionar "ANDAALNTECONE")

if Input.is_action_just_pressed("ANDAALNTECONE"):

if animacion_actual != "Default simplified|correr":

$AnimationPlayer.play("Default simplified|correr")

animacion_actual = "Default simplified|correr"

# Volver a gritar (al soltar "GIRADERECHACOND")

if Input.is_action_just_released("GIRADERECHACOND"):

if animacion_actual != "Default simplified|GRITANDO":

$AnimationPlayer.play("Default simplified|GRITANDO")

animacion_actual = "Default simplified|GRITANDO"

# Correr con "A" (al presionar)

if Input.is_action_just_pressed("A"):

if animacion_actual != "Default simplified|correr":

$AnimationPlayer.play("Default simplified|correr")

animacion_actual = "Default simplified|correr"

# Gritar con "A" (al soltar)

if Input.is_action_just_released("A"):

if animacion_actual != "Default simplified|GRITAR":

$AnimationPlayer.play("Default simplified|GRITAR")

animacion_actual = "Default simplified|GRITAR"

# Correr con "D" (al presionar)

if Input.is_action_just_pressed("D"):

if animacion_actual != "Default simplified|correr":

$AnimationPlayer.play("Default simplified|correr")

animacion_actual = "Default simplified|correr"

# Correr con "D" (al soltar) - REVISA ESTA LÓGICA

if Input.is_action_just_released("D"):

if animacion_actual != "Default simplified|GRITAR":

$AnimationPlayer.play("Default simplified|GRITAR")

animacion_actual = "Default simplified|GRITAR"

else:

# Si no se presiona ninguna tecla, reproduce la animación de estar quieto

if animacion_actual != animacion_idle:

$AnimationPlayer.play(animacion_idle)

animacion_actual = animacion_idle