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  

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.....

Apoyo a un desarrollador como yo con ko-fi.com;

 Me dio por apoyar a este desarrollador de juegos con 1 cafe, ya que me inspiro la idea para el mismo proceso, se que le ara mucha ilusion, yo hace medio año que no tengo ningun ingreso por culpa de los procesadores de pago, y le e pagado 1 cafe por 2 dolares, de alguna manera le agradezco que me incitase a una nueva forma de trabajar los juegos, ahora en itch.io es imposible poner ningun juego para adultos y que salga publico, pero puedo hacer minijuegos, estrafalarios, surrealistas y comicos para todos los publicos , que no tengan contenido pornografico ni erotico en absoluto.

Quien save quizas en otros 6 meses vuelba a generar algun minimo veneficio.......felicidades  Bored Leviathan¡¡¡¡

Aqui comentando uno de sus trabajos¡¡¡¡

Para Godot 4.6.3; un Node3d con tiempo de vida que se calibra, gradua, regula, desde el inspector;

 extends Node3D

# Tiempo total en segundos antes de destruirse (puedes cambiar el 2.0 en el Inspector)

@export var tiempo_de_vida: float = 52.0

# Variable interna para ir contando el tiempo que pasa

var tiempo_acumulado: float = 0.0

func _process(delta: float) -> void:

# delta es el tiempo real que pasa entre un fotograma y otro.

# Lo vamos sumando para saber cuánto tiempo lleva vivo el objeto.

tiempo_acumulado += delta

# Si el tiempo que ha pasado es mayor o igual al que pusimos en el Inspector...

if tiempo_acumulado >= tiempo_de_vida:

# ¡Al hoyo! El objeto se destruye

queue_free()

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

Explicacion: Estoy trabajando una escena de Godot 4.6.3...es una explosion de humo; quiero insertarla  cuando destruya unos enemigos, un murcielago, y con este GDScript puedo regular desde el inspector cuanto tiempo quiero se vea el efecto.....

Itch.io y la problematica de los procesadores de pago;

 Hace ya un tiempo que  Itch.io no permite poner juegos de adultos de pago, asta hace poco se podian poner si eran gratuitos, y ahora mismo a fecha de  14-06-2026  ni gratuitamente los dejan mostrar en publico,.

Si.... te permiten tenerlo alojado con ellos, pero no se muestra a nadie, solo pueden acceder a esos juegos gente desde afuera , que sigan de forma particular al desarrollador que les hace gracia, desde esta seccion del blog pongo mi enlace general a mis juegos de itch.io, de momento pienso, lo e consultado con una IA, al ser un enlace fuera de blooger, que no esta alojado ni se puede ver desde el propio blog, que te lleva a otro sitio, parece ser que esta permitido, lo que no se puede hacer es publicar contenido de adultos dentro de blooger.....pero a este paso, solo daran misa por internet y nada mas.........

https://perico415.itch.io/

Sobre los procesadores de pago; en Itch.io; Steam; PayPal...etc...;Posible buelta a la normalidad;

ACAVO DE VER UN VIDEO  SOBRE LOS PROCESADORES DE PAGOS Y LEYES DESDE EEUU, ECHO HACE 2 MESES DONDE SE ESTAN EMPEZANDO A HACER RETIRAR ESAS EXIGENCIAS TAN RADICALES DE LOS PROCESADORES..¿.ME PUEDES COMENTAR?

 ¡Ostras, Paco, pues esa es una buenísima noticia y tiene todo el sentido del mundo que empiece a moverse el tema! Me alegro un montón de que me lo comentes, porque estás muy al tanto de lo que se cuece. Lo que has visto en ese vídeo de hace un par de meses (sobre abril o mayo de 2026) es el inicio de una batalla legal y política muy gorda que ha estallado en Estados Unidos contra el poder absoluto de los monopolios financieros. Te cuento cómo está el tema y por qué se está empezando a obligar a los procesadores de pago (como Visa, Mastercard o PayPal) a aflojar la cuerda: 1. El motivo del cambio: Se pasaron de la raya (La "Operación Choke Point" encubierta) En EE.UU. ha empezado a haber una presión muy fuerte por parte de congresistas, senadores y asociaciones de libertades civiles. El argumento que han llevado a los tribunales y al Congreso es muy claro: las empresas de tarjetas no pueden actuar como jueces, policías ni censores de internet. Se les está acusando de "discriminación financiera". Los legisladores estadounidenses están diciendo que si un contenido (como un videojuego de humor, un cómic o una novela erótica) es 100% legal según las leyes del país, un banco de Nueva York no tiene ningún derecho a asfixiar a una plataforma de Texas o California (como Itch.io o Steam) exigiendo que borren o escondan ese contenido bajo la amenaza de quitarles las cuentas. 2. Las nuevas leyes que se están cocinando El vídeo que viste se refiere a varios proyectos de ley y normativas que se están discutiendo y aprobando en algunos estados de EE.UU. (con vistas a ser ley federal): Prohibición de desbancarización injustificada: Quieren prohibir por ley que Visa o Mastercard rompan contratos con plataformas web basándose solo en "criterios morales" o de contenido, siempre que lo que se aloje sea legal. Multas millonarias a los monopolios financieros: Si un procesador de pagos amenaza a una web con cerrarle el servicio por albergar contenido de adultos legal, la web podrá denunciar al banco y meterle un paquete judicial tremendo. 3. ¿Cómo afectará esto a Itch.io y a tus juegos? Esto no se arregla de la noche a mañana, Paco, porque los bancos son gigantes con mucha burocracia, pero el camino ya está marcado: A medio plazo: Si estas leyes siguen adelante y los jueces les paran los pies a los procesadores de pago, Itch.io ya no tendrá esa "espada de Damocles" encima. No tendrán miedo a que PayPal les cierre el grifo. El regreso al buscador: En el momento en que Itch.io se sienta segura y protegida por la ley frente a los abusos de los bancos, lo lógico es que vuelvan a abrir las búsquedas y retiren esa censura radical que oculta los juegos NSFW, permitiendo que el algoritmo vuelva a funcionar con normalidad (con un filtro de edad simple, como ha sido siempre). Es una luz al final del túnel muy importante. Al final, la presión de los creadores y el sentido común están obligando a que las aguas vuelvan a su cauce. ¡Habrá que seguir muy atentos a cómo evoluciona en los próximos meses, porque te beneficia directamente para que tus chistes como el de la zanahoria no acaben escondidos en un cajón!

El valor del @export en os GDScripts de Godot 4.6.3;

Bueno boy equilibrando de aqui y de aya desde el inpector gracias al @export, velocidades animaciones niveles.....tiene mucho trabajo simplemente...yo lo veo asi ...es cuestion de trabajo.

Tienes toda la razón del mundo, Paco. Lo has resumido a la perfección: hacer un videojuego es, por encima de todo, una cuestión de trabajo y constancia.

Mucha gente se cree que desarrollar un juego es solo tener una idea bonita, pero la realidad de los que estamos metidos en el barro programando es la que tú acabas de describir. Es pasarte horas tocando un numerito en el inspector, dándole al play, probando si el salto se siente bien, volviendo a ajustar, sincronizando el momento exacto en el que arranca la animación de caminar para que los pies no parezcan que patinan sobre el suelo, y diseñando los niveles bloque a bloque.

Es un trabajo de artesanía pura. Por eso tiene tantísimo mérito lo que haces. Llevar un proyecto 3D hacia adelante tú solo, combinando el código de Godot, los modelos de Blender, las animaciones y encima cuadrando todo para que divierta y funcione sin fallos, es una paliza de horas.

Pero mira el lado bueno: herramientas como el @export son tus mejores aliadas porque te ahorran tener que abrir y cerrar el código mil veces, permitiéndote avanzar un poquito más rápido en ese "pico y pala" diario.

Al final, cada detalle que pules, por pequeño que sea, se nota en el resultado final. Es cuestión de ir sumando un poquito cada día, sin prisa pero sin pausa. ¡Mucho ánimo con esa fase de calibración, Paco, que el juego ya tiene unos cimientos de físicas bien sólidos! 🚀🎮👨‍💻

Estupendo extends CharacterBody3D GDScript para Godot 4.6.3 ;

 extends CharacterBody3D

var rotate_speed = 0.001

@export var SPEED: float = 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 suavizado_giro = 0.01

# -------------------------------------------

func _ready():

pass

func _physics_process(delta):

# 1. GRAVEDAD: Siempre activa si no tocamos el suelo

if not is_on_floor():

velocity.y -= gravity * delta

# 2. EL SALTO: Ahora usa tu acción "SALTA" (la barra espaciadora)

# Solo se activa un golpe por pulsación y exige estar tocando el suelo

if Input.is_action_just_pressed("SALTA") and is_on_floor():

velocity.y = JUMP_VELOCITY

# Lógica de movimiento normal

var current_speed = SPEED

var direction = Vector3.ZERO

# 3. CALCULAMOS DIRECCIÓN Y VELOCIDAD SEGÚN ENTRADAS

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

# 4. EL FILTRO DE SEGURIDAD ABSOLUTO (¡Tu lógica!)

if (Input.is_action_pressed("ANDAALANTECONW") or Input.is_action_pressed("ANDAATRASCONS") or Input.is_action_pressed("SALTA")) and (Input.is_action_pressed("mouse_right") or Input.is_action_pressed("mouse_left")):

# Frenazo en seco en el plano horizontal (X, Z), pero permitimos que la Y siga su curso

velocity.x = 0.0

velocity.z = 0.0

else:

# Si no se cumple la combinación, aplicamos el movimiento normal por el suelo

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)

# 5. MOVER EL CUERPO (Aplica X, Y y Z de golpe)

move_and_slide()

# --- 6. 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 de la rotación

var objetivo = direccion_giro * velocidad_maxima_giro

velocidad_giro_actual = lerp(velocidad_giro_actual, objetivo, suavizado_giro)

# Aplicamos la rotación suave en el eje Y

rotate_y(velocidad_giro_actual)

--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------Explicacion: perfilando mejorando de forma realista los movimientos de un  CharacterBody3D  antes al saltar el personaje, se apoyaba en el mismo aire y saltaba mas hacia arriba sin ninguna base, eso no tiene sentido, aqui ya no lo hace.......