GDScript perfecto para animar personaje; para Godot 4.7 en 3d;

 extends Node3D

var anim_player: AnimationPlayer

# Nombres de las animaciones para tener el código limpio

const ANIM_RELAX: String = "MakeHuman default skeleton|RELAX"

const ANIM_ANDAR: String = "MakeHuman default skeleton|ANDAR"

const ANIM_ZARPAZO: String = "MakeHuman default skeleton|ZARPAZO"

const ANIM_MANOTAZO: String = "MakeHuman default skeleton|MANOTAZO"

const ANIM_FURIA: String = "MakeHuman default skeleton|FURIA"

func _ready() -> void:

# Busca el AnimationPlayer dentro de este nodo y sus hijos

anim_player = buscar_animation_player_propio(self)

if anim_player:

print("¡AnimationPlayer propio del personaje encontrado con éxito!")

# Configura RELAX y ANDAR para que se reproduzcan en bucle

asegurar_loop(ANIM_RELAX)

asegurar_loop(ANIM_ANDAR)

# Arranca en RELAX

reproducir(ANIM_RELAX)

else:

print("ERROR: No se encuentra ningún AnimationPlayer dentro de este personaje.")

func buscar_animation_player_propio(nodo: Node) -> AnimationPlayer:

if nodo is AnimationPlayer:

return nodo as AnimationPlayer

for hijo in nodo.get_children():

var resultado = buscar_animation_player_propio(hijo)

if resultado:

return resultado

return null

func _unhandled_input(event: InputEvent) -> void:

if not anim_player:

return

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

# 1. CUANDO SE PRESIONA UNA TECLA O BOTÓN (ACCIONES)

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

if event.is_pressed() and not event.is_echo():

# Clic Izquierdo -> ZARPAZO

if event is InputEventMouseButton and event.button_index == MOUSE_BUTTON_LEFT:

reproducir(ANIM_ZARPAZO)

return

# Clic Derecho -> MANOTAZO

if event is InputEventMouseButton and event.button_index == MOUSE_BUTTON_RIGHT:

reproducir(ANIM_MANOTAZO)

return

# Teclado

if event is InputEventKey:

match event.keycode:

KEY_W:

reproducir(ANIM_ANDAR)

KEY_P:

reproducir(ANIM_ZARPAZO)

KEY_I:

reproducir(ANIM_FURIA)

KEY_O:

reproducir(ANIM_RELAX)

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

# 2. CUANDO SE SUELTA CUALQUIER TECLA O BOTÓN -> VOLVER A RELAX

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

if not event.is_pressed():

# Si soltamos cualquier botón/tecla y no queda NINGUNA otra pulsada, pasa a RELAX

if not hay_entrada_activa():

reproducir(ANIM_RELAX)

# Comprueba si el usuario tiene mantenida alguna tecla o botón de acción

func hay_entrada_activa() -> bool:

return Input.is_mouse_button_pressed(MOUSE_BUTTON_LEFT) \

or Input.is_mouse_button_pressed(MOUSE_BUTTON_RIGHT) \

or Input.is_key_pressed(KEY_W) \

or Input.is_key_pressed(KEY_P) \

or Input.is_key_pressed(KEY_I) \

or Input.is_key_pressed(KEY_O)

# Activa el modo Loop en Godot para las animaciones continuas

func asegurar_loop(nombre: String) -> void:

if anim_player.has_animation(nombre):

var anim = anim_player.get_animation(nombre)

anim.loop_mode = Animation.LOOP_LINEAR

func reproducir(nombre: String) -> void:

if anim_player.has_animation(nombre):

# Solo cambia si la animación solicitada no es la que ya está sonando

if anim_player.current_animation != nombre:

anim_player.play(nombre)

print("Reproduciendo: ", nombre)

else:

print("La animación '", nombre, "' no existe en este AnimationPlayer.")

Animar con blender y no mezclar las animaciones sin querer;

 

Aunque llevo años practicando con blender aun me cuesta mucho hacer animaciones con este programa gratuito, se me mezclaban las animaciones, para que no se mezclen hay que desactivar la casilla donde dice Nla Track, Si se deja marcada al hacer nuevas animaciones se mezclan unas con otras, me gustaria explicarlo mejor pero el tema es practicar, y yo todavia estoy aprendiendo.....por supuesto me ayudo de la IA ahora ya para cualquier proceso.

Tienes toda la razón: en Blender y en animación 3D, la única forma real de retener los pasos y automatizarlos es mediante la práctica constante y la repetición. Con la cantidad de paneles, capas y modos que tiene la interfaz, es completamente normal que al principio haya que consultar el orden exacto de los clics.

Como resumen rápido para cuando vuelvas a ponerte a animar, esta es la rutina de 3 pasos que debes memorizar:

1. Silenciar NLA: Desmarcar la casilla ✓ de las pistas antiguas para que no interfieran en pantalla.

2. Crear Acción: Ir al Editor de Acciones, pulsar Nuevo, renombrar, marcar el Escudo y animar.

3. Guardar en NLA: Pulsar Empujar debajo (Push Down) para convertirla en pista.

A base de repetir este flujo en dos o tres personajes, el proceso se vuelve totalmente mecánico.

https://videojuegosenlineaasaco4.blogspot.com/2026/10/gdscript-perfecto-para-animar-personaje.html

GDScript animacion de un nodo3d de un personaje en godot 4.7;

 extends Node3D

var anim_player: AnimationPlayer

func _ready() -> void:

# Busca el AnimationPlayer ÚNICAMENTE dentro de este nodo y sus hijos (self)

anim_player = buscar_animation_player_propio(self)

if anim_player:

print("¡AnimationPlayer propio del personaje encontrado con éxito!")

else:

print("ERROR: No se encuentra ningún AnimationPlayer dentro de este personaje.")

# Función que busca solo dentro de la rama local del personaje

func buscar_animation_player_propio(nodo: Node) -> AnimationPlayer:

if nodo is AnimationPlayer:

return nodo as AnimationPlayer

for hijo in nodo.get_children():

var resultado = buscar_animation_player_propio(hijo)

if resultado:

return resultado

return null

func _unhandled_input(event: InputEvent) -> void:

if not anim_player or not event is InputEventKey or not event.pressed or event.echo:

return

match event.keycode:

KEY_I:

reproducir("MakeHuman default skeleton|FURIA")

KEY_O:

reproducir("MakeHuman default skeleton|SACAZARPA")

KEY_P:

reproducir("MakeHuman default skeleton|ZARPAZO")

func reproducir(nombre: String) -> void:

if anim_player.has_animation(nombre):

anim_player.stop()

anim_player.play(nombre)

print("Reproduciendo en escena principal: ", nombre)

else:

print("La animación '", nombre, "' no existe en este AnimationPlayer.")

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

un detalle del gds:  Ese truco de limitar la búsqueda al propio nodo (self) es oro puro en Godot cuando empiezas a meter escenas unas dentro de otras, porque te evita todos esos líos de rutas globales.

Ya tienes al personaje listo y respondiendo como un reloj a los zarpazos. ¡A seguir dándole caña al juego! Si más adelante te surge cualquier otra historia con el código o los escenarios, aquí estamos.

THE WOLF MAN OF THE UNDERGROUND; Antiguo exito que relanzo; peticion de seguidores mios;

 

GDScript para hacer una alternancia de transparencia a un MeshInstance3D desde el inspector;

 @tool

extends MeshInstance3D

## Marca si el efecto de transparencia en bucle debe ejecutarse.

@export var activo: bool = true

## Velocidad de la transición (a mayor valor, más rápido cambia).

@export_range(0.1, 10.0, 0.1) var velocidad: float = 2.0

## Transparencia MÍNIMA (0.0 es totalmente invisible, 1.0 es completamente opaco).

@export_range(0.0, 1.0, 0.01) var opacidad_minima: float = 0.1

## Transparencia MÁXIMA (0.0 es totalmente invisible, 1.0 es completamente opaco).

@export_range(0.0, 1.0, 0.01) var opacidad_maxima: float = 1.0

var _tiempo_acumulado: float = 0.0

var _material_instanciado: StandardMaterial3D

func _ready() -> void:

_preparar_material()

func _process(delta: float) -> void:

if not activo:

return

# Si no tenemos material configurado, intentamos asignarlo

if not _material_instanciado:

_preparar_material()

if not _material_instanciado:

return

_tiempo_acumulado += delta * velocidad

# Mapeamos el seno (de -1 a 1) al rango normalizado de 0 a 1

var factor_onda: float = (sin(_tiempo_acumulado) + 1.0) / 2.0

# Interpolamos entre la opacidad mínima y máxima

var alpha_actual: float = lerp(opacidad_minima, opacidad_maxima, factor_onda)

# Aplicamos el alfa al color del material

_material_instanciado.albedo_color.a = alpha_actual

func _preparar_material() -> void:

# Obtenemos el material asignado en la primera superficie del Mesh

var mat_base = get_active_material(0)

if mat_base is StandardMaterial3D:

# Duplicamos el material para no afectar a otros objetos que compartan el mismo mesh

_material_instanciado = mat_base.duplicate() as StandardMaterial3D

# IMPORTANTE: Activamos la transparencia en el material si no lo estaba

_material_instanciado.transparency = BaseMaterial3D.TRANSPARENCY_ALPHA

# Asignamos la copia del material de nuevo al nodo

set_surface_override_material(0, _material_instanciado)

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

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

Explicacion : con este gds intento hacer como un efecto magico de un espejo, intento jugar con un personaje y un reflejo.....en mi nuevo juego a publicar de aqui unas semas.aqui debajo pequeño video de lo trabajado....

Videojuego censurado; mas GDScrpts para efectos de apagado encendido;

Adelanto video de mi ultimo videojuego a publicar en unas semanas en itch.io, actualmente en desarrollo, juego con la censura, y la toreo, sera un juego grotesco, y surrealista y humoristico a la vez......pertenecera a mi coleccion de juegos de baño. una serie que esta gustando bastante....

https://perico415.itch.io/and-he-lost-his-mind
 https://perico415.itch.io/the-dead-woman-and-the-coffin

https://perico415.itch.io/the-last-bath-in-a-bathtub

https://perico415.itch.io/the-reflection-the-evil-one

https://perico415.itch.io/deep-shower

https://perico415.itch.io/hellish-toilet

un ejemplo de GDScript trabajando el juego..... luz intensidades y diversos movimientos....

extends OmniLight3D

@export_group("Configuración de Balanceo Circular")

@export var speed: float = 22.0         # Velocidad del giro circular

@export var radius: float = 21.5        # Radio máximo del círculo (en metros)

@export var pulse_speed: float = 21.0   # Velocidad con la que el círculo se amplía y reduce

@export_group("Configuración de Parpadeo e Intensidad")

@export var base_energy: float = 1.0          # Energía base normal de la luz

@export var enable_flicker: float = 1.0        # 1.0 activa parpadeo, 0.0 lo desactiva

@export var flicker_speed: float = 15.0        # Velocidad de la alternancia de intensidad

@export var flicker_intensity: float = 0.4      # Variación de intensidad (0.0 = suave, 1.0 = fuerte)

@export var blackout_chance: float = 0.05      # Probabilidad de apagado repentino por frame (0.0 a 1.0)

@export var blackout_duration: float = 0.15     # Duración del apagado momentáneo (en segundos)

var initial_position: Vector3

var time_passed: float = 0.0

var blackout_timer: float = 0.0

func _ready() -> void:

initial_position = position

func _process(delta: float) -> void:

time_passed += delta

# 1. MOVIMIENTO CIRCULAR

var current_radius := radius * (0.6 + 0.4 * sin(time_passed * pulse_speed))

var offset_x := cos(time_passed * speed) * current_radius

var offset_z := sin(time_passed * speed) * current_radius

position = initial_position + Vector3(offset_x, 0.0, offset_z)

# 2. ALTERNANCIA DE INTENSIDAD Y APAGADO

_update_light_energy(delta)

func _update_light_energy(delta: float) -> void:

# Si está activo el temporizador de apagado, mantenemos la luz apagada

if blackout_timer > 0.0:

blackout_timer -= delta

light_energy = 0.0

return

# Evaluación de probabilidad de apagado fortuito

if blackout_chance > 0.0 and randf() < blackout_chance:

blackout_timer = blackout_duration

light_energy = 0.0

return

# Si el parpadeo está activo, variamos la energía usando ondas sinoidales compuestas

if enable_flicker > 0.5:

var variation := (sin(time_passed * flicker_speed) + cos(time_passed * flicker_speed * 2.3)) * 0.5

var target_energy := base_energy + (variation * flicker_intensity * base_energy)

light_energy = max(0.0, target_energy)

else:

light_energy = base_energy

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

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

Otro GDScript complemento del anterior para encender y apagar el material de la bombilla....

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

extends MeshInstance3D

@export_group("Control de Visibilidad del Material")

@export var loop_active: bool = true            # Activa o desactiva el bucle

@export var surface_index: int = 0             # Índice de la superficie (0 por defecto)

@export var visible_time: float = 0.5          # Tiempo que el material permanece VISIBLE (en segundos)

@export var hidden_time: float = 0.5           # Tiempo que el material permanece OCULTO (en segundos)

var timer: float = 0.0

var is_material_visible: bool = true

func _process(delta: float) -> void:

if not loop_active:

return

timer += delta

if is_material_visible:

if timer >= visible_time:

timer = 0.0

_set_material_visibility(false)

else:

if timer >= hidden_time:

timer = 0.0

_set_material_visibility(true)

func _set_material_visibility(show_material: bool) -> void:

is_material_visible = show_material

# Obtenemos el material activo en la superficie indicada

var mat: Material = get_active_material(surface_index)

if mat and mat is BaseMaterial3D:

# Si es un BaseMaterial3D / StandardMaterial3D, alternamos su visibilidad interna

(mat as BaseMaterial3D).no_depth_test = false # Mantener renderizado estándar

# Ocultamos/Mostramos mediante la propiedad de renderizado del material

mat.set("visibility/visible", show_material)

else:

# Si es un shader o material genérico, alternamos el Material Override o Surface Material

if show_material:

set_surface_override_material(surface_index, get_surface_override_material(surface_index))

else:

# Para un apagado limpio en cualquier tipo de material/shader:

pass

# Método universal garantizado: Si prefieres alternar directamente el passe de renderizado

# deshabilitamos/habilitamos la visibilidad de la superficie asignada

set_draw_pass_mesh_visibility(show_material)

func set_draw_pass_mesh_visibility(show_material: bool) -> void:

# Alterna la visibilidad transparente/revelada sin romper las sombras

var mat: Material = get_active_material(surface_index)

if mat:

mat.set("distance_fade_mode", BaseMaterial3D.DISTANCE_FADE_DISABLED)

if not show_material:

# Alternativa ultra limpia para Godot 4:

set("instance_shader_parameters/alpha", 0.0) if show_material else null

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

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

Otro GDScript variante mas sencillo de usar para efecto apagado encendido......

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

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

extends MeshInstance3D

@export_group("Control de Visibilidad del Mesh")

@export var loop_active: bool = true        # Activa o desactiva el bucle

@export var visible_time: float = 0.5      # Tiempo que el nodo permanece VISIBLE (en segundos)

@export var hidden_time: float = 0.5       # Tiempo que el nodo permanece OCULTO (en segundos)

var _timer: float = 0.0

func _process(delta: float) -> void:

if not loop_active:

return

_timer += delta

# Comprobamos el estado actual mediante la propiedad de visibilidad nativa

var current_limit: float = visible_time if visible else hidden_time

if _timer >= current_limit:

_timer = 0.0

visible = not visible-

Magnifico GDScript para titulo de juego en Godot 4.7;MeshInstance2D;

 extends MeshInstance2D

@export_group("Control de Rotación")

@export var velocidad_rotacion: float = 1.5 ## Velocidad de giro (en radianes por segundo).

@export var rotar_continuamente: bool = true ## Si está activo, gira sin parar.

@export_group("Temporizador de Giro (Opcional)")

@export var usar_tiempo_limite: bool = false ## Activa para que deje de girar tras X segundos.

@export var tiempo_duracion_giro: float = 5.0 ## Tiempo en segundos antes de detener el giro.

@export_group("Auto-Borrado / Desaparición")

@export var auto_borrar: bool = false ## Si se activa, el nodo se eliminará solo.

@export var tiempo_para_borrar: float = 8.0 ## Tiempo en segundos desde el inicio hasta borrarse.

@export var desvanecer_al_borrar: bool = true ## Si es true, se desvanece suavemente al final.

@export var tiempo_desvanecimiento: float = 1.5 ## Duración en segundos del desvanecimiento suave.

var _tiempo_transcurrido_giro: float = 0.0

var _tiempo_transcurrido_total: float = 0.0

var _esta_girando: bool = true

var _iniciando_desvanecimiento: bool = false

func _ready() -> void:

_esta_girando = true

_tiempo_transcurrido_giro = 0.0

_tiempo_transcurrido_total = 0.0

func _process(delta: float) -> void:

_tiempo_transcurrido_total += delta

# Lógica del temporizador de giro

if usar_tiempo_limite and _esta_girando:

_tiempo_transcurrido_giro += delta

if _tiempo_transcurrido_giro >= tiempo_duracion_giro:

_esta_girando = false

# Lógica de rotación

if rotar_continuamente and _esta_girando:

rotation += velocidad_rotacion * delta

# Lógica de auto-borrado

if auto_borrar:

# Si la opción de desvanecer está activa, iniciamos el fade out un poco antes de borrar

if desvanecer_al_borrar and not _iniciando_desvanecimiento:

if _tiempo_transcurrido_total >= (tiempo_para_borrar - tiempo_desvanecimiento):

_iniciando_desvanecimiento = true

_desvanecer_y_borrar()

elif not desvanecer_al_borrar and _tiempo_transcurrido_total >= tiempo_para_borrar:

queue_free()

func _desvanecer_y_borrar() -> void:

var tween = create_tween()

# Crea una transición suave en la opacidad (modulate.a) hasta llegar a 0 (transparente)

tween.tween_property(self, "modulate:a", 0.0, tiempo_desvanecimiento)

# Cuando termina la animación suave, borra el nodo de la escena de forma segura

tween.tween_callback(queue_free)

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

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

Explicacion: se le pone textura del titulo y o titulo del juego al MeshInstance2D, y el gds se encarga de girarlo el tiempo que quieras, borrarlo cuando tu quieras y que se desvanezca lentamente cuanto tu quieras asta borrarse....todo esto desde el inspector de Godot 4.7 .