Files
dungeon-divers/scripts/dungeon/mob_visual.gd
T
2026-01-20 18:37:23 -05:00

568 lines
17 KiB
GDScript

extends Node2D
## Mob Visual
## Renders mobs using sprite sheets from CDN with JSON animation config
## Supports two formats:
## - Legacy: separate sprite strip per animation
## - New: single sprite sheet with frame sequences
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
var _initialized: bool = false # Track if we've already set up this mob
var _last_animation: String = "" # Track animation to avoid spam
# Animation state
var _current_state: String = "idle"
var _facing_direction: String = "down" # down, up, left, right, front, back
#Temporary state translation:
const STATE_TO_ANIMATION := {
"idle": "idle",
"walking": "walk",
"chasing": "walk",
"returning": "walk",
"fleeing": "walk",
"kiting": "walk",
"attacking": "attack",
"casting": "cast",
"summoning": "cast",
"healing": "heal",
"damaged": "hurt",
"dead": "dead"
}
func _ready():
# 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)
func _state_to_animation(state: String) -> String:
state = state.to_lower()
return STATE_TO_ANIMATION.get(state, "idle")
func update_data(data: Dictionary):
mob_data = data
var mob_id = data.get("id", data.get("Id", "unknown"))
# 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
# Only process sprite config on first update or if it changed
if not _initialized:
print("[MobVisual] First init for mob %s (%s)" % [mname, mob_id])
var sprite_config = data.get("spriteConfig", data.get("SpriteConfig", null))
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()
else:
_setup_fallback(data)
# Apply tint on first setup
var tint = data.get("tintColor", data.get("TintColor", "#ffffff"))
_apply_tint(tint)
_initialized = true
# 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)
var raw_state = data.get("state", data.get("State", "idle")).to_lower()
var animation_state := _state_to_animation(raw_state)
var rotation = data.get("rotation", data.get("Rotation", 0.0))
_update_animation_state(animation_state, rotation)
# Apply scale
var mob_scale = data.get("scale", data.get("Scale", 1.0))
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
## Detects format and uses appropriate builder
# Check for new format (has "sheets" key)
if _sprite_config.has("sheets"):
_build_from_new_format()
else:
# Legacy format (has "sprites" key)
_build_from_legacy_format()
func _build_from_new_format():
## New format: sprite sheets with frame sequences
## {
## "sheets": { "main": { "path": "...", "width": 512, ... } },
## "animations": { "idle_down": { "sheet": "main", "frames": [0,1,2,3], ... } }
## }
var sheets = _sprite_config.get("sheets", {})
var animations = _sprite_config.get("animations", {})
if sheets.is_empty() or animations.is_empty():
print("[MobVisual] No sheets or animations in config")
_setup_fallback(mob_data)
return
# Check if all sheet textures are cached, request download if not
var all_cached = true
var missing_paths = []
for sheet_key in sheets:
var sheet_info = sheets[sheet_key]
var path = sheet_info.get("path", "")
if path != "":
if UpdateManager and not UpdateManager.has_file(path):
all_cached = false
missing_paths.append(path)
# Request download if UpdateManager supports it
if UpdateManager.has_method("request_file"):
UpdateManager.request_file(path)
if not all_cached:
print("[MobVisual] Missing textures, using fallback: ", missing_paths)
_setup_fallback(mob_data)
return
# 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()
# Load all sheet textures
var sheet_textures: Dictionary = {}
for sheet_key in sheets:
var sheet_info = sheets[sheet_key]
var path = sheet_info.get("path", "")
if path != "":
var texture = UpdateManager.load_texture(path)
if texture:
sheet_textures[sheet_key] = {
"texture": texture,
"width": sheet_info.get("width", texture.get_width()),
"height": sheet_info.get("height", texture.get_height()),
"frameWidth": sheet_info.get("frameWidth", 64),
"frameHeight": sheet_info.get("frameHeight", 64)
}
# Build each animation
for anim_name in animations:
var anim_config = animations[anim_name]
var sheet_key = anim_config.get("sheet", "")
if not sheet_textures.has(sheet_key):
continue
var sheet_data = sheet_textures[sheet_key]
var texture = sheet_data["texture"]
var frame_width: int = int(sheet_data["frameWidth"])
var frame_height: int = int(sheet_data["frameHeight"])
var sheet_width: int = int(sheet_data["width"])
var columns: int = int(sheet_width / frame_width) if frame_width > 0 else 1
var frames = anim_config.get("frames", [0])
var fps = anim_config.get("fps", 8.0)
var loop = anim_config.get("loop", true)
var flip_x = anim_config.get("flipX", false)
var flip_y = anim_config.get("flipY", false)
# 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 using frame indices
for frame_idx in frames:
var idx: int = int(frame_idx) # Convert float to int
var col: int = idx % columns
var row: int = idx / columns
var atlas = AtlasTexture.new()
atlas.atlas = texture
atlas.region = Rect2(col * frame_width, row * frame_height, 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
_animated_sprite.modulate = Color.WHITE
_animated_sprite.position = Vector2.ZERO
_using_fallback = false
#print("[MobVisual] NEW FORMAT - Built sprite with animations: %s" % [sprite_frames.get_animation_names()])
# Hide fallback
if fallback_sprite:
fallback_sprite.visible = false
# Play default animation
_update_animation_state(_current_state, 0.0)
func _build_from_legacy_format():
## Legacy format: separate sprite strip per animation
## {
## "sprites": { "idle_down": "path/to/idle_down.png", ... },
## "animations": { "idle_down": { "frames": 4, "loop": true } },
## "frameWidth": 64, "frameHeight": 64, "fps": 8
## }
var sprites = _sprite_config.get("sprites", {})
if sprites == null or not sprites is Dictionary or sprites.is_empty():
_setup_fallback(mob_data)
return
# Check if all required textures are cached
var all_cached = true
for anim_name in sprites:
var sprite_path = sprites[anim_name]
if not UpdateManager or not UpdateManager.has_file(sprite_path):
all_cached = false
break
if not all_cached:
_setup_fallback(mob_data)
return
# 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:
continue
# 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 = int(frame_count)
# 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)
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
_animated_sprite.modulate = Color.WHITE
_animated_sprite.position = Vector2.ZERO
_using_fallback = false
# Hide fallback
if fallback_sprite:
fallback_sprite.visible = false
# Play default animation
_update_animation_state(_current_state, 0.0)
func _on_file_downloaded(file_path: String):
# Check if this is a texture we need
if _sprite_config.is_empty():
return
# Check new format sheets
if _sprite_config.has("sheets"):
var sheets = _sprite_config.get("sheets", {})
for sheet_key in sheets:
var sheet_info = sheets[sheet_key]
if sheet_info.get("path", "") == file_path:
_build_animated_sprite()
return
# Check legacy format sprites
var sprites = _sprite_config.get("sprites", {})
for anim_name in sprites:
if sprites[anim_name] == file_path:
_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
var angle = fmod(rotation + TAU, TAU)
if angle < PI * 0.25 or angle >= PI * 1.75:
return "right"
elif angle < PI * 0.75:
return "down"
elif angle < PI * 1.25:
return "left"
else:
return "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],
"%s_%s" % [state, _alt_direction(direction)],
state,
"idle_%s" % direction,
"idle_%s" % _alt_direction(direction),
"idle",
"walk_%s",
"run_%s",
"hurt_%s",
"death_%s",
"attack_%s"
]
# Get flip info from sprite config (new format)
var should_flip_x = false
var should_flip_y = false
for anim_name in names_to_try:
if frames.has_animation(anim_name):
# Check for flip settings in new format
if _sprite_config.has("animations"):
var anim_config = _sprite_config["animations"].get(anim_name, {})
should_flip_x = anim_config.get("flipX", false)
should_flip_y = anim_config.get("flipY", false)
# Only log and play if animation changed
if anim_name != _last_animation:
#print("[MobVisual] Playing animation: %s (state=%s, dir=%s)" % [anim_name, state, direction])
_last_animation = anim_name
_animated_sprite.play(anim_name)
# Handle flipping
# For left direction without a dedicated left animation, flip the right one
if direction == "left" and not frames.has_animation("%s_left" % state):
should_flip_x = not should_flip_x # Toggle flip
_animated_sprite.flip_h = should_flip_x
_animated_sprite.flip_v = should_flip_y
return
# No animation found
#print("[MobVisual] No animation found for state=%s, dir=%s. Tried: %s" % [state, direction, names_to_try])
#print("[MobVisual] Available animations: %s" % [frames.get_animation_names()])
func _alt_direction(dir: String) -> String:
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
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
func play_hurt_effect():
"""Play hurt animation and flash mob red briefly to show damage"""
# Try to play hurt animation if available
if _animated_sprite and _animated_sprite.sprite_frames:
_play_animation("hurt", _facing_direction)
var sprite_to_flash = _animated_sprite if _animated_sprite and _animated_sprite.visible else fallback_sprite
if not sprite_to_flash:
return
# Store original color
var original_color = sprite_to_flash.modulate
# Flash red
sprite_to_flash.modulate = Color(1.5, 0.5, 0.5, 1.0) # Bright red flash
# Return to original color after 0.1 seconds
await get_tree().create_timer(0.1).timeout
if is_instance_valid(sprite_to_flash):
sprite_to_flash.modulate = original_color
func play_death_animation():
"""Play death animation and stop on last frame"""
_current_state = "dead"
if _animated_sprite and _animated_sprite.sprite_frames:
# Try to play death animation using the standard animation search
var frames = _animated_sprite.sprite_frames
var death_anim_name = ""
# Try different death animation names with direction
var names_to_try = [
"dead_%s" % _facing_direction,
"dead_%s" % _alt_direction(_facing_direction),
"death_%s" % _facing_direction,
"death_%s" % _alt_direction(_facing_direction),
"dead",
"death"
]
for anim_name in names_to_try:
if frames.has_animation(anim_name):
death_anim_name = anim_name
break
if death_anim_name != "":
# Play the death animation
_last_animation = death_anim_name
_animated_sprite.play(death_anim_name)
# Wait for animation to finish
if _animated_sprite.sprite_frames.get_animation_loop(death_anim_name):
# If it loops, disable looping temporarily
_animated_sprite.sprite_frames.set_animation_loop(death_anim_name, false)
# Wait for animation to complete
await _animated_sprite.animation_finished
# Stop on last frame
var frame_count = _animated_sprite.sprite_frames.get_frame_count(death_anim_name)
if frame_count > 0:
_animated_sprite.frame = frame_count - 1
_animated_sprite.stop()
else:
# No death animation, just fade out the fallback
_update_fallback_state("dead")
else:
# Using fallback sprite, just update its appearance
_update_fallback_state("dead")
# Hide health bar and name label for dead mobs
if health_bar:
health_bar.visible = false
if name_label:
name_label.visible = false