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
