670 lines
22 KiB
GDScript
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
|