GDScript, una animacion la detiene al presionar tecla "u" con mapa de entrada llamado"paraanimacion" al soltar prosige;

 extends Node3D

var animation_player = null

var animation_playing = false

var target_animation = "MakeHuman default skeleton|pistolaenmanodisparando"

func _ready():

# Obtener una referencia al nodo AnimationPlayer

animation_player = $AnimationPlayer

# Reproducir la animación si existe

animation_player.play(target_animation)

animation_playing = true

func _process(delta):

# Controlar la reproducción de la animación con la tecla "u"

if Input.is_action_pressed("paraanimacion"):

if animation_playing:

# Detener la animación

animation_player.stop()

animation_playing = false

elif Input.is_action_just_released("paraanimacion"):

if not animation_playing:

# Reanudar la animación

animation_player.play(target_animation)

animation_playing = true

extends CPUParticles3D, GDScript rota el plano de particulas constantemente; para conseguir efectos;

 extends CPUParticles3D

# Called when the node enters the scene tree for the first time.

func _ready() -> void:

pass # Replace with function body.

# Called every frame. 'delta' is the elapsed time since the previous frame.

func _process(delta: float) -> void:

rotate_z(1.2)

pass

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

otro ejemplo en otro eje

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

extends CPUParticles3D

# Called when the node enters the scene tree for the first time.

func _ready() -> void:

pass # Replace with function body.

# Called every frame. 'delta' is the elapsed time since the previous frame.

func _process(delta: float) -> void:

rotate_x(2)

pass

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

otro ejemplo mas en los 3 ejes x,z,y

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

extends CPUParticles3D

# Called when the node enters the scene tree for the first time.

func _ready() -> void:

pass # Replace with function body.

# Called every frame. 'delta' is the elapsed time since the previous frame.

func _process(delta: float) -> void:

rotate_z(1.4)

rotate_x(1.7)

rotate_y(1.1)

pass

GDScript para Godot 4.3 por tiempo cambia la escena, por presional tecla del pc numero -9- cambia la escena, y al presionar -esc- sales del juego;

 extends Node

var tiempo_transcurrido = 0.0  # Variable para almacenar el tiempo transcurrido

func _process(delta):

if Input.is_action_pressed("ui_cancel"):

get_tree().quit()

tiempo_transcurrido += delta

if tiempo_transcurrido >= 12.0:

#queue_free()

var siguiente_escena = preload("res://ESCENAS/world_environmentESCENA PRINCIPAL-9-.tscn")  # Precargar la escena

get_tree().change_scene_to_packed(siguiente_escena)  # Cambiar a la escena precargada (Godot 4.2)

#queue_free()  # Liberar este nodo después del cambio de escena

# Nueva condición para cambiar de escena al presionar "9"

if Input.is_action_just_pressed("PISONUEVEPEROBOYAL10"):

var nueva_escena = preload("res://ESCENAS/world_environmentESCENA PRINCIPAL-9-.tscn")

get_tree().change_scene_to_packed(nueva_escena)

pass # Replace with function body.

Trabajo que publicare en itchi.io, perico415 - itch.io calculo en enero del 2025,;

 

https://perico415.itch.io/

Despues de 11 meses mas o menos casi un año de desarrollar con Godot, muestro este video de mi proximo trabajo que publicare en itchi.io, perico415 - itch.io calculo en enero del 2025, en estos 11 meses publique en itchi.io varios juegos, todos de tematica adulta,

Todos con bastante audiencia, y algunas capturas de video muy exitosas, teniendo en cuenta que no soy Youtuber de éxito y popular,

Realmente no me arrepiento de cambiarme a Godot antes usaba Unity, pero veia mucho royo, y para ser un aficionado en estos temas de desarrollar videojuegos, yo solo quiero hacerme rico haciendo juegos, no necesito a Unity ni trabajar para una empresa, yo me vasto y me sobro para ganar mucha pasta¡¡¡¡

Soy sarcastico….pero realmente me siento capaz de cualquier cosa!!!!

No ahora en serio, me gusta muchisimo crear videojuegos, y con Godot me siento muy comodo.

Y me encanta ver como suben un monton las visitas a mi pagina de Itch.io. perico415 - itch.io .

En este video, muestro mi proximo trabajo, tematica de intriga y misterio y surrealismo, me inspira el ambiente nocturno del cine de terror, me inspira Stephen king,

El juego va de un ascensor y de situaciones al vajar y subir plantas de un edificio, en cada planta procuro cambiar la escena, las animaciones , me da por hacerlas manualmente incluso las de caminar que son muy muy dificiles de hacer, pero lo estoy haciendo, y el juego tendra todo un mismo estilo de movimiento y de graficos 3d, podria poner animaciones ya echas realistas, pero me esta gustando hacerlas yo, y si desarrollo juegos es por diversion no por obligacion,

La IA del navegador Microsoft Edge me esta ayudando muchisimo en el tema de programacion GDScript que es el que usa Godot 4.3, es la version que estoy utilizando.

No te resuelve la papeleta, tienes que ir preguntando y probando y cambiando lineas de codigo, y al final estoy teniendo muy buenos resultados, lo mejor cuando un codigo, un script funciona, puedes hacer cambios y añadirle lineas o cambiarlas, y voy aprendiendo.

Ayuda a aprender es como tener un profesor particular.

Pondre varios scripts que utilizo en el juego, algunos vienen con el propio Godot otros los e retocado yo sacando informacion de aquí y de aya,

En este juego estoy empezando a manipular barra de vida, algo estoy haciendo y saldra en el juego, con script que me proporciono la IA , puedo manipular ideas y temas que salen en el juego,

Mis herramientas de trabajo son, Godot 4.3, Blender, Gimp, Paint, Makehuman, lmms , practicamente casi todos de tipo software libre.org , tambien uso algo de la web OpenGameArt.org .

Y efectos de sonido de https://www.videvo.net/

E conseguido hacer efectos de tembleque del ascensor, efectos de aparecer y desaparecer de fantasmas, cambiar escenas con facilidad por paso de tiempo o presionando alguna tecla del pc,

Me encanta y me gusta muchisimo poder jugar con las camaras y sus enfoques, haciendo un juego de estilo como de cine y de comic.

Y bueno hay estoy con mi maravillosa aficion, con la que pienso hacerme multimillonario……..perdon con la que pienso entretenerme asta el fin de mis dias, si la salud me lo permite, que pienso seran muchos años ya que para esto no hace falta correr maratones ni levantar cargas pesadas de 50 kilos, ….

Eso si paciencia….toneladas….contancia...eterna. Espero guste el video ...ala asta luego!!!!!

A continuacion algunos scripts GDScript que uso en el juego, ayudado por la IA, sino imposible no tengo estudios de programacion.........

extends MeshInstance3D

func _input(event):

# Comprobamos si es un evento de teclado

if event is InputEventKey:

if event.pressed:

if event.keycode == KEY_Z:

rotate_x(0.04)

elif event.keycode == KEY_X:

rotate_x(-0.04)

# Comprobamos si es un evento de acción de entrada

elif event is InputEventAction:

pass

#func _input(event):

if event is InputEventMouseButton:

if event.pressed and event.is_action("mouse_rueda_arriba"):

#if event.action == "mouse_rueda_arriba":

rotate_x(-0.04)

elif event.pressed and event.is_action("mouse_rueda_avajo"):

#elif event.action == "mouse_rueda_avajo":

rotate_x(0.04)

ooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo

extends Node3D

# Called when the node enters the scene tree for the first time.

func _ready() -> void:

$AnimationPlayer.play("Esqueleto|EsqueletoAction")

pass # Replace with function body.

# Called every frame. 'delta' is the elapsed time since the previous frame.

func _process(delta: float) -> void:

pass

ooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo

extends Area3D

# Called when the node enters the scene tree for the first time.

func _ready() -> void:

pass # Replace with function body.

# Called every frame. 'delta' is the elapsed time since the previous frame.

func _process(delta: float) -> void:

pass

func _on_area_entered(area: Area3D) -> void:

#$"CSGBox3D2ASCENSOR4 puertaabre".play("puertaascensor")

$MeshInstance3D.play("corredera")

pass # Replace with function body.

ooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo

extends Area3D

# Called when the node enters the scene tree for the first time.

func _ready() -> void:

pass # Replace with function body.

# Called every frame. 'delta' is the elapsed time since the previous frame.

func _process(delta: float) -> void:

pass

func _on_area_entered(area: Area3D) -> void:

var siguiente_escena = preload("res://ESCENAS/world_environmentESCENA PRINCIPAL-2-.tscn")  # Precargar la escena

get_tree().change_scene_to_packed(siguiente_escena)  # Cambiar a la escena precargada (Godot 4.2)

queue_free()  # Liberar este nodo después del cambio de escena

00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000

extends Area3D

# Called when the node enters the scene tree for the first time.

func _ready() -> void:

pass # Replace with function body.

# Called every frame. 'delta' is the elapsed time since the previous frame.

func _process(delta: float) -> void:

pass

func _on_area_entered(area: Area3D) -> void:

queue_free()

pass # Replace with function body.

ooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo

extends Area3D

# Called when the node enters the scene tree for the first time.

func _ready() -> void:

pass # Replace with function body.

# Called every frame. 'delta' is the elapsed time since the previous frame.

func _process(delta: float) -> void:

pass

func _on_area_entered(area: Area3D) -> void:

$MeshInstance3D/AnimationPlayer.play("CORREDERAS")

pass # Replace with function body.

ooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo

extends Area3D

# Called when the node enters the scene tree for the first time.

func _ready() -> void:

pass # Replace with function body.

# Called every frame. 'delta' is the elapsed time since the previous frame.

func _process(delta: float) -> void:

pass

func _on_area_entered(area: Area3D) -> void:

$"../CSGBox3D2ASCENSOR4 puertaabre".play($"../CSGBox3D2ASCENSOR4 puertaabre/AnimationPlayer")

pass # Replace with function body.

ooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo

extends Area3D

var Bullet = preload("res://EL PROTAGONISTA/BALA PROYECTIL/PROYECTIL.tscn")

#var Bullet2 = preload("res://EL PROTAGONISTA/FOGONAZO PISTOLA/cpu_particles_3dfogonazo.tscn")

func _ready() -> void:

pass # Replace with function body.

func _input(event):

if event is InputEventMouseButton:

if event.button_index == 1 and event.pressed :

#event.button_index == MOUSE_BUTTON_LEFT and event.pressed:

var bullet = Bullet.instantiate()

#var bullet2 = Bullet2.instantiate()

add_child(bullet)

#add_child(bullet2)

func _unhandled_input(event):

if event is InputEventKey and event.pressed:

if event.keycode == KEY_W:

translate(Vector3(0, 0, 0) * get_process_delta_time())  # Temporary movement (consider physics)

#if event.keycode == KEY_

#apply_impulse(Vector3(0,40,4))#ORIGINAL

if event.keycode == KEY_Z:

rotate_x(0.02)

pass

if event.keycode == KEY_X:

rotate_x(-0.02)

pass

if event is InputEventMouseButton:

if event.pressed and event.is_action("mouse_rueda_arriba"):

#if event.action == "mouse_rueda_arriba":

rotate_x(-0.02)

elif event.pressed and event.is_action("mouse_rueda_avajo"):

#elif event.action == "mouse_rueda_avajo":

rotate_x(0.02)

pass

oooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo

GDScript aparece y desaparece un nodo; este es de un tipo Node3D; ago efecto de un fantasma;

 extends Node3D

var timer = 0.0

var blink_speed = 0.4  # Ajusta la velocidad de parpadeo

func _process(delta: float) -> void:

timer += delta

if timer >= blink_speed:

timer = 0.0

visible = not visible

MeshInstance3D aparece y desaparece constantemente , GDScript para Godot 4.3;

 extends MeshInstance3D

var timer = 0.0

var blink_speed = 0.4  # Ajusta la velocidad de parpadeo

func _process(delta: float) -> void:

timer += delta

if timer >= blink_speed:

timer = 0.0

visible = not visible

Sencillisimo GDScript, lo que entra dentro de un Area3d, borra todos sus hijos; todo su contenido;

 extends Area3D

# Called when the node enters the scene tree for the first time.

func _ready() -> void:

pass # Replace with function body.

# Called every frame. 'delta' is the elapsed time since the previous frame.

func _process(delta: float) -> void:

pass

func _on_area_entered(area: Area3D) -> void:

queue_free()

pass # Replace with function body.

Una forma de destruir por tiempo una camara con Godot4.3, echo en GDScript, juego en 3d; y añadi que gire con un rotate_y(0.001);

 extends Camera3D

# Tiempo en segundos antes de autodestruirse

var self_destruct_time = 14.0

var elapsed_time = 0.0

func _process(delta: float) -> void:

elapsed_time += delta

rotate_y(0.001)

if elapsed_time >= self_destruct_time:

queue_free()

Una forma de destruir por tiempo una camara con Godot4.3, echo en GDScript, juego en 3d;

extends Camera3D

# Tiempo en segundos antes de autodestruirse

var self_destruct_time = 14.0

var elapsed_time = 0.0

func _process(delta: float) -> void:

elapsed_time += delta

if elapsed_time >= self_destruct_time:

queue_free()

GGDScript borra por tiempo, barra de vida y sus hijos; Ejemplos de barra de vida; Ejemplo asociado a otro objeto que es borrado tambien;

 extends ProgressBar

func _ready() -> void:

value = 0

func _process(delta: float) -> void:

value += 0.01

if value >= 100:

# Recorremos todos los hijos del ProgressBar y los eliminamos

for child in get_children():

child.queue_free()

# Eliminamos el ProgressBar

queue_free()

Gdscript Godot 4.3 barra de vida; aumenta por tiempo el valor asta el 100%; Practicas de barra de vida en Godot 4.3; una variante borra el ProgressBar;

 extends ProgressBar

func _ready():

# Establecemos un valor inicial para la barra de progreso

value = 0

func _process(delta):

# Incrementamos el valor de la barra de progreso en cada frame

value += 0.01

# Si el valor llega a 100, eliminamos el nodo padre (StaticBody3D)

if value >= 100:

queue_free()  # Esta función elimina el nodo actual (ProgressBar)

# Como el ProgressBar es hijo del StaticBody3D, al eliminar el hijo, el padre también se elimina

Gdscript Godot 4.3 barra de vida; aumenta por tiempo el valor asta el 100%; Practicas de barra de vida en Godot 4.3;

 extends ProgressBar

# Called when the node enters the scene tree for the first time.

func _ready() -> void:

# Set the initial value of the progress bar

value = 0

# Called every frame. 'delta' is the elapsed time since the previous frame.

func _process(delta: float) -> void:

# Increment the progress bar's value

value += 0.01

# Reset the value when it reaches 100

if value > 100:

value = 0

Sencillisimo GDScript para producir el temblor de un CSGBox3D;

 extends CSGBox3D

var amplitud = 0.1

var velocidad = 2.0

func _process(delta: float) -> void:

transform.origin.z += randf_range(-amplitud * velocidad * delta, amplitud * velocidad * delta)

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

variante con efecto mas acusado...........

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

extends CSGBox3D

var amplitud = 0.4

var velocidad = 5.0

func _process(delta: float) -> void:

transform.origin.z += randf_range(-amplitud * velocidad * delta, amplitud * velocidad * delta)

Un MeshInstance3D, asciende lentamente en eje "y" y se borra a los 25 segundos; Godot 4.3;

 extends MeshInstance3D

var speed = 0.05  # Unidades por segundo

var tiempo_transcurrido = 0.0  # Tiempo en segundos

# Called when the node enters the scene tree for the first time.

func _ready() -> void:

pass # Replace with function body.

# Called every frame. 'delta' is the elapsed time since the previous frame.

func _process(delta: float) -> void:

#var movimiento = Vector3(speed * delta, 0, 0)

var movimiento = Vector3( 0,speed * delta, 0)

#var movimiento = Vector3(speed * delta, 0, 0)

# Aplicar el movimiento a la posición del nodo

translate(movimiento)

# Actualizar el tiempo transcurrido

tiempo_transcurrido += delta

# Eliminar el nodo después de 2 segundos

if tiempo_transcurrido >= 25.0:

queue_free()

pass

Ejercicios de animar con Blender y pasar a Godot4.3;

 

Gira la camara3d y por tiempo la borra hace las dos cosas; GDScript para godot 4.3 en 3d;

 extends Camera3D

var target_rotation_x = PI / 2  # Ángulo de rotación objetivo en el eje X

var target_rotation_y = PI / 2  # Ángulo de rotación objetivo en el eje Y

var current_rotation_x = 0.0

var current_rotation_y = 0.0

var rotation_speed = 0.3  # Ajusta esta variable para cambiar la velocidad de rotación

var is_rotating_forward_x = true  # Indica si la rotación en X es en sentido horario

var is_rotating_forward_y = false  # Indica si la rotación en Y es en sentido horario

var tiempo_transcurrido = 0.0 

func _process(delta: float) -> void:

tiempo_transcurrido += delta

# Eliminar el nodo después de 2 segundos

if tiempo_transcurrido >= 8.28:

queue_free()

# Rotación en el eje X

if is_rotating_forward_x:

if current_rotation_x < target_rotation_x:

rotate_x(delta * rotation_speed)

current_rotation_x += delta * rotation_speed

if current_rotation_x >= target_rotation_x:

current_rotation_x = target_rotation_x

is_rotating_forward_x = false

else:

if current_rotation_x > -target_rotation_x:

rotate_x(-delta * rotation_speed)

current_rotation_x -= delta * rotation_speed

if current_rotation_x <= -target_rotation_x:

current_rotation_x = -target_rotation_x

is_rotating_forward_x = true

# Rotación en el eje Y

if is_rotating_forward_y:

if current_rotation_y < target_rotation_y:

rotate_y(delta * rotation_speed)

current_rotation_y += delta * rotation_speed

if current_rotation_y >= target_rotation_y:

current_rotation_y = target_rotation_y

is_rotating_forward_y = false

else:

if current_rotation_y > -target_rotation_y:

rotate_y(-delta * rotation_speed)

current_rotation_y -= delta * rotation_speed

if current_rotation_y <= -target_rotation_y:

current_rotation_y = -target_rotation_y

is_rotating_forward_y = true

Ejemplo de compensar retroceso de un CharacterBody3D cuando dispara; en GDScript para Godot 4.3;

 extends CharacterBody3D

var rotate_speed = 10.1  # Rotation speed

const SPEED = 0.2  # Movement speed

const JUMP_VELOCITY = 4.5  # Jump velocity

var gravity = ProjectSettings.get_setting("physics/3d/default_gravity")

func _ready():

# Replace with function body

pass

func _physics_process(delta):

#translate(Vector3(0,0,-0.005))# PARA UNA CONSTANCIA DE MOVIMIENTO CONTINUO

translate(Vector3(0,0,-0.00))# PARA UNA CONSTANCIA DE MOVIMIENTO CONTINUO

if not is_on_floor():

velocity.y -= gravity * delta  # Apply gravity

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

velocity.y = JUMP_VELOCITY  # Jump

#var input_dir = Input.get_vector("ui_left", "ui_right", "ui_up", "ui_down")  # Get input direction

var input_dir = Input.get_vector("ui_left", "ui_right", "andaradelante", "detenerse")  #ESTE FUNCIONABA ESTE FUNCIONABA

var direction = (transform.basis * Vector3(input_dir.x, 0, input_dir.y)).normalized()

if direction:

velocity.x = direction.x * SPEED  # Move in X direction

velocity.z = direction.z * SPEED  # Move in Z direction

else:

velocity.x = move_toward(velocity.x, 0, SPEED)  # Stop horizontal movement

velocity.z = move_toward(velocity.z, 0, SPEED)  # Stop vertical movement

move_and_slide()  # Apply movement and collisions

var movimiento_vector = Vector3.ZERO  # Initialize movement vector

if Input.is_action_pressed("move_left"):

rotate_y(0.05)  # Rotate on Z axis (positive for left)

if Input.is_action_pressed("move_right"):

rotate_y(-0.05)  # Rotate on Z axis (negative for right)

#translate(Vector3(0.05,0,0))

if Input.is_action_pressed("detenerse"):

translate(Vector3(0.0,0.00,0.005))

rotate_y(-0.00)

if Input.is_action_pressed("andaradelante"):

translate(Vector3(0.0,0.00,-0.005))

rotate_y(-0.00)

move_and_slide()

# Movimiento basado en el botón izquierdo del ratón (acción "mouse_left")

if Input.is_action_pressed("mouse_left"):

# Mover hacia adelante

translate(Vector3(0.0, 0.00, -0.02))

Un ejemplo instancia proyectil, y apunta con rueda y con teclas -z-x-; en el mismo GDScript;

 

extends Area3D

var Bullet = preload("res://EL PROTAGONISTA/BALA PROYECTIL/PROYECTIL.tscn")

#var Bullet2 = preload("res://EL PROTAGONISTA/FOGONAZO PISTOLA/cpu_particles_3dfogonazo.tscn")

func _ready() -> void:

pass # Replace with function body.

func _input(event):

if event is InputEventMouseButton:

if event.button_index == 1 and event.pressed :

#event.button_index == MOUSE_BUTTON_LEFT and event.pressed:

var bullet = Bullet.instantiate()

#var bullet2 = Bullet2.instantiate()

add_child(bullet)

#add_child(bullet2)

func _unhandled_input(event):

if event is InputEventKey and event.pressed:

if event.keycode == KEY_W:

translate(Vector3(0, 0, 0) * get_process_delta_time())  # Temporary movement (consider physics)

#if event.keycode == KEY_

#apply_impulse(Vector3(0,40,4))#ORIGINAL

if event.keycode == KEY_Z:

rotate_x(0.02)

pass

if event.keycode == KEY_X:

rotate_x(-0.02)

pass

if event is InputEventMouseButton:

if event.pressed and event.is_action("mouse_rueda_arriba"):

#if event.action == "mouse_rueda_arriba":

rotate_x(-0.02)

elif event.pressed and event.is_action("mouse_rueda_avajo"):

#elif event.action == "mouse_rueda_avajo":

rotate_x(0.02)

pass

Rotacion de un MeshInstance3D con "z" "x" y con rotacion de rueda del raton; con mapas de entrada"mouse_rueda_arriba" y "mouse_rueda_avajo";

 extends MeshInstance3D

func _input(event):

# Comprobamos si es un evento de teclado

if event is InputEventKey:

if event.pressed:

if event.keycode == KEY_Z:

rotate_x(0.02)

elif event.keycode == KEY_X:

rotate_x(-0.02)

# Comprobamos si es un evento de acción de entrada

elif event is InputEventAction:

pass

#func _input(event):

if event is InputEventMouseButton:

if event.pressed and event.is_action("mouse_rueda_arriba"):

#if event.action == "mouse_rueda_arriba":

rotate_x(-0.02)

elif event.pressed and event.is_action("mouse_rueda_avajo"):

#elif event.action == "mouse_rueda_avajo":

rotate_x(0.02)

Rotacion de un MeshInstance3D presionando "z" y presionando "x";

 extends MeshInstance3D

func _ready() -> void:

pass # Replace with function body.

func _input(event):

if event is InputEventKey and event.pressed:

if event.keycode == KEY_Z:

rotate_x(0.02)

pass

if event.keycode == KEY_X:

rotate_x(-0.02)

pass

Cambiar de escena presionando"1" con un mapa de entrada con nombre"PISO1" para un GDScript de Godot 4.3;

 extends WorldEnvironment

# Called every frame. 'delta' is the elapsed time since the previous frame.

func _process(delta: float) -> void:

# Si se presiona la tecla 1 (mapa de entrada PISO1)

if Input.is_action_just_pressed("PISO1"):

# Cargar la siguiente escena

var siguiente_escena = preload("res://ESCENAS/world_environmentESCENA PRINCIPAL-6-.tscn")

# Cambiar a la escena cargada

get_tree().change_scene_to_packed(siguiente_escena)

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

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

Explicacion: Cambiar de escena presionando"1" con un mapa de entrada con nombre"PISO1" para un GDScript de Godot 4.3;

Ejercicio de animacion manual, echo con blender y pasado a godot 4.3;

 Es muy dificil hacer animaciones de caminar manualmente, pero yo lo estoy consiguiendo, y solo con dos poses una en tijera, y grabada al principio y la otra a la inversa en tijera tambien y grabada al final del video, solo dos puntos de referencia y luego se pasa la animacion a modo ping pong en godot, el resto es sencillisimo, balancear la caveza y la espalda  los brazos,,,,,,,fantastico¡¡¡

GDScript para por tiempo cambiar de escena, tambien salir del juego al presionar escape; version Godot 4.3; varia algo del 4.2;

 extends WorldEnvironment

var tiempo_transcurrido = 0.0  # Variable para almacenar el tiempo transcurrido

# Called when the node enters the scene tree for the first time.

func _ready() -> void:

pass # Replace with function body.

# Called every frame. 'delta' is the elapsed time since the previous frame.

func _process(delta: float) -> void:

#pass

if Input.is_action_pressed("ui_cancel"):

get_tree().quit()

tiempo_transcurrido += delta

# Si han pasado 20 segundos, elimina el nodo

if tiempo_transcurrido >= 18.0:

#queue_free()

var siguiente_escena = preload("res://ESCENAS/world_environmentESCENA PRINCIPAL-5-.tscn")  # Precargar la escena

get_tree().change_scene_to_packed(siguiente_escena)  # Cambiar a la escena precargada (Godot 4.2)

#queue_free()  # Liberar este nodo después del cambio de escena

pass # Replace with function body.

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

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

Nota: los script de Godot 4.3  varian un poco de la version 4.2 , varian en estas lineas 

func _ready() -> void:

pass # Replace with function body.

func _process(delta: float) -> void:

#pass

---------------nota--------------------------------------------

arriba version Godot 4.3

debajo version Godot 4.2

------------------nota----------------------------------------

func _ready() 

pass # Replace with function body.

func _process(delta):

pass

Escala un extends Label3D en eje -x- y en eje -y- con GDScript ;

 extends Label3D

var scale_speed = 0.2

var scale_direction = 1

func _ready() -> void:

pass  # Replace with function body.

func _process(delta: float) -> void:

# Escalado en los ejes X e Y

scale.x += scale_speed * scale_direction * delta

scale.y += scale_speed * scale_direction * delta

# Cambiar la dirección de escalado cuando alcance ciertos límites

if scale_direction == 1 and scale.x >= 0.3:

scale_direction = -1

elif scale_direction == -1 and scale.x <= 0.01:

scale_direction = 1

extends Label3D escalar un Label 3d mediante GDScript;

 extends Label3D

var scale_speed = 0.8

var scale_direction = 1

func _ready() -> void:

pass  # Replace with function body.

func _process(delta: float) -> void:

# Escalado en el eje X

scale.x += scale_speed * scale_direction * delta

# Cambiar la dirección de escalado cuando alcance ciertos límites

if scale_direction == 1 and scale.x >= 0.3:

scale_direction = -1

elif scale_direction == -1 and scale.x <= 0.01:

scale_direction = 1

GDScript camara rota en diversas direcciones, muy bueno;

 extends Camera3D

var target_rotation_x = PI / 2  # Ángulo de rotación objetivo en el eje X

var target_rotation_y = PI / 4  # Ángulo de rotación objetivo en el eje Y

var current_rotation_x = 0.0

var current_rotation_y = 0.0

var rotation_speed = 0.7  # Ajusta esta variable para cambiar la velocidad de rotación

var is_rotating_forward_x = true  # Indica si la rotación en X es en sentido horario

var is_rotating_forward_y = false  # Indica si la rotación en Y es en sentido horario

func _process(delta: float) -> void:

# Rotación en el eje X

if is_rotating_forward_x:

if current_rotation_x < target_rotation_x:

rotate_x(delta * rotation_speed)

current_rotation_x += delta * rotation_speed

if current_rotation_x >= target_rotation_x:

current_rotation_x = target_rotation_x

is_rotating_forward_x = false

else:

if current_rotation_x > -target_rotation_x:

rotate_x(-delta * rotation_speed)

current_rotation_x -= delta * rotation_speed

if current_rotation_x <= -target_rotation_x:

current_rotation_x = -target_rotation_x

is_rotating_forward_x = true

# Rotación en el eje Y

if is_rotating_forward_y:

if current_rotation_y < target_rotation_y:

rotate_y(delta * rotation_speed)

current_rotation_y += delta * rotation_speed

if current_rotation_y >= target_rotation_y:

current_rotation_y = target_rotation_y

is_rotating_forward_y = false

else:

if current_rotation_y > -target_rotation_y:

rotate_y(-delta * rotation_speed)

current_rotation_y -= delta * rotation_speed

if current_rotation_y <= -target_rotation_y:

current_rotation_y = -target_rotation_y

is_rotating_forward_y = true