JUEGA ¡¡YA!!;

 

GDScript de borrar Area3d y manipular label;

 extends Area3D

@export_category("Control de Interfaz")

# Arrastra aquí tu nodo HSlider desde el Inspector

@export var slider_control: HSlider

# Arrastra aquí tu nodo Label2 (el del texto grande de victoria)

@export var mensaje_victoria: Label

# Arrastra aquí tu nodo Label3 (el del texto grande de derrota/game over)

@export var mensaje_derrota: Label

@export_category("Eliminar Suelo al Ganar")

# Arrastra aquí el Area3DSuelo desde el árbol de escenas para borrarlo al ganar

@export var area_suelo_a_borrar: Area3D

@export_category("Configuración del Retraso")

# ¿Quieres que el texto tarde un poco en aparecer? Actívalo o desactívalo

@export var usar_retraso: bool = true

# Tiempo de espera en segundos antes de mostrar el cartel de victoria

@export var tiempo_espera_segundos: float = 2.0

@export_category("Movimiento Lateral")

# Velocidad a la que se desplaza con las flechas en el eje Z

@export var velocidad_movimiento: float = 5.0

# Distancia máxima (en metros) que se puede alejar de su centro en Z

@export var distancia_maxima: float = 3.0

# Variable para recordar la posición Z inicial configurada en el editor

var posicion_inicial_z: float = 0.0 

func _ready() -> void:

# Guardamos el valor de Z del editor al arrancar

posicion_inicial_z = position.z 

# Nos aseguramos de que los textos empiecen OCULTOS al iniciar la partida

if mensaje_victoria:

mensaje_victoria.visible = false

else:

push_warning("¡Aviso! No has arrastrado el Label de victoria al script de la colchoneta.")

if mensaje_derrota:

mensaje_derrota.visible = false

# Conectamos la señal para detectar cuándo entra un cuerpo (el suicida) en el área

body_entered.connect(_on_body_entered)

# Calibramos el HSlider por código

if slider_control:

slider_control.min_value = -distancia_maxima

slider_control.max_value = distancia_maxima

slider_control.step = 0.01

slider_control.value = 0.0 

slider_control.value_changed.connect(_on_slider_value_changed)

func _process(delta: float) -> void:

var direccion: float = 0.0

if Input.is_action_pressed("ui_right"):

direccion += 1.0

if Input.is_action_pressed("ui_left"):

direccion -= 1.0

if direccion != 0.0:

position.z += direccion * velocidad_movimiento * delta

position.z = clamp(position.z, posicion_inicial_z - distancia_maxima, posicion_inicial_z + distancia_maxima)

if slider_control:

slider_control.value_changed.disconnect(_on_slider_value_changed)

slider_control.value = position.z - posicion_inicial_z

slider_control.value_changed.connect(_on_slider_value_changed)

func _on_slider_value_changed(nuevo_valor: float) -> void:

position.z = posicion_inicial_z + nuevo_valor

# Esta función se activa SOLA cuando el personaje toca la colchoneta

func _on_body_entered(body: Node3D) -> void:

print("¡Salvado! Ha entrado: ", body.name)

# Si has arrastrado el suelo al Inspector, lo borramos de la memoria INMEDIATAMENTE

if area_suelo_a_borrar:

print("Borrando el Area3DSuelo para evitar la derrota...")

area_suelo_a_borrar.queue_free()

# Aseguramos que el cartel de derrota desaparezca o se mantenga oculto

if mensaje_derrota:

mensaje_derrota.visible = false

# Comprobamos si tenemos activo el retraso en el Inspector

if usar_retraso:

await get_tree().create_timer(tiempo_espera_segundos).timeout

# Se muestra el cartel de victoria

if mensaje_victoria:

mensaje_victoria.visible = true

Deslizar un Area3d con mouse, dedo de la mano y teclas flechas; Godot 4.7; GDScript;

 extends Area3D

@export_category("Control de Interfaz")

# Arrastra aquí tu nodo HSlider desde el Inspector

@export var slider_control: HSlider

@export_category("Movimiento Lateral")

# Velocidad a la que se desplaza con las flechas en el eje Z

@export var velocidad_movimiento: float = 5.0

# Distancia máxima (en metros) que se puede alejar de su centro en Z

@export var distancia_maxima: float = 3.0

# Variable para recordar la posición Z inicial configurada en el editor

var posicion_inicial_z: float = 0.0 

func _ready() -> void:

# Guardamos el valor de Z del editor al arrancar

posicion_inicial_z = position.z 

# Calibramos el HSlider por código para que coincida con tus distancias

if slider_control:

slider_control.min_value = -distancia_maxima

slider_control.max_value = distancia_maxima

slider_control.step = 0.01

slider_control.value = 0.0 # Empieza en el centro

# Conectamos la señal para cuando el usuario arrastre la bolita con el ratón

slider_control.value_changed.connect(_on_slider_value_changed)

else:

push_warning("¡Aviso! No has arrastrado el HSlider al Inspector del Area3D.")

func _process(delta: float) -> void:

var direccion: float = 0.0

# 1. Detectamos las flechas del teclado

if Input.is_action_pressed("ui_right"):

direccion += 1.0

if Input.is_action_pressed("ui_left"):

direccion -= 1.0

# 2. Si el jugador está pulsando las flechas, movemos el objeto

if direccion != 0.0:

position.z += direccion * velocidad_movimiento * delta

# Limitamos el movimiento dentro de los márgenes seguros

position.z = clamp(position.z, posicion_inicial_z - distancia_maxima, posicion_inicial_z + distancia_maxima)

# ¡Sincronización! Actualizamos la posición de la bolita del slider en pantalla

if slider_control:

# Desconectamos temporalmente la señal para evitar un bucle infinito al actualizar el valor

slider_control.value_changed.disconnect(_on_slider_value_changed)

# Calculamos el desvío actual respecto al centro y se lo asignamos al slider

slider_control.value = position.z - posicion_inicial_z

# Volvemos a conectar la señal para el ratón

slider_control.value_changed.connect(_on_slider_value_changed)

# 3. Esta función se ejecuta automáticamente cuando arrastras la bolita con el ratón

func _on_slider_value_changed(nuevo_valor: float) -> void:

# Modificamos la Z del objeto directamente usando el valor del slider

position.z = posicion_inicial_z + nuevo_valor

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

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

Explicacion: GDScript para un juego muy corto y sencillo en el que solo hay que mover un colchon que hay en el suelo, todo en 3d; para salvar a un accidentado, es para pc y para telefono , y se usa el mouse el dedo o teclas flechas izquierda y derecha del teclado del pc

GDScript para Godot 4.7, produce una animacion y un movimiento de ladeo que se puede manipular desde el inspector;

 extends Node3D

@export_category("Rotación Aleatoria")

# ¿Quieres que rote en estos ejes? Actívalo o desactívalo en el Inspector

@export var rotar_en_x: bool = true

@export var rotar_en_y: bool = true

@export var rotar_en_z: bool = true

# Rango de grados máximos que puede girar (ej. entre -45 y 45 grados)

@export var angulo_maximo_grados: float = 45.0

# Cuánto tarda en completarse cada giro aleatorio (en segundos)

@export var tiempo_giro: float = 2.0

func _ready() -> void:

$AnimationPlayer.play("LENGUA")

# Iniciamos el bucle de rotación aleatoria

iniciar_rotacion_aleatoria()

func iniciar_rotacion_aleatoria() -> void:

# Creamos el Tween que controlará la animación fluida

var tween = create_tween()

# Lo configuramos en paralelo para que anime los tres ejes a la vez si es necesario

tween.set_parallel(true)

# Usamos una transición suave para que no dé tirones al cambiar de dirección

tween.set_trans(Tween.TRANS_SINE)

tween.set_ease(Tween.EASE_IN_OUT)

# --- EJE X ---

if rotar_en_x:

var angulo_x = deg_to_rad(randf_range(-angulo_maximo_grados, angulo_maximo_grados))

tween.tween_property(self, "rotation:x", angulo_x, tiempo_giro)

# --- EJE Y ---

if rotar_en_y:

var angulo_y = deg_to_rad(randf_range(-angulo_maximo_grados, angulo_maximo_grados))

tween.tween_property(self, "rotation:y", angulo_y, tiempo_giro)

# --- EJE Z ---

if rotar_en_z:

var angulo_z = deg_to_rad(randf_range(-angulo_maximo_grados, angulo_maximo_grados))

tween.tween_property(self, "rotation:z", angulo_z, tiempo_giro)

# Cuando este grupo de giros termine, volvemos a llamar a la función para generar nuevos ángulos

tween.chain().tween_callback(iniciar_rotacion_aleatoria)

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

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

Explicacion:   GDScript para Godot 4.7, produce una animacion y un movimiento de ladeo que se puede manipular desde el inspector;

Creando un cielo en Godot 4.7; en 3d;

 Estas imagenes son para poner  un cielo en proyectos 3d para Godot 4.7....es una vase para empezar a aprender, fijarse en las capturas de pantalla y en mi enlace donde hay imagenes de cielo a 360 grados, son perfectas para verse de forma muy real en los juegos 3d...

Paso enlace donde hay cielos descargables tipo CCO, libre sin pagar por usarlo....

https://polyhaven.com/a/sunflowers_puresky

Sunflowers (Pure Sky) HDRI • Poly Haven    CC0

License

A si ilumina Godot 4.7;

 google analitic integrado aqui en html ultimas lineas

¡Solo un pequeño recordatorio! Si disfrutas lo que creo, puedes apoyarme en https://ko-fi.com/perico415

Probando ambiente con iluminaciones en el nuevo Godot 4.7

GDScripts Godot 4.6.3 de mi juego ROBBERY AND FALL;;

 extends Node3D

func _ready() -> void:

$AnimationPlayer.play("Game_engineAction")

pass

func _process(delta: float) -> void:

pass

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

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

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

extends Area3D

# Controla el tiempo de espera en segundos desde el Inspector

@export var tiempo_espera: float = 5.0

func _ready() -> void:

# Conectamos la señal de que otra área ha entrado en nuestro espacio

area_entered.connect(_on_area_entered)

func _on_area_entered(other_area: Area3D) -> void:

print("¡Área detectada! Esperando ", tiempo_espera, " segundos antes de borrar...")

# El truco: el código se para aquí y espera los segundos que le hayas dicho

await get_tree().create_timer(tiempo_espera).timeout

print("¡Tiempo cumplido! Borrando objeto.")

# Se borra a sí misma del juego de forma segura

queue_free()

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

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

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

extends Area3D

# Permite arrastrar cualquier archivo de escena (.tscn) desde el sistema de archivos al Inspector

@export var escena_a_instanciar: PackedScene

func _ready() -> void:

# Conectamos la señal que detecta cuando otra Area3D entra en esta área

area_entered.connect(_on_area_entered)

func _on_area_entered(area_rival: Area3D) -> void:

# Comprobamos primero si nos hemos acordado de poner una escena en el Inspector

if escena_a_instanciar == null:

push_warning("¡Aviso! No has asignado ninguna escena en el Inspector de este Area3D.")

return

# 1. Creamos la instancia en memoria

var nueva_instancia: Node3D = escena_a_instanciar.instantiate() as Node3D

# 2. La añadimos a la escena actual (normalmente al nodo raíz del nivel para que no se mueva con el personaje)

get_tree().current_scene.add_child(nueva_instancia)

# 3. Le damos la posición exacta en el espacio tridimensional donde ha ocurrido el choque

# Puedes usar la posición de esta área o la del área que acaba de entrar ('area_rival.global_position')

nueva_instancia.global_position = global_position

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

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

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

extends Camera3D

# --- Variables regulables desde el Inspector ---

@export_group("Configuración del Loop")

## La distancia máxima que se acercará y alejará la cámara desde su punto inicial.

@export var amplitud: float = 55.0

## La velocidad a la que se realiza el movimiento de vaivén.

@export var velocidad: float = 22.0

# --- Variables internas del sistema ---

var posicion_inicial: Vector3

var tiempo_acumulado: float = 0.0

func _ready() -> void:

# Guardamos la posición original en la que colocaste la cámara en el editor

posicion_inicial = global_position

func _process(delta: float) -> void:

# 1. Control de salida rápida del juego (Mantenemos tu función anterior)

if Input.is_key_pressed(KEY_ESCAPE):

get_tree().quit()

# 2. Lógica del bucle de enfoque (Acercar / Alejar)

tiempo_acumulado += delta * velocidad

# El seno oscila suavemente entre -1 y 1

var oscilacion: float = sin(tiempo_acumulado)

# Calculamos el desplazamiento en el eje Z (hacia adelante y hacia atrás)

var desplazamiento_x: float = oscilacion * amplitud

# Aplicamos el movimiento respecto a su posición inicial

global_position.x = posicion_inicial.x + desplazamiento_x

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

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

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

extends WorldEnvironment

func _process(_delta: float) -> void:

# Comprobamos si el jugador presiona la tecla Escape

if Input.is_key_pressed(KEY_ESCAPE):

print("Cerrando el juego de forma segura... ¡Hasta pronto, HAL!")

get_tree().quit()

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

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

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

extends Camera3D

# --- Variables regulables desde el Inspector ---

@export_group("Configuración del Loop")

## La distancia máxima que se acercará y alejará la cámara desde su punto inicial.

@export var amplitud: float = 55.0

## La velocidad a la que se realiza el movimiento de vaivén.

@export var velocidad: float = 22.0

# --- Variables internas del sistema ---

var posicion_inicial: Vector3

var tiempo_acumulado: float = 0.0

func _ready() -> void:

# Guardamos la posición original en la que colocaste la cámara en el editor

posicion_inicial = global_position

func _process(delta: float) -> void:

# 1. Control de salida rápida del juego (Mantenemos tu función anterior)

if Input.is_key_pressed(KEY_ESCAPE):

get_tree().quit()

# 2. Lógica del bucle de enfoque (Acercar / Alejar)

tiempo_acumulado += delta * velocidad

# El seno oscila suavemente entre -1 y 1

var oscilacion: float = sin(tiempo_acumulado)

# Calculamos el desplazamiento en el eje Z (hacia adelante y hacia atrás)

var desplazamiento_z: float = oscilacion * amplitud

# Aplicamos el movimiento respecto a su posición inicial

global_position.z = posicion_inicial.z + desplazamiento_z

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

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

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

extends CPUParticles3D

# Controla la velocidad de giro desde el Inspector.

# Valores positivos giran a un lado, negativos al otro.

@export var velocidad_giro: float = 2.0

func _ready() -> void:

# Le da una orientación inicial totalmente aleatoria en el eje Y (entre 0 y 360 grados)

# para que cada vez que empiece el nivel o aparezca, no mire siempre al mismo sitio.

rotate_y(randf_range(0.0, TAU))

func _physics_process(delta: float) -> void:

# Hace que el emisor de partículas gire continuamente en el eje Y

# Multiplicamos por 'delta' para que gire suave y fluido independientemente de los FPS

rotate_y(velocidad_giro * delta)

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

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

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

extends RigidBody3D

func _ready() -> void:

# Activamos el monitor de contactos para que este cuerpo detecte los choques

contact_monitor = true

max_contacts_reported = 2

# Conectamos la señal de colisión con la función de abajo

body_entered.connect(_on_body_entered)

func _on_body_entered(body: Node) -> void:

# 'body' es el objeto real con el que acabamos de chocar abajo

if body and body.name == "RigidBody3D":

print("¡ZAS! Golpeado: ", body.name, ". Borrando de la escena...")

# Borra de forma segura el cuerpo de abajo (y todos sus ladrillos hijos)

body.queue_free()

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

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

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

extends Node3D

func _ready() -> void:

$AnimationPlayer.play("ARMA")

pass

func _process(delta: float) -> void:

pass

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

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

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

extends HSlider

# Controla la velocidad de giro del slider desde el Inspector (en grados por segundo)

@export var velocidad_giro_slider: float = 90.0

# Referencia automática al nodo del pivote usando su ruta exacta en tu escena

@onready var pivote_camara: Node3D = $"../../../WorldEnvironment/Node3D2PIEDRAKECAE"

func _process(delta: float) -> void:

# Si el slider no está en el centro (0), significa que lo estamos moviendo

if value != 0.0:

# Hacemos girar directamente al pivote desde aquí usando su valor (-1 a 1)

pivote_camara.rotate_y(deg_to_rad(-velocidad_giro_slider) * value * delta)

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

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

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

extends Label

# Controla el tiempo de vida del Label desde el Inspector (en segundos)

@export var tiempo_espera: float = 5.0

func _ready() -> void:

# Crea un temporizador rápido que espera los segundos indicados

# Cuando termina el tiempo, llama automáticamente a 'queue_free()' para borrar el Label

get_tree().create_timer(tiempo_espera).timeout.connect(queue_free)

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

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

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

extends Label3D

# Controla la velocidad de giro desde el Inspector.

# Valores positivos giran a un lado, negativos al otro.

@export var velocidad_giro: float = 2.0

func _ready() -> void:

# Le da una orientación inicial totalmente aleatoria en el eje Y (entre 0 y 360 grados)

# para que cada vez que empiece el nivel o aparezca, no mire siempre al mismo sitio.

rotate_y(randf_range(0.0, TAU))

func _physics_process(delta: float) -> void:

# Hace que el emisor de partículas gire continuamente en el eje Y

# Multiplicamos por 'delta' para que gire suave y fluido independientemente de los FPS

rotate_y(velocidad_giro * delta)

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

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

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

extends Node3D

# El @export permite ver y editar la velocidad desde el Inspector en Godot 4.6

@export var velocidad_giro: float = 45.0

func _process(delta: float) -> void:

# Rotamos 'self' (este mismo nodo pivote) en el eje Y.

# Multiplicamos por delta para que el giro sea suave y no dependa de los FPS.

rotate_y(deg_to_rad(velocidad_giro) * delta)

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

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

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

extends Node3D

# Controla la velocidad de giro desde el Inspector (en grados por segundo)

@export var velocidad_giro: float = 90.0

func _process(delta: float) -> void:

# Creamos una dirección basada en las teclas que pulses.

# Si pulsas 'D' (derecha) devolverá 1. Si pulsas 'A' (izquierda) devolverá -1.

# Si no pulsas nada, devolverá 0 y el pivote se quedará quieto.

var direccion: float = Input.get_axis("ui_left", "ui_right")

#var direccion: float = Input.get_axis("left", "right")

# Si tus teclas A y D no están mapeadas en las acciones por defecto "ui_left" y "ui_right",

# puedes descomentar la línea de abajo y usar este otro método directo:

# var direccion: float = Input.get_action_strength("key_d") - Input.get_action_strength("key_a")

# Aplicamos la rotación usando la dirección (multiplicamos por '-' para que la dirección sea intuitiva)

if direccion != 0:

rotate_y(deg_to_rad(-velocidad_giro) * direccion * delta)

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

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

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

extends Node3D

# Permite ajustar el rango de tiempo estándar desde el Inspector

@export var tiempo_minimo: float = 2.0

@export var tiempo_maximo: float = 6.0

# NUEVO: Segundos EXTRA que se quedará la cámara borrable en pantalla

@export var tiempo_extra_borrable: float = 4.0

# Referencias a tus TRES cámaras con las rutas correctas de tu escena

@onready var camara_pivote: Camera3D = $WorldEnvironment/Node3D/Camera3D

@onready var camara_borrable: Camera3D = $"WorldEnvironment/Camera3D BORRABLE"

@onready var camara_malo: Camera3D = $"Camera3D BORRABLE2enfoca malo"

var timer: Timer

func _ready() -> void:

# Creamos un temporizador por código para controlar los cambios

timer = Timer.new()

add_child(timer)

# Conectamos el temporizador para que llame a la función de cambiar cámara

timer.timeout.connect(_on_timer_timeout)

# Iniciamos el bucle con un tiempo aleatorio normal

_reiniciar_temporizador(false) # false significa tiempo normal al arrancar

func _on_timer_timeout() -> void:

# Elegimos un número entero aleatorio entre 0, 1 o 2

var eleccion: int = randi() % 3

# Variable para saber si ha salido la borrable

var es_la_borrable: bool = false

# Dependiendo del número, activa una de las tres cámaras

if eleccion == 0:

camara_pivote.make_current()

print("Cambiado a: Cámara del Pivote")

elif eleccion == 1:

camara_borrable.make_current()

es_la_borrable = true # ¡Apuntamos que ha salido la borrable!

print("Cambiado a: Cámara Borrable (Se mantendrá más tiempo)")

else:

camara_malo.make_current()

print("Cambiado a: Cámara que enfoca al malo")

# Le pasamos a la función si tiene que aplicar el tiempo extra o no

_reiniciar_temporizador(es_la_borrable)

func _reiniciar_temporizador(con_extra: bool) -> void:

# Calcula el número al azar normal entre el mínimo y el máximo

var tiempo_aleatorio: float = randf_range(tiempo_minimo, tiempo_maximo)

# Si la cámara actual es la borrable, le sumamos el tiempo extra

if con_extra:

tiempo_aleatorio += tiempo_extra_borrable

timer.start(tiempo_aleatorio)

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

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

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

extends Node3D

# Permite ajustar el rango de tiempo (en segundos) entre cambios desde el Inspector

@export var tiempo_minimo: float = 2.0

@export var tiempo_maximo: float = 6.0

# Referencias a tus TRES cámaras con las rutas correctas de tu escena

@onready var camara_pivote: Camera3D = $WorldEnvironment/Node3D/Camera3D

@onready var camara_borrable: Camera3D = $"WorldEnvironment/Camera3D BORRABLE"

@onready var camara_malo: Camera3D = $"Camera3D BORRABLE2enfoca malo"

var timer: Timer

func _ready() -> void:

# Creamos un temporizador por código para controlar los cambios

timer = Timer.new()

add_child(timer)

# Conectamos el temporizador para que llame a la función de cambiar cámara

timer.timeout.connect(_on_timer_timeout)

# Iniciamos el bucle con un tiempo aleatorio

_reiniciar_temporizador()

func _on_timer_timeout() -> void:

# Elegimos un número entero aleatorio entre 0, 1 o 2

var eleccion: int = randi() % 3

# Dependiendo del número, activa una de las tres cámaras

if eleccion == 0:

camara_pivote.make_current()

print("Cambiado a: Cámara del Pivote")

elif eleccion == 1:

camara_borrable.make_current()

print("Cambiado a: Cámara Borrable")

else:

camara_malo.make_current()

print("Cambiado a: Cámara que enfoca al malo")

# Volvemos a calcular un tiempo nuevo para el próximo cambio

_reiniciar_temporizador()

func _reiniciar_temporizador() -> void:

# Calcula un número al azar entre el mínimo y el máximo que pongas en el Inspector

var tiempo_aleatorio: float = randf_range(tiempo_minimo, tiempo_maximo)

timer.start(tiempo_aleatorio)

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

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

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

extends Node3D

# Permite ajustar el rango de tiempo (en segundos) entre cambios desde el Inspector

@export var tiempo_minimo: float = 2.0

@export var tiempo_maximo: float = 6.0

# Referencias a tus dos cámaras usando la ruta exacta de tu árbol de nodos

@onready var camara_pivote: Camera3D = $WorldEnvironment/Node3D/Camera3D

@onready var camara_borrable: Camera3D = $"WorldEnvironment/Camera3D BORRABLE"

@onready var camara_malo: Camera3D =$"WorldEnvironment/Camera3D BORRABLE2enfoca malo"

var timer: Timer

func _ready() -> void:

# Creamos un temporizador por código para controlar los cambios

timer = Timer.new()

add_child(timer)

# Conectamos el temporizador para que llame a la función de cambiar cámara

timer.timeout.connect(_on_timer_timeout)

# Iniciamos el bucle con un tiempo aleatorio

_reiniciar_temporizador()

func _on_timer_timeout() -> void:

# Elegimos aleatoriamente entre true (0.5 o más) y false (menos de 0.5)

var elegir_pivote: bool = randf() >= 0.5

if elegir_pivote:

camara_pivote.make_current()

print("Cambiado a: Cámara del Pivote")

else:

camara_borrable.make_current()

print("Cambiado a: Cámara Borrable")

# Volvemos a calcular un tiempo nuevo para el próximo cambio

_reiniciar_temporizador()

func _reiniciar_temporizador() -> void:

# Calcula un número al azar entre el mínimo y el máximo que pongas en el Inspector

var tiempo_aleatorio: float = randf_range(tiempo_minimo, tiempo_maximo)

timer.start(tiempo_aleatorio)

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

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

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

Explicacion: GDscripts del juego  ROBBERY AND FALL echo con Godot 4.6.3