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
