juego del 2019; a llovido....;

https://www.kongregate.com/en/games/asaco415415/campo-de-minas 

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