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

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)