sábado, 30 de mayo de 2026

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......

miércoles, 27 de mayo de 2026

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.......

domingo, 24 de mayo de 2026

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

viernes, 22 de mayo de 2026

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?

martes, 19 de mayo de 2026

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.

domingo, 17 de mayo de 2026

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.

miércoles, 13 de mayo de 2026

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!!!