GDScript para Godot 4.5 provocar un sonido al entrar en un area y cerrar otro que venia por defecto;

 extends Area3D

# --- Referencia al Nodo de Sonido de Premio/Ganancia (EXISTENTE) ---

# El nodo AudioStreamPlayer3D debe ser un hijo de este Area3D.

@onready var audio_player: AudioStreamPlayer3D = $AudioStreamPlayer3D

# --- NUEVA REFERENCIA: Sonido de Daño (A DETENER) ---

# ⚠️ IMPORTANTE: Esta ruta DEBE ser correcta desde la raíz de este script.

#@onready var audio_player_daño = $CollisionShape3D/AudioStreamPlayer3DSONIDODEMEMATANLENTO

@onready var audio_player_daño = $"../CharacterBody3D/Area3D cuando entra en area MATAEROE/CollisionShape3D/AudioStreamPlayer3DSONIDODEMEMATANLENTO"

# --- Control de Cooldown (Enfriamiento) ---

# Evita que el sonido se repita frenéticamente por una sola colisión.

var can_play_sound: bool = true

const COOLDOWN_TIME: float = 0.5 # Tiempo de espera para poder reproducir de nuevo (0.5 segundos)

# --- FUNCIÓN DE COLISIÓN ---

# ⚠️ Conecta la señal 'area_entered' del Area3D a esta función.

func _on_area_entered(area: Area3D) -> void:

# 🔊 LÓGICA AÑADIDA: Detener el sonido de peligro 

if is_instance_valid(audio_player_daño) and audio_player_daño.playing:

audio_player_daño.stop()

print("Sonido de peligro detenido.")

# 1. Comprueba si el sonido de premio puede reproducirse

if can_play_sound and audio_player != null:

# 2. Reproduce el sonido de premio

audio_player.play()

print("Sonido de premio/ganancia generado.")

# 3. Inicia el cooldown

can_play_sound = false

# 4. Usa un Timer de la escena para restablecer la capacidad de reproducción después del cooldown.

get_tree().create_timer(COOLDOWN_TIME).timeout.connect(func(): can_play_sound = true)

# --- Comprobación Inicial ---

func _ready() -> void:

if audio_player == null:

push_error("ERROR: El nodo AudioStreamPlayer3D (premio) no fue encontrado. Revisa la ruta '$AudioStreamPlayer3D'.")

# Opcional: Comprobar el sonido de daño al inicio

if audio_player_daño == null:

push_error("ERROR: El nodo AudioStreamPlayer3DSONIDODEMEMATANLENTO no fue encontrado. Revisa la ruta.")

🔉🔉🔉🔉🔉🔉🔉🔉🔉🔉🔉🔉🔉🔉🔉🔉🔉🔉🔉🔉🔉🔉🔉🔉🔉🔉🔉🔉🔉🔉

Explicacion: La idea es que el player es herido por un enemigo, tiene consigo un sonido de apagamiento muerte, entonces cuando toca el botiquin ese sonido desaparece y aparece el sonido de energia nueva recuperada, esto va acompañado de un corazon que se va encojiendo, y que al tocar el botiquin se agranda asta estar sano...............

💗💗💗💗💗💗💗💗💗💗💗💗💗💗💗💗💗💗💗💗💗💗💗💗💗💗💗💗💗💗💗💗

extends Area3D

# Define la ruta de la escena de destino

@export var destination_scene_path: String = "res://ESCENAS/PROTAMUERTE.tscn"

# Define el tiempo de espera antes de cambiar de escena

const DELAY_TIME: float = 44.0 

# Bandera para asegurar que la acción solo se ejecute una vez

var is_scene_change_scheduled: bool = false 

# --- VARIABLES DEL ENCOGIMIENTO ---

@onready var corazon_mesh = $MeshInstance3D # ⚠️ Asegúrate de que esta ruta sea correcta

var is_shrinking: bool = false

var elapsed_shrink_time: float = 0.0

# --- VARIABLE CRÍTICA PARA CANCELAR EL TEMPORIZADOR ---

var active_timer: SceneTreeTimer = null

# --- VARIABLES DE SONIDO (BOTIQUÍN) ---

@onready var audio_player_botikin = $"Area3DBOTIKIN/AudioStreamPlayer3D" 

var can_play_botikin_sound: bool = true

const BOTIKIN_COOLDOWN_TIME: float = 1.0 

# --- NUEVA VARIABLE DE SONIDO (DAÑO) ---

# ⚠️ ¡IMPORTANTE! Asegúrate de que el AudioStreamPlayer3D exista exactamente en esta ruta:

@onready var audio_player_daño = $CollisionShape3D/AudioStreamPlayer3DSONIDODEMEMATANLENTO

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

## FUNCIÓN DE DAÑO (INICIA / IGNORA ATAQUES)

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

# Se ejecuta al recibir daño (conecta la señal 'area_entered' del área de daño)

func _on_area_entered(area):

# Si la secuencia ya está activa, ignoramos el nuevo ataque para CONGELAR el tiempo.

if is_scene_change_scheduled:

print("Ataque ignorado (CONGELACIÓN ACTIVA).")

return # Salimos de la función sin reiniciar

# 🔊 Reproducir el sonido de DAÑO al inicio de la secuencia

if is_instance_valid(audio_player_daño):

audio_player_daño.play()

# --- INICIO DE LA SECUENCIA (SOLO SI NO ESTABA ACTIVA) ---

set_monitoring(false) # Deshabilita el monitoreo para no recibir más daño

is_scene_change_scheduled = true

is_shrinking = true

elapsed_shrink_time = 0.0 

print("Colisión de daño detectada. Secuencia de muerte INICIADA.")

# 3. Crear y almacenar el nuevo temporizador

active_timer = get_tree().create_timer(DELAY_TIME)

active_timer.timeout.connect(_start_scene_change)

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

## FUNCIÓN DE SALVACIÓN (TOCA EL BOTIQUÍN)

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

func _on_area_3dbotikin_area_entered(area: Area3D) -> void:

# Solo actúa si la secuencia de muerte está activa

if is_scene_change_scheduled:

# --- LÓGICA DE SONIDO DEL BOTIQUÍN ---

if can_play_botikin_sound and is_instance_valid(audio_player_botikin):

audio_player_botikin.play()

can_play_botikin_sound = false

# Reinicia el cooldown

get_tree().create_timer(BOTIKIN_COOLDOWN_TIME).timeout.connect(func(): can_play_botikin_sound = true)

# Detener y cancelar la secuencia

is_shrinking = false 

is_scene_change_scheduled = false

if active_timer != null:

active_timer.timeout.disconnect(_start_scene_change)

active_timer = null

print("¡SALVADO! El botiquín ha detenido y restablecido el sistema.")

# Restaurar la escala y el contador de tiempo a cero (DESESCALADA)

if is_instance_valid(corazon_mesh):

corazon_mesh.scale = Vector3.ONE * 1.0 # Vuelve a tamaño completo

elapsed_shrink_time = 0.0              # Reinicia el tiempo

# Restaurar la capacidad de recibir daño

set_monitoring(true)

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

## LÓGICA DE ANIMACIÓN (ENCOGIMIENTO)

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

func _process(delta: float):

# Solo si el encogimiento ha sido iniciado y el mesh es válido

if is_shrinking and is_instance_valid(corazon_mesh):

elapsed_shrink_time += delta

# Calcular el factor de encogimiento

var scale_factor = 1.0 - (elapsed_shrink_time / DELAY_TIME)

scale_factor = max(0.0, scale_factor) 

# Aplicar la nueva escala

corazon_mesh.scale = Vector3.ONE * scale_factor

# Si el tiempo ha expirado, detenemos la animación

if elapsed_shrink_time >= DELAY_TIME:

is_shrinking = false

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

## FUNCIÓN DE CAMBIO DE ESCENA

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

func _start_scene_change():

# Forzamos la escala final a cero

if is_instance_valid(corazon_mesh):

corazon_mesh.scale = Vector3.ZERO

var error = get_tree().change_scene_to_file(destination_scene_path)

if error != OK:

push_error("Error al intentar cambiar de escena: ", error)

else:

print("¡GAME OVER! Cambio de escena realizado.")👆👆👆👆👆👆👆👆👆👆👆👆👆👆👆👆👆👆👆👆👆👆👆👆👆👆👆👆👆👆👆👆👆👆👆👆👆👆👆👆👆👆👆👆👆👆👆👆👆👆👆👆👆👆👆👆👆👆👆👆👆👆👆👆👆👆👆👆👆👆👆

Explicacion: el GDscript de arriba pertenece al player esta linea es la que produce el sonido de muerte lenta desinflar el corazon    $CollisionShape3D/AudioStreamPlayer3DSONIDODEMEMATANLENTO--------------------------------------------------------------------------------------------------------------------------------------------------------------La verdad es complicado de entender, yo me ayudo de la IA que hace los GDScripts, de todas formas es dificil hay que saber que se quiere hacer, hay que saber donde ponerlo, hay que saber las rutas de los archibos de sonidos, colocarlos correctamente al arrastrarlos al GDScript, tiene miga todo incluso si los GDScript te lo hace una IA, tambien tienes que pensar, pero en fin es fantastica la ayuda que ofrece hoy en dia la IA con estos temas.

GDScript para Godot 4.5, 3d, cañon dispara el solo, y al ser impactado es destruido.;

 extends Area3D

# --- Variables Originales del Disparo ---

var Bullet = preload("res://PROTAGONISTA/area_3d_proyectil_en_si_mismoENEMIGO.tscn")

var timer = Timer.new()

var tiempo_disparo = 0.5  # Tiempo entre disparos en segundos

# --- NUEVA VARIABLE: Escena de la Astilla ---

# ⚠️ CAMBIA ESTA RUTA por la ruta real de tu escena "Astilla.tscn"

const ASTILLA_SCENE_PATH = "res://BARCO ELEMENTOS TEXTURAS/CAÑONES/TIBURON REVENTAO-3-.tscn"

var Astilla = preload(ASTILLA_SCENE_PATH) 

func _ready():

# Lógica original del Timer para disparar

add_child(timer)

timer.timeout.connect(_on_timer_timeout)

timer.start(tiempo_disparo)

# ⚠️ MUY IMPORTANTE: Conecta la señal 'area_entered' de este Area3D

# en el editor de Godot a la función '_on_area_entered'.

func _on_timer_timeout():

var bullet = Bullet.instantiate()

add_child(bullet)

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

## FUNCIÓN DE COLISIÓN (Se ejecuta al tocar)

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

# Se ejecuta cuando otro Área entra en la nuestra.

func _on_area_entered(area: Area3D):

_destroy_and_instantiate()

# Si quieres que se destruya al tocar un cuerpo físico (como el jugador o un RigidBody3D),

# usa también la señal 'body_entered'.

func _on_body_entered(body: Node3D):

_destroy_and_instantiate()

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

## LÓGICA DE INSTANCIACIÓN Y DESTRUCCIÓN

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

func _destroy_and_instantiate():

# 1. Instanciar la Astilla

var astilla = Astilla.instantiate()

# 2. Posicionar la Astilla en la ubicación de este nodo

# Usamos get_parent() para añadir la astilla al mismo nivel que este nodo,

# asegurando que se muestre correctamente en el mundo.

if is_instance_valid(get_parent()):

get_parent().add_child(astilla)

astilla.global_transform = global_transform

print("Colisión detectada. Instanciando Astilla y destruyendo nodo actual.")

# 3. Eliminar este nodo del árbol de la escena

queue_free()

https://itch.io/s/165572/halloween-sale-2025;

 https://itch.io/s/165572/halloween-sale-2025

Nuevo juego en desarrollo con Godot 4.5, pronto a la venta en https://perico415.itch.io/;

https://perico415.itch.io/

extends Skeleton3D GDScript lo gira como peonza en su eje -y-;

 extends Skeleton3D

# Archivo: GirarComoPeonza.gd

 # O el nodo al que se adjunte (CharacterBody3D, Skeleton3D, etc.)

# --- PROPIEDADES EXPORTADAS ---

# Velocidad de rotación en grados por segundo.

# Puedes ajustar este valor en el Inspector.

@export var velocidad_giro_grados_por_segundo: float = 360.0 # Una vuelta completa por segundo

# --- FUNCIÓN DE PROCESAMIENTO ---

func _process(delta: float):

# La rotación se aplica en la función _process, que se llama en cada frame.

# 1. Calcular el ángulo de rotación para este frame:

#    (Velocidad en grados/seg) * (Tiempo transcurrido desde el último frame)

var angulo_delta = deg_to_rad(velocidad_giro_grados_por_segundo) * delta

# 2. Aplicar la rotación al nodo actual (self):

#    'rotate_y(ángulo)' aplica una rotación alrededor del eje Y local del nodo.

#    Esto causa el efecto de "peonza" o "trompo".

rotate_y(angulo_delta)

VIDEOS QUE INSPIRAN PARA MOTIVARTE A TRABAJAR MUY INTERESANTES, Y MUY IMPORTANTE PARA NO PARAR. INTENTO APLICARLO A MI AFICION;

https://youtu.be/ju-qiq9apig

https://youtu.be/8uYv5-OcFn8 

Lanzar piedras gdscript godot 4.4; 3d;

 extends CharacterBody3D

var rotate_speed = 10.1

const SPEED = 99.09

const JUMP_VELOCITY = 22.3

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

@export var FORWARD_JUMP_AMOUNT = -4.7

# --- NUEVAS VARIABLES PARA LANZAR LA PIEDRA ---

# ¡IMPORTANTE! Cambia esta ruta por la de tu escena de la piedra

var stone_scene = preload("res://PROTAGONISTA/BONBADEMANO.tscn")

@export var throw_strength: float = 15.0 

# --- NUEVA VARIABLE para la rotación con las teclas Z y X ---

var player_mesh: MeshInstance3D

func _ready():

# --- OBTENER REFERENCIA al nodo MeshInstance3D ---

# Asegúrate de que "MeshInstance3D" es el nombre exacto de tu nodo 3D.

player_mesh = get_node("MeshInstance3D")

# --- NUEVA FUNCIÓN para detectar el clic del ratón ---

func _unhandled_input(event):

if event.is_action_pressed("mouse_left"):

throw_stone()

func _physics_process(delta):

# Aplicar gravedad

if not is_on_floor():

velocity.y -= gravity * delta

# Movimiento de Salto

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

velocity.y = JUMP_VELOCITY

velocity += -transform.basis.z * FORWARD_JUMP_AMOUNT

# --- LÓGICA de rotación para la tecla 'Z' y 'X' (ahora afecta al mesh) ---

if Input.is_key_pressed(KEY_Z):

if player_mesh:

player_mesh.rotate_object_local(Vector3.FORWARD, 1.0 * delta)

if Input.is_key_pressed(KEY_X):

if player_mesh:

player_mesh.rotate_object_local(Vector3.FORWARD, -1.0 * delta)

# --- Tu lógica de movimiento y rotación original ---

if Input.is_action_pressed("GIRAIZQUIERDACONA"):

rotate_y(0.05)

if Input.is_action_pressed("GIRADERECHACOND"):

rotate_y(-0.05)

if Input.is_action_pressed("ANDAALANTECONW"):

translate(Vector3(0.0,0,0.11))

rotate_y(-0.00)

if Input.is_action_pressed("E"):

translate(Vector3(0.01,0,0.22))

rotate_y(-0.00)

if Input.is_action_pressed("ANDAATRASCONS"):

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

rotate_y(-0.00)

rotate_y(rotation_input.y * delta * rotate_speed)

rotate_x(rotation_input.x * delta * rotate_speed)

rotation_input = Vector2.ZERO

var input_dir = Input.get_vector("ui_right", "ui_left", "ui_down", "ui_up")

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

if direction:

velocity.x = direction.x * SPEED

velocity.z = direction.z * SPEED

else:

velocity.x = move_toward(velocity.x, 0, SPEED)

velocity.z = move_toward(velocity.z, 0, SPEED)

move_and_slide()

var rotation_input: Vector2 = Vector2.ZERO

# --- FUNCIÓN para lanzar la piedra ---

func throw_stone():

var stone_instance = stone_scene.instantiate()

# Posicionar la piedra en la misma posición y rotación que el jugador

stone_instance.global_transform = global_transform

# Obtener la dirección "hacia adelante" del jugador

var direction = global_transform.basis.z

# Aplicar una fuerza inicial para lanzarla

stone_instance.apply_central_impulse(direction * throw_strength)

# Añadir la piedra a la escena principal

get_parent().add_child(stone_instance)

Animar personaje en godot 4.4. "RELAJO""CAMINA""BOMBAMANO""CORRECACA";

 extends Node3D

var animacion_actual = "RELAJO"

func _ready():

$AnimationPlayer.play(animacion_actual)

func _physics_process(delta):

# NUEVO CÓDIGO: Salir del juego al presionar la tecla Escape

if Input.is_action_just_pressed("ui_cancel"):

get_tree().quit()

var alguna_tecla_pulsada = false

# Comprobamos si alguna de las acciones está siendo presionada

if Input.is_action_pressed("achazo") or \

   Input.is_action_pressed("mouse_left") or \

   Input.is_action_pressed("mouse_right") or \

   Input.is_action_pressed("DESDEABAJOPUÑETASO") or \

   Input.is_action_pressed("ANDAALANTECONW") or \

   Input.is_action_pressed("ANDAATRASCONS") or \

   Input.is_action_pressed("DESDEABAJOPUÑETASO") or \

   Input.is_action_pressed("DESDEABAJOPUÑETASO") or \

   Input.is_action_pressed("CORRECACA") or \

   Input.is_action_pressed("PATADAMEDIA") or \

   Input.is_action_pressed("DESDEABAJOPUÑETASO") or \

   Input.is_action_pressed("ui_accept") or \

   Input.is_action_pressed("A") or \

   Input.is_action_pressed("D"):

alguna_tecla_pulsada = true

# Animación de ESPADAZO

if Input.is_action_pressed("achazo") or Input.is_action_pressed("mouse_left"):

if animacion_actual != "BOMBAMANO":

$AnimationPlayer.play("BOMBAMANO")

#$AnimationPlayer/AudioStreamPlayer3D.play("MakeHuman default skeleton|ESPADAZO")

animacion_actual = "BOMBAMANO"

# Animación de ATRABESAR

elif Input.is_action_pressed("mouse_right") or Input.is_action_pressed("DESDEABAJOPUÑETASO"):

if animacion_actual != "BOMBAMANO":

$AnimationPlayer.play("BOMBAMANO")

animacion_actual = "BOMBAMANO"

# Animación de ANDAR

elif Input.is_action_pressed("ANDAALANTECONW") or Input.is_action_pressed("A") or Input.is_action_pressed("D"):

if animacion_actual != "CAMINA":

$AnimationPlayer.play("CAMINA")

animacion_actual = "CAMINA"

elif Input.is_action_pressed("ANDAATRASCONS") or Input.is_action_pressed("A") or Input.is_action_pressed("D"):

if animacion_actual != "CAMINA":

$AnimationPlayer.play("CAMINA")

animacion_actual = "CAMINA"

elif Input.is_action_pressed("PUÑETAZO") or Input.is_action_pressed("A") or Input.is_action_pressed("D"):

if animacion_actual != "CAMINA":

$AnimationPlayer.play("CAMINA")

animacion_actual = "CAMINA"

elif Input.is_action_pressed("CORRECACA") or Input.is_action_pressed("E") or Input.is_action_pressed("E"):

if animacion_actual != "CORRECACA":

$AnimationPlayer.play("CORRECACA")

animacion_actual = "CORRECACA"

elif Input.is_action_pressed("PATADAMEDIA") or Input.is_action_pressed("R") or Input.is_action_pressed("R"):

if animacion_actual != "BOMBAMANO":

$AnimationPlayer.play("BOMBAMANO")

animacion_actual = "BOMBAMANO"

elif Input.is_action_pressed("ui_accept") or Input.is_action_pressed("A") or Input.is_action_pressed("D"):

if animacion_actual != "CAMINA":

$AnimationPlayer.play("CAMINA")

animacion_actual = "CAMINA"

elif Input.is_action_just_pressed("PUÑETAZO") or Input.is_action_pressed("A") or Input.is_action_pressed("D"):

if animacion_actual != "CAMINA":

$AnimationPlayer.play("CAMINA")

animacion_actual = "CAMINA"

# Si no se presiona ninguna tecla, volvemos a la animación de descanso

elif not alguna_tecla_pulsada:

if animacion_actual != "RELAJO":

$AnimationPlayer.play("RELAJO")

animacion_actual = "RELAJO"

elif Input.is_action_pressed("achazo") or Input.is_action_pressed("A") or Input.is_action_pressed("D"):

if animacion_actual != "CAMINA":

$AnimationPlayer.play("CAMINA")

animacion_actual = "CAMINA"

Me inspiro Medal of Honor.;

 

https://gamejolt.com/@paco415/games

El video que compartiste es un interesante tutorial y gameplay de un juego que creaste, claramente inspirado en la saga de Medal of Honor [00:11].

En el video, explicas que tu juego es un tributo a la obra del director Steven Spielberg, el cual te inspiró para desarrollarlo [00:32].

El juego, que también tiene un final que funciona como homenaje a Medal of Honor, tiene como objetivo que el jugador, un soldado estadounidense, se infiltre en una base de bunkers alemanes y encuentre una medicina especial para ganar [01:41].

El video muestra un recorrido completo de la jugabilidad, incluyendo:

Cómo correr y disparar [03:31].

Que el juego puede reiniciarse al ser eliminado pulsando la tecla 'O' [02:34].

Cómo lanzar granadas con la tecla 'M' [04:23].

Al final, se puede ver la pantalla de "Misión cumplida" que aparece al completar el objetivo [09:56]. El video termina con unos créditos que, según comentas, son un tributo al juego original [10:45].

Videojuego para todos los publicos de piratas;

 

Promocionando mi trabajo actual lo ultimo de lo ultimo, aunque no esta terminado ni mucho menos, pero me publicito con humildad;

 El video es una presentación de un juego de piratas en desarrollo, creado por ti. En él, ofreces un tutorial detallado de las características del juego.

Según el video, el objetivo principal es navegar un barco pirata, destruir enemigos y resolver acertijos para poder acceder a una habitación misteriosa que te llevará a ganar el juego [06:25].

También describes las mecánicas de juego, incluyendo:

Cómo controlar al pirata y sus ataques [04:43].

Cómo usar el cañón para destruir a los enemigos, como los tiburones [03:33], e incluso a un pirata en un mástil [11:46].

Cómo manejar la cámara para ver desde diferentes ángulos, incluso bajo el agua [02:34].

Algo importante que mencionas es que el juego todavía está en desarrollo [12:21] y que, si lo publicas en Itch.io, tendría que ser un juego para todas las audiencias para cumplir con las políticas de la plataforma [14:19].

instanciando un RigidBody3D con gravedad que cae a los 3 segundos; automaticamente cada 3 segundos;

 extends Area3D

# Carga la escena de la bola para poder instanciarla.

var bola_proyectada_scene = preload("res://PIRATAENCUBETA/PROLLECTILES DE PIRATA EN CUBIERTA/RIGBODIQUECAEarea_3dBOLAPROYECTADA.tscn")

# Variable para contar el tiempo restante para la próxima instancia.

var tiempo_restante: float = 3.0

func _process(delta: float) -> void:

# Resta el tiempo transcurrido (delta) al contador.

tiempo_restante -= delta

# Comprueba si el tiempo ha llegado a cero o menos.

if tiempo_restante <= 0.0:

# Llama a la función para instanciar la bola.

instanciar_bola()

# Reinicia el contador para que el ciclo se repita cada 3 segundos.

tiempo_restante = 3.0

func instanciar_bola() -> void:

# Instancia la escena pre-cargada.

var nueva_bola = bola_proyectada_scene.instantiate()

# Asigna la posición de la nueva instancia a la del nodo actual.

nueva_bola.global_position = self.global_position

# Añade la instancia como hijo del nodo padre.

get_parent().add_child(nueva_bola)

Cambiar resolucion de pantalla en los juegos de godot 4.4;

extends MultiMeshInstance3D

# Definimos las tres resoluciones.

var resolucion_1: Vector2i = Vector2i(1920, 1080)

var resolucion_2: Vector2i = Vector2i(1280, 720) # He corregido el 12800 a 1280.

var resolucion_3: Vector2i = Vector2i(800, 600)

func _input(event: InputEvent) -> void:

# Si presionas RESOLUCION1, cambia a 1920x1080

if event.is_action_pressed("RESOLUCION1"):

DisplayServer.window_set_size(resolucion_1)

# Opcional: para que se vea en ventana y no en pantalla completa

DisplayServer.window_set_mode(DisplayServer.WINDOW_MODE_WINDOWED)

# Si presionas RESOLUCION2, cambia a 1280x720

if event.is_action_pressed("RESOLUCION2"):

DisplayServer.window_set_size(resolucion_2)

DisplayServer.window_set_mode(DisplayServer.WINDOW_MODE_WINDOWED)

# Si presionas RESOLUCION3, cambia a 800x600

if event.is_action_pressed("RESOLUCION3"):

DisplayServer.window_set_size(resolucion_3)

DisplayServer.window_set_mode(DisplayServer.WINDOW_MODE_WINDOWED)

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

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

Explicacion: este GDScript cambia la resolucion de pantallas en 3 tamaños, tecla -1- con mapa de entrada llamado "RESOLUCION1" tecla-2- "RESOLUCION2" tecla -3- "RESOLUCION3" resoluciones de  1920x1080  de  1280x720  de  800x600.

¡¡Trabajo duro!!;

 Esa es una descripción muy precisa del "trabajo duro" en el desarrollo de videojuegos y en la programación. No es un cansancio físico, sino un agotamiento mental que se deriva de la concentración y la repetición.

Tienes toda la razón, es un trabajo mentalmente agotador:

• Concentración Intensa: Estar horas concentrado en una pantalla, resolviendo problemas y buscando el origen de los errores, consume muchísima energía mental. Es un tipo de esfuerzo que el cerebro no está acostumbrado a sostener por períodos largos.

• Tareas Repetitivas y Paciencia: Afinar pequeños detalles, hacer ajustes mínimos en los valores de un script, o simplemente probar y volver a probar algo una y otra vez requiere una paciencia y una disciplina que no todo el mundo tiene.

• La Lucha contra lo invisible: Con las tareas físicas, ves el progreso: la pared se construye, la zanja se excava. En la programación, a veces trabajas durante horas y no ves un cambio visible hasta que finalmente encuentras ese pequeño error que lo arregla todo.

Ese tipo de trabajo es el que diferencia a un aficionado de un profesional. Esa constancia y esa capacidad para seguir adelante a pesar de la frustración mental es lo que al final se traduce en un producto de calidad. Es un tipo de "músculo" que se entrena con la práctica y la disciplina.

Giros locos de un pez muerto y luego se borra pasados unos segundos;

 extends Node3D

# Velocidad máxima de rotación en radianes por segundo.

# Puedes ajustar este valor en el Inspector para controlar la "locura".

@export var max_rotation_speed: float = 10.0

func _process(delta: float) -> void:

# Genera un valor de rotación aleatorio para cada eje en cada fotograma

var random_x_rotation = (randf() * 2 - 1) * max_rotation_speed

var random_y_rotation = (randf() * 2 - 1) * max_rotation_speed

var random_z_rotation = (randf() * 2 - 1) * max_rotation_speed

# Rota el nodo en los tres ejes usando los valores aleatorios

# 'delta' asegura que la rotación sea suave e independiente de los FPS

rotate_x(random_x_rotation * delta)

rotate_y(random_y_rotation * delta)

rotate_z(random_z_rotation * delta)

func _ready():

# get_tree().create_timer(3.0) crea un temporizador de 3 segundos.

# .timeout.connect(queue_free) conecta la señal 'timeout' del temporizador

# con el método 'queue_free()' de este mismo nodo.

# queue_free() borra el nodo de forma segura.

get_tree().create_timer(4.8).timeout.connect(queue_free)

Instancia 4 elementos funciona en godot 4.4;

 extends Area3D

var Esferauno = preload("res://BARCO ELEMENTOS TEXTURAS/CAÑONES/TIBURON REVENTAO-3-.tscn")

var Esferauno1 = preload("res://BARCO ELEMENTOS TEXTURAS/CAÑONES/TIBURON REVENTAO-3-.tscn")

var Esferauno2 = preload("res://BARCO ELEMENTOS TEXTURAS/AGUA/mesh_instance_3d_salpicadurasDEL TIBURON MUERTO.tscn")

var Esferauno3 = preload("res://BARCO ELEMENTOS TEXTURAS/TIBURON/ACUARIUM/TIBURON/TIBURONSERETUERCEMUERTO-.tscn")

func _ready() -> void:

$AnimationPlayer.play("TIBURONDESDEAREAMUEVO")

pass

func _process(delta: float) -> void:

pass

func _on_area_entered(area: Area3D) -> void:

var parent = get_parent() # Obtiene una referencia al nodo padre

if parent and parent is CharacterBody3D:

var parent_global_transform = parent.global_transform # Guarda la transformación global del padre

# Instancia la escena de "POLICIA NOKEADO"

var policia_nokeado_instancia = Esferauno.instantiate()

get_tree().root.add_child(policia_nokeado_instancia) # Añade la instancia a la raíz del árbol de escena

policia_nokeado_instancia.global_transform = parent_global_transform # Establece su posición a la del padre borrado

parent.queue_free() # Borra el nodo padre (CharacterBody3D)

var collision_shape_cubo = parent.get_node_or_null("CollisionShape3D")

if collision_shape_cubo:

collision_shape_cubo.queue_free()

get_node("CollisionShape3D").queue_free()

# Si deseas que esta Area3D también se borre, descomenta la siguiente línea

# queue_free()

pass

func _on_area_exited(area: Area3D) -> void:

# Ahora, Esferauno (POLICIA NOKEADO) ya no se instanciará aquí.

# Si Esferauno1 (DIENTES Y SANGRE) debe seguir apareciendo al salir, déjalo aquí.

var Esferauno1_instancia = Esferauno1.instantiate()

add_child(Esferauno1_instancia) # Puedes decidir si quieres que esto sea hijo de esta Area3D o de la raíz.

var Esferauno2_instancia = Esferauno2.instantiate()

add_child(Esferauno2_instancia) # Puedes decidir si quieres que esto sea hijo de esta Area3D o de la raíz.

var Esferauno3_instancia = Esferauno3.instantiate()

add_child(Esferauno3_instancia) # Puedes decidir si quieres que esto sea hijo de esta Area3D o de la raíz.

pass

Giros locos en ejes -y-z-x alternando y a lo loco; simulara un pez cazado;

 extends Node3D

# Velocidad máxima de rotación en radianes por segundo.

# Puedes ajustar este valor en el Inspector para controlar la "locura".

@export var max_rotation_speed: float = 10.0

func _process(delta: float) -> void:

# Genera un valor de rotación aleatorio para cada eje en cada fotograma

var random_x_rotation = (randf() * 2 - 1) * max_rotation_speed

var random_y_rotation = (randf() * 2 - 1) * max_rotation_speed

var random_z_rotation = (randf() * 2 - 1) * max_rotation_speed

# Rota el nodo en los tres ejes usando los valores aleatorios

# 'delta' asegura que la rotación sea suave e independiente de los FPS

rotate_x(random_x_rotation * delta)

rotate_y(random_y_rotation * delta)

rotate_z(random_z_rotation * delta)

Instanciar 3 elementos para simular una caza en el mar, ademas anima un objeto en una simulacion del mar;

 extends Area3D

var Esferauno = preload("res://BARCO ELEMENTOS TEXTURAS/CAÑONES/TIBURON REVENTAO-3-.tscn")

# Nota: "Esferauno1" está precargando la misma escena que "Esferauno".

# Si son escenas diferentes, por favor revisa la ruta.

var Esferauno1 = preload("res://BARCO ELEMENTOS TEXTURAS/CAÑONES/TIBURON REVENTAO-3-.tscn")

var Esferauno2 = preload("res://BARCO ELEMENTOS TEXTURAS/AGUA/mesh_instance_3d_salpicaduras.tscn")

func _ready() -> void:

$AnimationPlayer.play("TIBURONDESDEAREAMUEVO")

func _on_area_entered(area: Area3D) -> void:

var parent = get_parent()

if parent and parent is CharacterBody3D:

var parent_global_transform = parent.global_transform

# Instancia la escena del "POLICIA NOKEADO"

var policia_nokeado_instancia = Esferauno.instantiate()

get_tree().root.add_child(policia_nokeado_instancia)

policia_nokeado_instancia.global_transform = parent_global_transform

# Borra el nodo padre (CharacterBody3D)

parent.queue_free()

# Instancia y añade Esferauno1

var Esferauno1_instancia = Esferauno1.instantiate()

Esferauno1_instancia.global_transform = parent_global_transform

get_tree().root.add_child(Esferauno1_instancia)

# Instancia y añade Esferauno2 (salpicaduras)

var Esferauno2_instancia = Esferauno2.instantiate()

Esferauno2_instancia.global_transform = parent_global_transform

get_tree().root.add_child(Esferauno2_instancia)

# Borra el CollisionShape3D de este nodo

var collision_shape = get_node_or_null("CollisionShape3D")

if collision_shape:

collision_shape.queue_free()

# Borra el propio nodo Area3D para evitar errores futuros

queue_free()

Me tratan de esquizofrenico¡¡¡¡;

https://evefysh.itch.io/ 

https://itch.io/profile/evefysh

https://perico415.itch.io/mmacabre-and-gothic/comments

https://perico415.itch.io/

EveFyshHace 14 horas

¿El desarrollador está mentalmente enfermo? No lo digo como un insulto, simplemente literalmente jugando todos sus juegos y me da las vibraciones de un esquizofrénico tratando de hacer un juego

Alo cual respondi:  

Vincent van Gogh, pintor holandés, también tenía problemas mentales, y mira como está valorada su obra.

AL FINAL BORRE LA CRITICA Y LA RESPUESTA, NO ME APORTA NADA, SOLO HACE PERDER EL TIEMPO, QUIERO PENSAR QUE LAS CRITICAS HAN DE SER RESPETUOSAS Y DE SUMAR NO DE RESTAR.

En este enlace una critica constructiva

Si, el juego se puede ampliar más, claro, y pulir más, también es cierto, decidí publicarlo porque es completo, tiene una trama mínima y un final donde ganas la partida al escapar de la persecución...vaya, vamos a pasar un enlace de YouTube donde aparezca el juego completo, hay partidas muy cortas pero todas tienen un final razonable para que sea coherente.

Dispara en Godot 4.4 instanciando y moviendo el cañon en 4 angulos;

 extends Area3D

var Bullet = preload("res://BARCO ELEMENTOS TEXTURAS/CAÑONES/area_3dprollectil_cañon.tscn")

var fire_cooldown: float = 1.7

var can_fire: bool = true

var bullet_speed: float = 20.0

var fire_timer: Timer

# Asegúrate de que esta variable exista. La agregué aquí.

var rotation_speed: float = 1.0

func _ready() -> void:

fire_timer = Timer.new()

add_child(fire_timer)

fire_timer.wait_time = fire_cooldown

fire_timer.one_shot = true

fire_timer.timeout.connect(func(): can_fire = true)

func _process(delta: float) -> void:

# Lógica de Disparo

if Input.is_action_pressed("DISPARACAÑON") and can_fire:

can_fire = false

instantiate_bullet()

fire_timer.start()

# Lógica de Rotación

var rotation_direction: float = 0.0

if Input.is_action_pressed("girav"):

rotation_direction = 1.0

elif Input.is_action_pressed("girab"):

rotation_direction = -1.0

# Aplica la rotación en el eje X.

#rotate_x(rotation_speed * rotation_direction * delta)

rotate_x(delta * rotation_speed * rotation_direction  )

if Input.is_action_pressed("giraz"):   

rotation_direction = 1.0

# Si se presiona la acción "girax", gira en la dirección opuesta.

elif Input.is_action_pressed("girax"):

rotation_direction = -1.0

# Aplica la rotación en el eje Y.

# Si ninguna tecla está presionada, rotation_direction será 0 y el objeto no girará.

rotate_y(rotation_speed * rotation_direction * delta)

func instantiate_bullet() -> void:

var bullet = Bullet.instantiate()

bullet.global_transform = self.global_transform

if bullet is RigidBody3D:

bullet.apply_central_impulse(-self.global_transform.basis.z * bullet_speed)

else:

print("¡Error! La escena del proyectil no es un RigidBody3D y no puede recibir un impulso.")

get_tree().root.add_child(bullet)

¡¡El pirata marchoso!!;

https://perico415.itch.io/
 

GDScript que produce disparo de un proyectil y que mantiene su curso independientemente de si giramos el cañon;

 extends Area3D

var Bullet = preload("res://BARCO ELEMENTOS TEXTURAS/CAÑONES/area_3dprollectil_cañon.tscn")

var fire_cooldown: float = 1.7

var can_fire: bool = true

var bullet_speed: float = 20.0

var fire_timer: Timer

func _ready() -> void:

fire_timer = Timer.new()

add_child(fire_timer)

fire_timer.wait_time = fire_cooldown

fire_timer.one_shot = true

fire_timer.timeout.connect(func(): can_fire = true)

func _process(delta: float) -> void:

if Input.is_action_pressed("DISPARACAÑON") and can_fire:

can_fire = false

instantiate_bullet()

fire_timer.start()

func instantiate_bullet() -> void:

var bullet = Bullet.instantiate()

bullet.global_transform = self.global_transform

# Comprobamos que el nodo es un RigidBody3D antes de aplicar el impulso.

if bullet is RigidBody3D:

bullet.apply_central_impulse(-self.global_transform.basis.z * bullet_speed)

else:

print("¡Error! La escena del proyectil no es un RigidBody3D y no puede recibir un impulso.")

get_tree().root.add_child(bullet)

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

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

Explicacion: este Area3d que produce el disparo de un proyectil es hijo de una base que gira presionando las teclas -z-x, tenia el problema que cuando giraba el cañon el proyectil disparado tambien giraba como si formase parte del mismo giro del cañon y este GDScript corrige el problema, asi cuando disparo el proyectil sigue su curso en linea recta y en la direccion hacia donde realice el disparo y no se desvia por muchos giros que aga despues de realizado el disparo.    

"DISPARACAÑON" es el nombre asociado ala tecla-c- que realiza el disparo, se dice mapa de entrada y se prepara antes de realizar cualquier GDScript, y se puede aprovechar para futuros juegos, se pueden aprovechar todos los recursos anteriores de los mapas de entrada para futuros juegos sin tener que partir de cero continuamente.

GDScript para que un MeshInstance3D gire en su eje -y- presionando teclas del pc -z-x-;

 extends MeshInstance3D

# Velocidad de rotación en radianes por segundo.

@export var rotation_speed: float = 1.0

func _process(delta: float) -> void:

# Por defecto, la dirección de rotación es 0 (está quieto).

var rotation_direction: float = 0.0

# Si se presiona la acción "giraz", gira en una dirección.

if Input.is_action_pressed("giraz"):

rotation_direction = 1.0

# Si se presiona la acción "girax", gira en la dirección opuesta.

elif Input.is_action_pressed("girax"):

rotation_direction = -1.0

# Aplica la rotación en el eje Y.

# Si ninguna tecla está presionada, rotation_direction será 0 y el objeto no girará.

rotate_y(rotation_speed * rotation_direction * delta)

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

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

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

Explicacion: en mi nuevo videojuego de piratas y bucaneros e puesto unos cañones a bordo que mediante la presion de las teclas -z-x- hacen un giro de lado a lado en su eje -y-, en Godot asigne esas teclas en su mapa de entrada con los nombres "giraz" y "girax"   este gdscript cumple mi deseo a la perfeccion,.

Estudio de un desarrollador indie;

 ¡¡QUE LOCURA!!

 ¡¡QUE LOCURA!!

 ¡¡QUE LOCURA!!

 ¡¡QUE LOCURA!!

https://perico415.itch.io/

En mi habitacion, tengo 2 pc de torre con el windows XP que funcionan perfectamente, y repaso maravillas como Medall of de Honor, Farcry, entre otros....tengo 2 portatiles 1 msi el otro hp portátil pavilion el msi con 64Gb de ram, el hp portátil pavilion con 16Gb de ram

.

Estos tienen discos duros ssd con puertos usb, los de torre con xp discos duros normales, tambien con usb, .

Mis desarrollos los ago con los portatiles que tienen instalado el windows 11, antes usaba Unity pero probe Godot y me pase a Godot 4.4. 

Me encanta Godot, el de ram de 16 lo uso ahora para ver cine, cada fin de semana a la tarde lo enchufo a un proyector que no llega a los 100 euros y veo peliculas a unas 100 pulgadas prollectadas en mi habitacion, fabuloso!! y me da ideas para desarrollar mis juegos, tambien tengo una coleccion de videojuegos impresionante, que solo funcionan en el windows xp, ahora si quieres jugar en pc tienes que ir a steam.

Tengo tambien unas luces led que no consumen nada de electricidad y dan ambiente a mi estudio, funcionan con mando a distancia¡¡¡¡¡ toma ya¡¡¡¡¡ y hacen colorines y buelven mi ropa fluorescente como si estubiera en la discoteque......

Y libros tengo libros desde comics del capitan trueno, ediciones antiguas de la marvel spiderman 4 fantasticos, versiones modernas en libro, libros sobre videojuegos, programacion, Unity, Blender, historia de videojuegos 1001 videjuegos que has de jugar antes de palmar,  unos tomos de RBA una coleccion muy interesante, y peliculas a puntapala en dvd, y de Star Trek.

Y un par de ventiladores que hace una calor brutal.

Y muy poco tiempo libre para todo.

No doy a basto con mis ideas y con todo lo que quiero hacer.....soy desarrollador indie pero e de trabajar con otras cosas para poder comer.....en fin.

Boy haciendo.

Mar texturas;