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  

Juega dentro de mi blog a ROBBERY AND FALL;

 contine google analitic html las ultimas lineas

Juega ahora a ROBBERY AND FALL;

 

GDScript para hacer zoom con una camara3d;

 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 = 5.0

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

@export var velocidad: float = 2.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

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

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

Explicacion: Jugando con la camara3d mediante programacion, hace  zoomm aleja y acerca aleatoriamente, y se puede regular desde el inspector gracias al @export.  La velocidad la amplitud.....