Instanciar un objeto con GDScript para Godot 4.6.3; y desistanciarlo;

 extends Area3D

# 1. Al usar @export, la escena aparecerá en el Inspector a la derecha.

# Podrás arrastrar el archivo .tscn que quieras meter desde tu Sistema de Archivos.

@export var escena_a_instanciar: PackedScene

# 2. Variable para recordar el elemento que hemos creado y poder borrarlo luego

var elemento_actual: Node = null

# SEÑAL 1: Al entrar en el área, fabricamos el elemento

func _on_area_entered(area: Area3D) -> void:

# Comprobamos si has arrastrado alguna escena en el Inspector

if escena_a_instanciar == null:

print("⚠️ ¡Aviso! No has arrastrado ninguna escena en el Inspector de este Area3D")

return

# ¡Instanciamos el elemento en la memoria!

elemento_actual = escena_a_instanciar.instantiate()

# Lo añadimos al mapa

get_parent().add_child(elemento_actual)

# Lo colocamos en la posición exacta de este Area3D

if elemento_actual is Node3D:

elemento_actual.global_position = self.global_position

# SEÑAL 2: Al salir del área, lo borramos de golpe

func _on_area_exited(area: Area3D) -> void:

# Si el elemento existe en el juego, le metemos el tijeretazo

if is_instance_valid(elemento_actual):

elemento_actual.queue_free()  # Lo elimina por completo de la pantalla y la memoria

elemento_actual = null        # Vaciamos la variable para el siguiente toque

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

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

Explicacion. : Este GDScript sirve para que un Area3d con su colisionador, al toparse con otro Area3d y otro colisionador instancie un elemento en escena en este caso un baston, al retirarse desaparece el baston.....lo bueno de este GDscript esque puedes arrastrar al inpector el elemento que quieras se instancie....una  tscn  una escena.....@export var escena_a_instanciar: PackedScene

GDScript para Godot 4.6.3; manejo de un Node3d; Personaje se mueve por pantalla; flechas del teclado y teclas -m-n;

 extends Node3D

# Velocidad a la que se moverá el objeto (puedes cambiarla desde el Inspector)

@export var velocidad: float = 5.0

func _process(delta: float) -> void:

# 1. Creamos un vector para almacenar la dirección del movimiento

var direccion: Vector3 = Vector3.ZERO

# 2. Detectamos si se presionan las flechas del teclado (Movimiento horizontal)

if Input.is_key_pressed(KEY_UP):

direccion.z -= 1.0  # Mueve hacia adelante

if Input.is_key_pressed(KEY_DOWN):

direccion.z += 1.0  # Mueve hacia atrás

if Input.is_key_pressed(KEY_LEFT):

direccion.x -= 1.0  # Mueve hacia la izquierda

if Input.is_key_pressed(KEY_RIGHT):

direccion.x += 1.0  # Mueve hacia la derecha

# 3. NUEVAS TECLAS: Control de altura en el eje Y

if Input.is_key_pressed(KEY_N):

direccion.y += 1.0  # Asciende (Sube)

if Input.is_key_pressed(KEY_M):

direccion.y -= 1.0  # Desciende (Baja)

# 4. Si se está pulsando alguna tecla, movemos el objeto

if direccion != Vector3.ZERO:

# Normalizamos el vector para que no vaya más rápido al moverse en diagonal

direccion = direccion.normalized()

# Aplicamos el movimiento teniendo en cuenta la velocidad y el tiempo (delta)

global_translate(direccion * velocidad * delta)

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

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

Explicacion: Un personaje en 3d lo volamos por el escenario,,,, teclas -m-n lo vajan y lo suben por su eje de coordenadas "Y" que va de arriva  abajo, y teclas flechas del teclado del pc, lo mueven por sus cordenadas "z" y "x"  izquierda a derecha adelante atras,   tenemos el detalle del   @export var velocidad: float = 5.0    que sirve para desde el inspector del motor de juegos Godot 4.6.3 variar la velocidad de su movimiento, sin tener que tocar el GDScript

Enlaces a mis juegos; casi todos para adultos;

 https://perico415.itch.io/tasty-baked-carrot

https://perico415.itch.io/a10-y-a30

https://perico415.itch.io/dance-ballerina

https://perico415.itch.io/dos-melones

https://perico415.itch.io/gush-of-pleasure

https://perico415.itch.io/invaded-butt

https://perico415.itch.io/tasty-baked-carrot

https://perico415.itch.io/the-hoop-and-your-butt

https://perico415.itch.io/the-unveiling

https://perico415.itch.io/vestida-desnuda

https://perico415.itch.io/tolon-tolon

https://perico415.itch.io/goza-moza

Te gusta mi trabajo? invitame a un cafe para poder seguir desarrollando...

Do you like my work? Buy me a coffee so I can keep developing it...

https://ko-fi.com/perico415

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