GDScript para Godot 4.6.3 para CharacterBody3D, animaciones muy correctas; resuelve se mueva de su sitio con los pies quietos;

 extends CharacterBody3D

var rotate_speed = 0.001

@export var SPEED: float = 3.0  # Velocidad normal de caminar

#const SPEED = 3.0  # Velocidad normal de caminar

const RUN_SPEED = 10.0  # Velocidad más alta para correr

const JUMP_VELOCITY = 2.5

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

# --- NUEVAS VARIABLES PARA EL GIRO SUAVE ---

var velocidad_giro_actual = 0.0

@export var velocidad_maxima_giro: float = 0.35

#var velocidad_maxima_giro = 0.35

var suavizado_giro = 0.01

# -------------------------------------------

func _ready():

pass

func _physics_process(delta):

# Gravedad, siempre activa

if not is_on_floor():

velocity.y -= gravity * delta

# El salto se activa al mantener pulsado

if Input.is_action_pressed("ui_accept"):

velocity.y = JUMP_VELOCITY

# Lógica de movimiento normal

var current_speed = SPEED

var direction = Vector3.ZERO

# 1. Calculamos la dirección como si todo funcionara normal

if Input.is_action_pressed("CORRECACA"):

direction = -transform.basis.z 

current_speed = RUN_SPEED

else:

# Nota: Usamos solo el eje vertical (Y) del vector para caminar adelante/atrás

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

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

current_speed = SPEED

# 2. EL FILTRO DE SEGURIDAD ABSOLUTO: 

# Si en este preciso instante están las dos pulsadas, anulamos la velocidad inmediatamente

#if Input.is_action_pressed("ANDAALANTECONW") and Input.is_action_pressed("mouse_right"):

if Input.is_action_pressed("ANDAALANTECONW") and (Input.is_action_pressed("mouse_right") or Input.is_action_pressed("mouse_left")):

velocity.x = 0.0

velocity.z = 0.0

else:

# Si no se cumple la combinación, aplicamos el movimiento que calculamos antes

if direction:

velocity.x = direction.x * current_speed

velocity.z = direction.z * current_speed

else:

velocity.x = move_toward(velocity.x, 0, current_speed)

velocity.z = move_toward(velocity.z, 0, current_speed)

move_and_slide()

# --- LÓGICA DE GIRO SUAVE ---

var direccion_giro = 0.0

if Input.is_action_pressed("GIRAIZQUIERDACONA"):

direccion_giro += 0.5

if Input.is_action_pressed("GIRADERECHACOND"):

direccion_giro -= 0.5

# Calculamos el objetivo y suavizamos la velocidad

var objetivo = direccion_giro * velocidad_maxima_giro

velocidad_giro_actual = lerp(velocidad_giro_actual, objetivo, suavizado_giro)

# Aplicamos la rotación suave

rotate_y(velocidad_giro_actual)

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

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

Explicacion: Este GDScript, funciona muy bien alternando al disparar o al lanzar granadas el personaje, que no se mueva de su sitio con los pies quietos, un error que quedaba muy feo y este GDS lo resuelve; Tenia el problema que si presionaba -w-w que es para avanzar y caminar el personaje avanzaba de todas formas si estaba disparando con los pies parados o si lanzaba bomba de mano con los pies parados......

Te gusta algo del bloc? ¡¡apoyame con un cafe!! ¡¡gracias!!

Do you like anything on the blog? Support me with a coffee!! Thank you!!

GDSscript para Godot 4.6.3; maneja al CharacterBody3D para que camine y si dispara se detenga;

 extends CharacterBody3D

var rotate_speed = 0.001

@export var SPEED: float = 3.0  # Velocidad normal de caminar

#const SPEED = 3.0  # Velocidad normal de caminar

const RUN_SPEED = 10.0  # Velocidad más alta para correr

const JUMP_VELOCITY = 2.5

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

# --- NUEVAS VARIABLES PARA EL GIRO SUAVE ---

var velocidad_giro_actual = 0.0

@export var velocidad_maxima_giro: float = 0.35

#var velocidad_maxima_giro = 0.35

var suavizado_giro = 0.01

# -------------------------------------------

func _ready():

pass

func _physics_process(delta):

# Gravedad, siempre activa

if not is_on_floor():

velocity.y -= gravity * delta

# El salto se activa al mantener pulsado

if Input.is_action_pressed("ui_accept"):

velocity.y = JUMP_VELOCITY

# Lógica de movimiento normal

var current_speed = SPEED

var direction = Vector3.ZERO

# 1. Calculamos la dirección como si todo funcionara normal

if Input.is_action_pressed("CORRECACA"):

direction = -transform.basis.z 

current_speed = RUN_SPEED

else:

# Nota: Usamos solo el eje vertical (Y) del vector para caminar adelante/atrás

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

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

current_speed = SPEED

# 2. EL FILTRO DE SEGURIDAD ABSOLUTO: 

# Si en este preciso instante están las dos pulsadas, anulamos la velocidad inmediatamente

if Input.is_action_pressed("ANDAALANTECONW") and Input.is_action_pressed("mouse_right"):

velocity.x = 0.0

velocity.z = 0.0

else:

# Si no se cumple la combinación, aplicamos el movimiento que calculamos antes

if direction:

velocity.x = direction.x * current_speed

velocity.z = direction.z * current_speed

else:

velocity.x = move_toward(velocity.x, 0, current_speed)

velocity.z = move_toward(velocity.z, 0, current_speed)

move_and_slide()

# --- LÓGICA DE GIRO SUAVE ---

var direccion_giro = 0.0

if Input.is_action_pressed("GIRAIZQUIERDACONA"):

direccion_giro += 0.5

if Input.is_action_pressed("GIRADERECHACOND"):

direccion_giro -= 0.5

# Calculamos el objetivo y suavizamos la velocidad

var objetivo = direccion_giro * velocidad_maxima_giro

velocidad_giro_actual = lerp(velocidad_giro_actual, objetivo, suavizado_giro)

# Aplicamos la rotación suave

rotate_y(velocidad_giro_actual)

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

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

Explicacion;   GDSscript para Godot 4.6.3; maneja al CharacterBody3D para que camine y si dispara se detenga;  El problema que tenia era que cuando disparaba y estaba con los pies quietos el personaje del juego seguia avanzando, este GDS resuelve que al presionar el disparo automaticamente aunque este presionada la tecla de avanzar la "W" el personaje se para en su sitio.....y si sueltas la tecla del boton derecho del mouse, automaticamente anda y avanza al estar presionada claro la tecla "W" de avanzar y animacion caminar, estre gds esta combinado con otro de animaciones exclusivas del personaje,,,,,,es bastante lioso combinar varios conceptos,  yo me ayudo de la IA si no no podria ni hacer ni entender......

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.