BORRAR AREA3D DE GODOT EN 5 SEGUNDOS CON GDSCRIPT;

 extends Area3D

func _ready() -> void:

# Espera 5 segundos y luego ejecuta queue_free()

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

Stealing from the history museum. 14-12-25;

 https://perico415.itch.io/

GDScript instanciando por entrar en una area3d , con retraso de 6 segundos;

 extends Area3D

# Carga la escena de la bola para poder instanciarla.

var bola_proyectada_scene = preload("res://EL DEL CUADRO QUE GRITA/character_body_3d_enemigo_cubo7-12-25.tscn")

# 0: Esperando colisión inicial

# 1: Colisión detectada, contando tiempo

# 2: Instanciación completada

var estado_instanciacion: int = 0

# Contador de tiempo, para acumular los segundos.

var tiempo_acumulado: float = 0.0

# Constante que define el retardo deseado: ¡AHORA 6 SEGUNDOS!

const TIEMPO_ESPERA: float = 6.0

# Esta función se llama automáticamente cuando otro Area3D entra en este Area3D.

# (Debes haber conectado la señal 'area_entered').

func _on_area_entered(area: Area3D) -> void:

# 1. Comprobar que el retardo no se haya iniciado ya.

if estado_instanciacion == 0:

print("Área tocada. Iniciando cuenta atrás de ", TIEMPO_ESPERA, " segundos para instanciar bola...")

estado_instanciacion = 1 # Cambiamos el estado para empezar a contar.

# 2. OPCIONAL: Comprobar si el Area que ha entrado es un área específica.

# if area.name != "Area_del_jugador":

# return

# Esta función se llama en cada frame del juego.

func _process(delta: float) -> void:

# Comprobar si estamos en el estado de conteo (1).

if estado_instanciacion == 1:

# Acumular el tiempo transcurrido desde el último frame.

tiempo_acumulado += delta

# Comprobar si se ha alcanzado el tiempo de espera (6.0 segundos).

if tiempo_acumulado >= TIEMPO_ESPERA:

# ¡Tiempo cumplido! Instanciar y cambiar el estado.

instanciar_bola()

estado_instanciacion = 2 # Marcamos como completado.

# Detenemos el _process, ya que la tarea ha terminado.

set_process(false)

func instanciar_bola() -> void:

print("¡6 segundos cumplidos! Instanciando bola proyectada.")

# 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)

# --- FIN DEL SCRIPT ---

Nueva compilacion para windows y linux, La imitacion de Monalisa se sale¡¡¡¡ esta que se sale¡¡¡¡;

 Nueva compilacion para windows y linux, La imitacion de Monalisa se sale¡¡¡¡ esta que se sale¡¡¡¡ Creo ire poniendo por fechas todo lo nuevo, asi los jugadores tendran un orden logico de las mejoras y ampliaciones que boy a ir añadiendo......​

​New build for Windows and Linux! The Mona Lisa imitation is amazing! It's fantastic! I think I'll be posting all the new features by date, so players will have a logical order of the improvements and expansions I'll be adding...​

Stealing from the history museum.;

 

https://perico415.itch.io/

Desarrollando juego del museo; 4-12-25;

Juego con uno de los personajes de los cuadros, el del "grito", se sale del cuadro y se pone detras del protagonista........que ocurrira?

 https://perico415.itch.io/stealing-from-the-history-museum

Demo del juego del robo que boy a trabajar durante un año!;

 

Godot 4.5 estudiando nuevo proyecto-3-parte; video de yutube, comento;

comento el nuevo video de yutube de mi primer proyecto para Steam que pienso dedicarle 1 año, estudiando movimientos de personaje, estudiando cambios de escenas, estudiando algo el sonido y la luz y ocurrencias con toque humoristico,  cadencias de memoria con tema lanzar granadas de mano, e de corregirlo, el tema de disparos funciona fluido........la iluminacion quiero conserbar ese ambiente.......en fin solo es trabajo y tiempo.

 

black-friday itch.io;

https://itch.io/s/169895/black-friday-creator-day-2025 

Godot 4.5 estudiando nuevo proyecto-2-parte;

 

Estoy con nuevo proyecto realizándolo con Godot 4.5, este es muy ambicioso porque quiero publicar mi primer juego en Steam, y no lo voy a realizar en 2 meses, creo me atreveré a publicarlo de aquí 6 meses a 1 año, e comprado un mouse mas preciso para trabajar el juego, de estos de Gamer y bueno se nota la diferencia, mas precisión y mas seguridad manejando con el.

En el juego utilizo muchísimo la cámara, permitiendo infinidad de ángulos y de distancias, el jugador tendrá todas sus preferencias cubiertas en ese aspecto.

En este video estoy empezando a trabajar el juego y probando el mouse.

El argumento trata sobre un robo en un museo.

Las animaciones las descargo y las combino lo mejor que se alludandome de la IA y sus gdscripts para hacer funcionar al personaje.

La ambientación sera toda de oscuridad y de misterio, una iluminación estilo series de televisión CSI, al menos en eso me inspiro.

Iré publicando avances en yutube y en mi blog, ahora no tengo ninguna prisa, antes hacia un juego cada mes o dos meses y los publicaba en Itch.io, con temas de erotismo, porque algún dólar caía por ventas y hacia ilusión ganar algo, pero con la censura actual eso se a echo imposible, así que voy a ir en plan de autentico profesional, y voy hacer un juego que publicare en Steam y del cual pienso recuperar los 100$ que cuesta publicar alli mas las ganancias, otros 100$ me atrevo a asegurar que conseguire ganar.

Y estoy completamente seguro que lo voy a conseguir, jamas podre vivir de esto, pero algun pellizco, o trozo del pastel si que lo boy a sacar.

Es mas el goze de tener una ilusion, una aficion, algo que me llena y me desconecta de la monotonia de mi abitual trabajo del que si me gano el pan.

GDSCRIPT SOLO DISPARA DE 1 EN 1 AL EMPEZAR A PRESIONAR TECLA; GODOT 4.5;

 extends Area3D

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

# --- Variables de control para el cooldown ---

var right_mouse_fire_cooldown: float = 0.4

var can_fire_right_mouse: bool = true

# --- Nodos Timer ---

var right_mouse_timer: Timer

# --- Referencia al nodo del modelo 3D (para la rotación) ---

var player_mesh: MeshInstance3D

func _ready() -> void:

# --- Inicialización del temporizador para el Botón Derecho ---

right_mouse_timer = Timer.new()

add_child(right_mouse_timer)

right_mouse_timer.wait_time = right_mouse_fire_cooldown

right_mouse_timer.one_shot = true

# Al terminar el tiempo, volvemos a permitir el disparo

right_mouse_timer.timeout.connect(func(): can_fire_right_mouse = true)

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

player_mesh = get_node("MeshInstance3D")

func _input(event: InputEvent) -> void:

if event is InputEventMouseButton:

# 🎯 CAMBIO CLAVE: Disparo al EMPEZAR a presionar 🔫

# Verificamos si es el botón derecho Y SI ESTÁ presionado (event.is_pressed())

if event.button_index == MOUSE_BUTTON_RIGHT and event.is_pressed(): 

if can_fire_right_mouse:

can_fire_right_mouse = false

instantiate_bullet()

right_mouse_timer.start()

# NOTA: La liberación del botón ahora no hace nada porque no hay código que la compruebe.

func _process(delta: float) -> void:

# --- LÓGICA de rotación (Se mantiene aquí) ---

if player_mesh:

if Input.is_key_pressed(KEY_Z):

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

if Input.is_key_pressed(KEY_X):

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

# --- Función unificada para instanciar la bala ---

func instantiate_bullet() -> void:

var bullet = Bullet.instantiate()

add_child(bullet)

GDScript para proyectil continuo;; Godot 4.5;

 extends Area3D

var speed: float = 31.0 # Velocidad de la bala (Unidades por segundo)

var tiempo_transcurrido: float = 0.0 # Tiempo en segundos

# El tiempo de vida de la bala es de 80.8 segundos (mucho, pero lo mantenemos por tu configuración)

const LIFESPAN: float = 80.8 

func _ready() -> void:

# La bala ya debe estar orientada en la dirección de disparo

pass

func _process(delta: float) -> void:

# 1. ACTUALIZAR EL TIEMPO

tiempo_transcurrido += delta

# 2. MOVER EL PROYECTIL HACIA ADELANTE (Movimiento Recto y Limpio)

# Usamos translate() para mover el proyectil en su eje local Z (hacia adelante).

# Como no hay ninguna rotación aplicada, mantendrá el rumbo recto.

translate(Vector3(0, 0, speed * delta))

# 3. CONDICIÓN DE DESTRUCCIÓN

if tiempo_transcurrido >= LIFESPAN:

queue_free()

# --- PARTES ELIMINADAS ---

# Se ha eliminado todo el código de 'desired_sweep_angle', 'sin', y 'rotation = current_rotation'

# que causaba el movimiento de barrido lateral.

PASANDO PERSONAJE DE BLENDER 4.4.3. A GODOT 4.5.;

 

AGREGANDO LINTERNA A PERSONAJE EN BLENDER 4.4.3.;

Control + "p"

 

AÑADIR OBJETO A PERSONAJE CON BLENDER 4.4.3. UNA PISTOLA;;

 Control + "p"

Godot 4.5 estudiando nuevo proyecto;

 

¡¡Censura!!;

 Me han censurado y retirado de Gamejolt un juego de atropellar gatos, ni que ubiese echo el Carmageddon., en itchi.io y Steam censuran cualquier indicio incluso de desnudos, pues nada e ido a Youtube y borre tambien el video, no se al final que ocurrira, quizas tengan razon , no lo se, so lo se que la vida real es infinitamente mas desagradable, y los juegos son solo ficcion , pero si esto sigue asi, quizas proivan cualquier videojuego, cualquier, pelicula, cualquier novela, cualquiera obra de teatro...........

Carmageddon

participo en una game jam;

https://gamejolt.com/c/gamedev/narrative_jam?page=1 

participo en una game jam;   de momento solo hay 59 participantes, se que no ganare pero tengo curiosidad.................mi juego es este de aqui------https://gamejolt.com/games/El_ultimo_vivo/920498

✨ PREMIOS

🥇 1er lugar

$3,500 USD

🥈 2do lugar

$1000 USD

🥉 3er lugar

$500 USD

¡Esta es una oportunidad que no querrás perderte!

juego hazaña sensual;

 

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()