GDScripts del juego de la paloma;

 extends Node3D

func _ready() -> void:

$AnimationPlayer.play("abuelito")

pass

func _process(delta: float) -> void:

pass

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

extends Camera3D

func _process(_delta: float) -> void:

# Si se presiona la tecla Escape, cierra el juego de golpe

if Input.is_action_just_pressed("ui_cancel") or Input.is_key_pressed(KEY_ESCAPE):

get_tree().quit()

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

extends Camera3D

# Tiempo en segundos antes de borrarse. Puedes cambiarlo en el Inspector.

@export var tiempo_vida : float = 23.0

func _ready() -> void:

# Creamos un temporizador por código

var timer = get_tree().create_timer(tiempo_vida)

# Cuando el tiempo se agote, llamamos a queue_free() para borrar la cámara

timer.timeout.connect(queue_free)

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

extends CPUParticles3D

# Tiempo en segundos antes de que las partículas se activen.

# Puedes calibrarlo directamente desde el Inspector.

@export var tiempo_espera : float = 5.0

func _ready() -> void:

# Nos aseguramos de que por defecto arranquen apagadas (en false)

emitting = false

# Creamos un temporizador con el tiempo del Inspector

var timer = get_tree().create_timer(tiempo_espera)

# Cuando el tiempo termine, llamamos a la función para encenderlas

timer.timeout.connect(_activar_particulas)

func _activar_particulas() -> void:

# Activamos las partículas poniéndolas en true

emitting = true

print("¡Partículas activadas después de ", tiempo_espera, " segundos!")

func _process(delta: float) -> void:

pass

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

extends Node3D

# Esta variable saldrá en el Inspector. 

# 1.0 es velocidad normal, 2.0 es el doble de rápido, y 0.5 es cámara lenta.

@export var velocidad_animacion : float = 41.0

func _ready() -> void:

# Buscamos el reproductor de animación

var anim = $AnimationPlayer

# Le aplicamos la velocidad que hayas puesto en el Inspector

anim.speed_scale = velocidad_animacion

# Arrancamos la animación del palomo

anim.play("PALOMO")

func _process(delta: float) -> void:

pass

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

extends Node3D

# --- Configuración de la Animación ---

@export var velocidad_animacion : float = 41.0

# --- Configuración del Cambio de Escena ---

# Aquí arrastras la escena (.tscn) a la que quieres viajar

@export var proxima_escena : PackedScene

# Tiempo en segundos antes de cambiar de escena (puedes calibrarlo en el Inspector)

@export var tiempo_espera : float = 30.0

func _ready() -> void:

# 1. Configurar y arrancar la animación del palomo

var anim = $AnimationPlayer

if anim:

anim.speed_scale = velocidad_animacion

anim.play("PALOMO")

# 2. Crear el temporizador para cambiar de escena

# Usamos el tiempo que hayas puesto en el Inspector

var timer = get_tree().create_timer(tiempo_espera)

# Cuando termine el tiempo, llamará automáticamente a la función '_al_terminar_tiempo'

timer.timeout.connect(_al_terminar_tiempo)

func _al_terminar_tiempo() -> void:

# Comprobamos si te has acordado de arrastrar una escena al Inspector

if proxima_escena:

# Cambiamos a la nueva escena de forma limpia

get_tree().change_scene_to_packed(proxima_escena)

else:

# Si se te olvidó arrastrar la escena, te avisará en la consola para que no te vuelvas loco

print("¡Aviso! No has arrastrado ninguna escena al Inspector en el hueco 'proxima_escena'.")

func _process(delta: float) -> void:

pass

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

extends Node3D

# Esta variable aparece en el Inspector para cambiar la velocidad cuando quieras

@export var velocidad_giro : float = 31.0

func _process(delta: float) -> void:

# Hace que el nodo gire de forma constante en el eje Y (izquierda a derecha)

# Multiplicamos por delta para que el giro sea suave y no dependa de los FPS

rotate_y(velocidad_giro * delta)

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

extends Node3D

func _ready() -> void:

$AnimationPlayer.play("CAGANDO")

pass

func _process(delta: float) -> void:

pass

Paloma desagradecida.; videojuego simulacion;

 

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;