Files
dungeon-divers/scripts/dungeon/mob_visual.gd
T
2025-12-23 08:32:22 -05:00

337 lines
11 KiB
GDScript

extends Node2D
## Mob Visual
## Renders mobs using sprite sheets from CDN with JSON animation config
## Falls back to simple shapes if assets aren't available
var fallback_sprite: Sprite2D = null
var name_label: Label = null
var health_bar: ProgressBar = null
var mob_data: Dictionary = {}
var _sprite_config: Dictionary = {} # Animation config from server
var _animated_sprite: AnimatedSprite2D = null
var _using_fallback: bool = true
# Animation state
var _current_state: String = "idle"
var _facing_direction: String = "down" # down, up, left, right, front, back
func _ready():
print("[MobVisual] _ready called!")
# Try to find child nodes (they may not exist in all mob scenes)
fallback_sprite = get_node_or_null("Sprite2D")
name_label = get_node_or_null("NameLabel")
health_bar = get_node_or_null("HealthBar")
# Create fallback sprite if it doesn't exist
if not fallback_sprite:
fallback_sprite = Sprite2D.new()
fallback_sprite.name = "FallbackSprite"
add_child(fallback_sprite)
# Create name label if it doesn't exist
if not name_label:
name_label = Label.new()
name_label.name = "NameLabel"
name_label.horizontal_alignment = HORIZONTAL_ALIGNMENT_CENTER
name_label.position = Vector2(-50, -35)
name_label.size = Vector2(100, 15)
add_child(name_label)
# Create health bar if it doesn't exist
if not health_bar:
health_bar = ProgressBar.new()
health_bar.name = "HealthBar"
health_bar.position = Vector2(-20, -28)
health_bar.size = Vector2(40, 5)
health_bar.show_percentage = false
add_child(health_bar)
# Connect to UpdateManager for async texture loading
if UpdateManager:
UpdateManager.file_downloaded.connect(_on_file_downloaded)
print("[MobVisual] Connected to UpdateManager")
else:
print("[MobVisual] WARNING: UpdateManager is null!")
func update_data(data: Dictionary):
mob_data = data
# Update name
var mname = data.get("name", data.get("Name", "Mob"))
if name_label:
name_label.text = mname
# Update health bar
var hp = data.get("health", data.get("Health", 100))
var max_hp = data.get("maxHealth", data.get("MaxHealth", 100))
if health_bar:
health_bar.max_value = max_hp
health_bar.value = hp
# Get sprite config (sent from server with mob data)
var sprite_config = data.get("spriteConfig", data.get("SpriteConfig", null))
# Debug: print what we received
if sprite_config != null:
print("[MobVisual] %s received spriteConfig: %s" % [mname, sprite_config])
else:
print("[MobVisual] %s has NO spriteConfig" % mname)
if sprite_config != null and sprite_config is Dictionary and not sprite_config.is_empty():
if sprite_config != _sprite_config:
_sprite_config = sprite_config
_build_animated_sprite()
elif _using_fallback:
_setup_fallback(data)
# Update visual state
var state = data.get("state", data.get("State", "idle")).to_lower()
var rotation = data.get("rotation", data.get("Rotation", 0.0))
_update_animation_state(state, rotation)
# Apply tint
var tint = data.get("tintColor", data.get("TintColor", "#ffffff"))
_apply_tint(tint)
# Apply scale
var mob_scale = data.get("scale", data.get("Scale", 1.0))
print("[MobVisual] Raw scale from data: %s (type: %s)" % [mob_scale, typeof(mob_scale)])
# Ensure scale is valid (at least 1.0 if 0 or invalid)
if mob_scale == null or mob_scale <= 0:
mob_scale = 1.0
if _animated_sprite:
_animated_sprite.scale = Vector2.ONE * mob_scale
elif fallback_sprite:
fallback_sprite.scale = Vector2.ONE * mob_scale
func _build_animated_sprite():
## Build AnimatedSprite2D from sprite config
print("[MobVisual] _build_animated_sprite called for %s" % mob_data.get("name", "unknown"))
var sprites = _sprite_config.get("sprites", {})
print("[MobVisual] sprites dict type: %s, value: %s" % [typeof(sprites), sprites])
if sprites == null or not sprites is Dictionary or sprites.is_empty():
print("[MobVisual] No sprites in config, using fallback")
_setup_fallback(mob_data)
return
# Check if all required textures are cached
var all_cached = true
var missing_files = []
for anim_name in sprites:
var sprite_path = sprites[anim_name]
print("[MobVisual] Checking texture: %s" % sprite_path)
if not UpdateManager:
print("[MobVisual] UpdateManager is null!")
all_cached = false
missing_files.append(sprite_path)
elif not UpdateManager.has_file(sprite_path):
print("[MobVisual] File NOT in cache: %s" % sprite_path)
all_cached = false
missing_files.append(sprite_path)
else:
print("[MobVisual] File IS in cache: %s" % sprite_path)
if not all_cached:
print("[MobVisual] Missing textures: %s" % missing_files)
_setup_fallback(mob_data)
return
print("[MobVisual] All textures cached, building AnimatedSprite2D")
# Create or reuse AnimatedSprite2D
if not _animated_sprite:
_animated_sprite = AnimatedSprite2D.new()
_animated_sprite.name = "MobAnimatedSprite"
add_child(_animated_sprite)
# Build SpriteFrames
var sprite_frames = SpriteFrames.new()
var frame_width = _sprite_config.get("frameWidth", 64)
var frame_height = _sprite_config.get("frameHeight", 64)
var fps = _sprite_config.get("fps", 8)
var animations = _sprite_config.get("animations", {})
for anim_name in sprites:
var sprite_path = sprites[anim_name]
var texture = UpdateManager.load_texture(sprite_path)
if not texture:
push_warning("[MobVisual] Failed to load texture: %s" % sprite_path)
continue
print("[MobVisual] Loaded texture %s: size=%dx%d" % [anim_name, texture.get_width(), texture.get_height()])
# Get animation config
var anim_config = animations.get(anim_name, {"frames": 1, "loop": true})
var frame_count = anim_config.get("frames", 1)
var loop = anim_config.get("loop", true)
# frame_count might be a float from JSON, convert to int
frame_count = int(frame_count)
print("[MobVisual] Animation %s: frame_count=%d, loop=%s" % [anim_name, frame_count, loop])
# Add animation
sprite_frames.add_animation(anim_name)
sprite_frames.set_animation_speed(anim_name, fps)
sprite_frames.set_animation_loop(anim_name, loop)
# Add frames from sprite sheet (horizontal strip)
var tex_width = texture.get_width()
var calculated_frames = int(tex_width / frame_width) if frame_width > 0 else 1
frame_count = min(frame_count, calculated_frames)
print("[MobVisual] Texture width=%d, frame_width=%d, calculated_frames=%d, using frame_count=%d" % [tex_width, frame_width, calculated_frames, frame_count])
for i in range(frame_count):
var atlas = AtlasTexture.new()
atlas.atlas = texture
atlas.region = Rect2(i * frame_width, 0, frame_width, frame_height)
sprite_frames.add_frame(anim_name, atlas)
_animated_sprite.sprite_frames = sprite_frames
_animated_sprite.visible = true
_animated_sprite.z_index = 10 # Make sure it's on top
_animated_sprite.modulate = Color.WHITE # Ensure full visibility
_animated_sprite.position = Vector2.ZERO # Centered on parent
_using_fallback = false
print("[MobVisual] AnimatedSprite2D position: %s, scale: %s, modulate: %s" % [_animated_sprite.position, _animated_sprite.scale, _animated_sprite.modulate])
# Hide fallback
if fallback_sprite:
fallback_sprite.visible = false
# Play default animation
_update_animation_state(_current_state, 0.0)
# Debug: print the animation that should be playing
print("[MobVisual] Built animated sprite with %d animations, current animation: %s, visible: %s" % [
sprites.size(),
_animated_sprite.animation if _animated_sprite.sprite_frames else "none",
_animated_sprite.visible
])
func _on_file_downloaded(file_path: String):
# Check if this is a texture we need
if not _sprite_config.is_empty():
var sprites = _sprite_config.get("sprites", {})
for anim_name in sprites:
if sprites[anim_name] == file_path:
# A texture we need was downloaded, try building again
_build_animated_sprite()
return
func _setup_fallback(data: Dictionary):
_using_fallback = true
# Hide animated sprite if exists
if _animated_sprite:
_animated_sprite.visible = false
if fallback_sprite:
fallback_sprite.visible = true
# Use SpriteGenerator for a simple shape
if SpriteGenerator:
fallback_sprite.texture = SpriteGenerator.get_circle()
# Color based on mob type or default red
var tint = data.get("tintColor", data.get("TintColor", "#cc4444"))
fallback_sprite.modulate = Color.from_string(tint, Color(0.8, 0.3, 0.3))
func _update_animation_state(state: String, rotation: float):
_current_state = state
# Determine facing direction from rotation
_facing_direction = _rotation_to_direction(rotation)
if _animated_sprite and _animated_sprite.sprite_frames:
_play_animation(state, _facing_direction)
else:
_update_fallback_state(state)
func _rotation_to_direction(rotation: float) -> String:
# Convert rotation (radians) to cardinal direction
# 0 = right, PI/2 = down, PI = left, -PI/2 = up
var angle = fmod(rotation + TAU, TAU) # Normalize to 0-2PI
# Map to front/back/left/right (common sprite sheet naming)
if angle < PI * 0.25 or angle >= PI * 1.75:
return "right"
elif angle < PI * 0.75:
return "front" # or "down"
elif angle < PI * 1.25:
return "left"
else:
return "back" # or "up"
func _play_animation(state: String, direction: String):
if not _animated_sprite or not _animated_sprite.sprite_frames:
return
var frames = _animated_sprite.sprite_frames
# Try different animation name formats
var names_to_try = [
"%s_%s" % [state, direction], # "idle_front"
"%s_%s" % [state, _alt_direction(direction)], # "idle_down"
state, # "idle"
"idle_%s" % direction, # fallback to idle
"idle_%s" % _alt_direction(direction),
"idle"
]
for anim_name in names_to_try:
if frames.has_animation(anim_name):
print("[MobVisual] Playing animation: %s (current: %s, playing: %s)" % [anim_name, _animated_sprite.animation, _animated_sprite.is_playing()])
_animated_sprite.play(anim_name)
# Handle left direction with flip
_animated_sprite.flip_h = (direction == "left" and not frames.has_animation("%s_left" % state))
return
# No matching animation found
push_warning("[MobVisual] No animation found for state=%s direction=%s, available: %s" % [state, direction, frames.get_animation_names()])
func _alt_direction(dir: String) -> String:
# Alternative direction names
match dir:
"front": return "down"
"back": return "up"
"down": return "front"
"up": return "back"
_: return dir
func _update_fallback_state(state: String):
if not fallback_sprite:
return
# Simple color changes for fallback
match state:
"attacking":
fallback_sprite.modulate = fallback_sprite.modulate.lightened(0.3)
"chasing":
fallback_sprite.modulate = fallback_sprite.modulate.darkened(0.1)
"dead":
fallback_sprite.modulate = Color(0.3, 0.3, 0.3, 0.5)
_:
var tint = mob_data.get("tintColor", mob_data.get("TintColor", "#cc4444"))
fallback_sprite.modulate = Color.from_string(tint, Color(0.8, 0.3, 0.3))
func _apply_tint(tint_hex: String):
var tint_color = Color.from_string(tint_hex, Color.WHITE)
if _animated_sprite:
_animated_sprite.modulate = tint_color
elif fallback_sprite:
fallback_sprite.modulate = tint_color