Files
2026-02-09 12:17:26 -05:00

670 lines
22 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
var _sprite_config_key: String = ""
var _definition_id = null # Server definitionId for fallback art resolution
# Shared cache to reuse sprite frames across mobs with identical configs
static var _sprite_frames_cache: Dictionary = {} # key -> SpriteFrames
# 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 reset_state():
## Fully reset visual state so the node can be reused for a respawned mob.
_current_state = "idle"
_facing_direction = "down"
_initialized = false
_last_animation = ""
func update_data(data: Dictionary):
mob_data = data
var mob_id = data.get("id", data.get("Id", "unknown"))
var sprite_config = data.get("spriteConfig", data.get("SpriteConfig", null))
# Track definitionId for fallback art resolution
var def_id = data.get("definitionId", data.get("DefinitionId", null))
if def_id != null:
_definition_id = def_id
# 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
# Process sprite config on first update or if it changed.
# Server may send null for invalid configs — treat as missing.
if sprite_config != null and sprite_config is Dictionary and not sprite_config.is_empty():
# Validate that config has at minimum sheets or sprites
var has_sheets = sprite_config.has("sheets") and sprite_config["sheets"] is Dictionary and not sprite_config["sheets"].is_empty()
var has_sprites = sprite_config.has("sprites") and sprite_config["sprites"] is Dictionary and not sprite_config["sprites"].is_empty()
if has_sheets or has_sprites:
_sprite_config_key = _get_sprite_config_key(sprite_config)
if sprite_config != _sprite_config:
_sprite_config = sprite_config
_using_fallback = true
if _animated_sprite:
_animated_sprite.visible = false
if UpdateManager and UpdateManager.has_method("queue_build"):
UpdateManager.queue_build(Callable(self, "_build_animated_sprite"))
else:
_build_animated_sprite()
else:
# Config present but missing actual sprite data — use fallback
if not _sprite_config.is_empty():
_sprite_config = {}
_sprite_config_key = ""
_setup_fallback(data)
else:
# Null or missing sprite config — use fallback with safe defaults
if not _sprite_config.is_empty():
_sprite_config = {}
_sprite_config_key = ""
_setup_fallback(data)
if not _initialized:
print("[MobVisual] First init for mob %s (%s)" % [mname, mob_id])
# Apply tint on first setup (null-safe: server may send null for invalid tint)
var tint = data.get("tintColor", data.get("TintColor", "#ffffff"))
if tint == null or not (tint is String) or tint.is_empty():
tint = "#ffffff"
_apply_tint(tint)
_initialized = true
# Resolve animation — prefer server-authoritative currentAnimation, fall back to state.
# If dungeon_manager already triggered play_death_animation() this tick (setting
# _current_state = "dead"), don't let a stale currentAnimation override it — unless
# the server explicitly says the mob is alive via a non-dead animation.
var current_anim = data.get("currentAnimation", data.get("CurrentAnimation", null))
var rotation = data.get("rotation", data.get("Rotation", 0.0))
if current_anim != null and current_anim is String and not current_anim.is_empty():
var anim_lower = current_anim.to_lower()
# Map through STATE_TO_ANIMATION if it's a known state name; otherwise use as-is
var animation_state: String
if STATE_TO_ANIMATION.has(anim_lower):
animation_state = STATE_TO_ANIMATION[anim_lower]
else:
animation_state = anim_lower
if animation_state == "dead":
# Server confirms death — apply death animation
_update_animation_state(animation_state, rotation)
elif _current_state == "dead":
# Server says non-dead but we're locally dead — server override, mob is alive
_update_animation_state(animation_state, rotation)
else:
# Normal case: apply server animation
_update_animation_state(animation_state, rotation)
elif _current_state != "dead":
# Legacy path: use state field, but still skip if locally dead (no server override)
var raw_state = data.get("state", data.get("State", "idle")).to_lower()
var animation_state := _state_to_animation(raw_state)
_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
if _sprite_config_key != "" and _sprite_frames_cache.has(_sprite_config_key):
_use_cached_frames(_sprite_frames_cache[_sprite_config_key])
_using_fallback = false
if fallback_sprite:
fallback_sprite.visible = false
return
# 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)
_cache_and_apply_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)
_cache_and_apply_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:
if UpdateManager and UpdateManager.has_method("queue_build"):
UpdateManager.queue_build(Callable(self, "_build_animated_sprite"))
else:
_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:
if UpdateManager and UpdateManager.has_method("queue_build"):
UpdateManager.queue_build(Callable(self, "_build_animated_sprite"))
else:
_build_animated_sprite()
return
func _get_sprite_config_key(config: Dictionary) -> String:
# Use JSON as a stable-ish cache key (server sends consistent key order)
return JSON.stringify(config)
func _cache_and_apply_frames(sprite_frames: SpriteFrames) -> void:
if _sprite_config_key != "":
_sprite_frames_cache[_sprite_config_key] = sprite_frames
_use_cached_frames(sprite_frames)
func _use_cached_frames(sprite_frames: SpriteFrames) -> void:
if not _animated_sprite:
_animated_sprite = AnimatedSprite2D.new()
_animated_sprite.name = "MobAnimatedSprite"
add_child(_animated_sprite)
_animated_sprite.sprite_frames = sprite_frames
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
# Try definitionId-based local sprite lookup before falling back to generic shape
var resolved_texture: Texture2D = null
if _definition_id != null:
var def_path = "res://textures/mobs/%s.png" % str(_definition_id)
if ResourceLoader.exists(def_path):
resolved_texture = load(def_path)
if resolved_texture:
fallback_sprite.texture = resolved_texture
elif SpriteGenerator:
fallback_sprite.texture = SpriteGenerator.get_circle()
# Color based on tint — safe defaults when null/missing
var tint = data.get("tintColor", data.get("TintColor", "#ffffff"))
if tint == null or not (tint is String) or tint.is_empty():
tint = "#ffffff"
fallback_sprite.modulate = Color.from_string(tint, Color.WHITE)
# Apply safe default scale
var mob_scale = data.get("scale", data.get("Scale", 1.0))
if mob_scale == null or not (mob_scale is float or mob_scale is int) or mob_scale <= 0:
mob_scale = 1.0
fallback_sprite.scale = Vector2.ONE * mob_scale
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:
_last_animation = anim_name
_animated_sprite.play(anim_name)
# Handle horizontal flipping when playing opposite direction's animation.
# If facing right but playing a _left animation (or vice versa), flip.
if direction == "right" and anim_name.ends_with("_left"):
should_flip_x = not should_flip_x
elif direction == "left" and anim_name.ends_with("_right"):
should_flip_x = not should_flip_x
_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 != "":
# Disable looping for death animation BEFORE playing
_animated_sprite.sprite_frames.set_animation_loop(death_anim_name, false)
# Play the death animation
_last_animation = death_anim_name
_animated_sprite.play(death_anim_name)
# 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
print("[Frame] - ", frame_count)
print("[Frame] - ", _animated_sprite.frame)
#_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