301 lines
9.4 KiB
GDScript
301 lines
9.4 KiB
GDScript
extends Draggable
|
|
class_name Card
|
|
|
|
var card_id
|
|
|
|
enum burned {
|
|
NOT,
|
|
SINGED,
|
|
BURNING,
|
|
TORCHED
|
|
}
|
|
|
|
#FIXME remove this legacy stuff without loosing the evil notes ...
|
|
var compatible_sticky_notes: Array[StickyNote] = []
|
|
@export var evil_sticky_notes: Array[StickyNote] = []
|
|
var own_sticky_notes: Array[StickyNote] = []
|
|
var wiggle_pos: float = 0
|
|
var wiggle_intensity: float = 0
|
|
var noise: Noise = FastNoiseLite.new()
|
|
var wiggle_tween : Tween
|
|
var scale_tween : Tween
|
|
var brightness_tween : Tween
|
|
|
|
var transfor_arr: Array[Transform2D] = [
|
|
Transform2D(0.9, Vector2(-125, -83)),
|
|
Transform2D(-0.3, Vector2(-126, -75)),
|
|
Transform2D(-0.3, Vector2(-126, -74)),
|
|
Transform2D(-0.3, Vector2(-126, -73)),
|
|
Transform2D(0.5, Vector2(-126, -77))
|
|
]
|
|
|
|
@export var text: String = "" :
|
|
set(value):
|
|
text = value
|
|
_on_text_updated.call_deferred()
|
|
|
|
@onready var label: Label = $Label
|
|
@onready var background_sprite: AnimatedSprite2D = $AnimatedSprite2D
|
|
|
|
@export var wiggle_strength: float = 0.2
|
|
@export var wiggle_speed: float = 5
|
|
@export_range(1, 2) var scale_bump: float = 1.05
|
|
@export_range(1.0, 10.0) var bounce_speed: float = 5
|
|
|
|
@export_color_no_alpha var highlight_color: Color = Color(1.4, 1.4, 1.4)
|
|
|
|
## Override set_highlight to add visual feedback for cards
|
|
func set_highlight(value: bool) -> void:
|
|
if value == _highlighted: return
|
|
_highlighted = value
|
|
|
|
if scale_tween: scale_tween.kill()
|
|
if wiggle_tween: wiggle_tween.kill()
|
|
if brightness_tween: brightness_tween.kill()
|
|
|
|
if _highlighted:
|
|
scale_tween = get_tree().create_tween()
|
|
scale_tween.tween_property(self, "scale", Vector2(scale_bump, scale_bump), 0.1)
|
|
wiggle_tween = get_tree().create_tween()
|
|
wiggle_tween.tween_property(self, "wiggle_intensity", 1, 0.2)
|
|
brightness_tween = get_tree().create_tween()
|
|
brightness_tween.set_parallel(true)
|
|
brightness_tween.tween_property(background_sprite, "modulate", highlight_color, 0.15)
|
|
brightness_tween.tween_property(label, "modulate", highlight_color, 0.15)
|
|
else:
|
|
scale_tween = get_tree().create_tween()
|
|
scale_tween.tween_property(self, "scale", Vector2(1, 1), 0.3)
|
|
wiggle_tween = get_tree().create_tween()
|
|
wiggle_tween.tween_property(self, "wiggle_intensity", 0, 0.5)
|
|
brightness_tween = get_tree().create_tween()
|
|
brightness_tween.set_parallel(true)
|
|
brightness_tween.tween_property(background_sprite, "modulate", Color.WHITE, 0.2)
|
|
brightness_tween.tween_property(label, "modulate", Color.WHITE, 0.2)
|
|
|
|
|
|
@export var voice_line: AudioStream = null
|
|
@export var is_dragable: bool = false
|
|
@export var diameter := 336.0
|
|
@export_range(0, 2) var burn_progress: float = 0:
|
|
set(burn):
|
|
if is_node_ready():
|
|
if burn > 0 and background_sprite.material == null:
|
|
if background_sprite != null:
|
|
background_sprite.material = crumble_material.duplicate()
|
|
add_child(card_fire, false, Node.INTERNAL_MODE_FRONT)
|
|
card_fire.material = card_fire.material.duplicate()
|
|
elif burn_progress > 0 and burn <= 0:
|
|
background_sprite.material.set_shader_parameter("fire_progression", 0)
|
|
card_fire.material.set_shader_parameter("fire_progression", 0)
|
|
background_sprite.material = null
|
|
remove_child(card_fire)
|
|
|
|
burn_progress = burn
|
|
if background_sprite != null and card_fire != null and burn_progress > 0:
|
|
background_sprite.material.set_shader_parameter("fire_progression", burn_progress)
|
|
card_fire.material.set_shader_parameter("fire_progression", burn_progress)
|
|
background_sprite.visible = burn_progress < 2
|
|
card_fire.visible = burn_progress < 2
|
|
label.modulate = Color.WHITE.lerp(Color(0,0,0,0), clampf(burn_progress*3-3, 0, 1))
|
|
|
|
var burn_tween: Tween
|
|
signal has_burned
|
|
|
|
var burn_state: burned = burned.NOT:
|
|
set(burning):
|
|
if burning != burn_state:
|
|
if burn_tween: burn_tween.kill()
|
|
match burning:
|
|
burned.NOT:
|
|
burn_tween = get_tree().create_tween()
|
|
burn_tween.tween_property(self, "burn_progress", 0, 0.5)
|
|
burn_state = burning
|
|
burned.SINGED:
|
|
burn_tween = get_tree().create_tween()
|
|
burn_tween.set_ease(Tween.EASE_OUT)
|
|
burn_tween.set_trans(Tween.TRANS_SINE)
|
|
burn_tween.tween_property(self, "burn_progress", 0.5, 2)
|
|
burn_state = burning
|
|
burned.TORCHED:
|
|
print_debug("Card %s has been burned." % HardCards.get_obscure_name(name))
|
|
has_burned.emit()
|
|
burn_state = burning
|
|
|
|
func torch():
|
|
if burn_tween: burn_tween.kill()
|
|
burn_state = burned.TORCHED
|
|
burn_tween = create_tween()
|
|
burn_tween.tween_property(self, "burn_progress", 2.0, 2)
|
|
await burn_tween.finished
|
|
|
|
var crumble_material: ShaderMaterial = preload("res://logic-scenes/card_burner/card_crumble.material")
|
|
var card_fire: Sprite2D = preload("res://logic-scenes/card_burner/card_fire.tscn").instantiate()
|
|
|
|
var sticky_note_position: Vector2 = Vector2(-66, 83)
|
|
|
|
var mouse_offset: Vector2
|
|
|
|
func init(card_name: String = "card", own_id:StringName = "-1") -> void:
|
|
if card_name != "c_void":
|
|
text = card_name
|
|
if !card_name.begins_with("c"):
|
|
push_error("Illegal card!", card_name, own_id)
|
|
card_id = own_id
|
|
name = card_name
|
|
|
|
|
|
func _ready():
|
|
super._ready()
|
|
_handle_wiggle(0)
|
|
_on_text_updated.call_deferred()
|
|
|
|
func _on_text_updated():
|
|
if is_node_ready():
|
|
var curr_frame := text.hash() % background_sprite.sprite_frames.get_frame_count(background_sprite.animation)
|
|
background_sprite.frame = curr_frame
|
|
|
|
if text == "":
|
|
if background_sprite.get_child_count() == 0:
|
|
background_sprite.add_child(load("res://logic-scenes/board/void_stuff.tscn").instantiate(), false, Node.INTERNAL_MODE_DISABLED)
|
|
else:
|
|
if background_sprite.get_child_count() > 0:
|
|
background_sprite.get_child(0).queue_free()
|
|
|
|
label.text = text
|
|
|
|
wiggle_pos = float(text.hash() % 100)
|
|
|
|
label.rotation = deg_to_rad(transfor_arr[curr_frame].get_rotation())
|
|
#label.position = transfor_arr[curr_frame].origin
|
|
|
|
burn_progress = burn_progress
|
|
|
|
if not Engine.is_editor_hint():
|
|
_handle_wiggle(0)
|
|
|
|
func _process(delta: float) -> void:
|
|
if highlighted:
|
|
_handle_wiggle(delta)
|
|
|
|
if get_overlapping_areas().size() > 0 and is_dragable:
|
|
for area in get_overlapping_areas():
|
|
if area is Card:
|
|
if not (area.highlighted or self.highlighted) and area.is_dragable:
|
|
var diff:Vector2 = position - area.position
|
|
position -= diff.normalized() * ((diff.length()-diameter)/diameter) * bounce_speed * (delta/(1.0/60))
|
|
|
|
_move_card()
|
|
|
|
func _handle_wiggle(delta):
|
|
wiggle_pos += delta * wiggle_speed * wiggle_intensity
|
|
rotation = noise.get_noise_1d(wiggle_pos)*wiggle_strength
|
|
|
|
|
|
func _on_mouse_entered() -> void:
|
|
super._on_mouse_entered()
|
|
|
|
func _on_mouse_exited():
|
|
super._on_mouse_exited()
|
|
if burn_state == burned.SINGED:
|
|
burn_state = burned.NOT
|
|
|
|
func _move_card():
|
|
if is_dragged:
|
|
update_drag_position(get_viewport().get_mouse_position())
|
|
|
|
func has_sticky_note_attached() -> bool:
|
|
return get_attached_sticky_note() != null
|
|
|
|
func get_attached_sticky_note() -> StickyNote:
|
|
for child in get_children(false):
|
|
if child is StickyNote:
|
|
return child
|
|
return null
|
|
|
|
|
|
func preview_sticky_note(sticky_note: StickyNote):
|
|
if not is_instance_valid(sticky_note):
|
|
return
|
|
# Keep sticky in current parent during preview (just move it visually)
|
|
# Use a safe transform with validated position
|
|
var target_pos := global_position + sticky_note_position
|
|
if is_finite(target_pos.x) and is_finite(target_pos.y):
|
|
sticky_note.tween_transform_to(Transform2D(0, target_pos))
|
|
else:
|
|
push_warning("Card.preview_sticky_note: Invalid position calculated, skipping tween")
|
|
|
|
func attach_sticky_note(sticky_note: StickyNote) -> bool:
|
|
if has_sticky_note_attached():
|
|
return false
|
|
|
|
sticky_note.reparent(self)
|
|
sticky_note.position = sticky_note_position
|
|
sticky_note.is_dragable = false
|
|
|
|
if name == "c_hit" and sticky_note.name == "c_effort" and Steamworks.has_initialized:
|
|
Steam.setAchievement("FIGHT_FOR_GOOD")
|
|
Steam.storeStats()
|
|
|
|
return true
|
|
|
|
func remove_sticky_note() -> StickyNote:
|
|
var former_child: StickyNote = get_attached_sticky_note()
|
|
if not former_child:
|
|
return null
|
|
former_child.reparent(get_parent())
|
|
return former_child
|
|
|
|
func exchange_sticky_note_with(new_note: StickyNote) -> StickyNote:
|
|
if new_note == get_attached_sticky_note():
|
|
return null
|
|
|
|
var old_note := remove_sticky_note()
|
|
attach_sticky_note(new_note)
|
|
return old_note
|
|
|
|
|
|
# === DROP TARGET PATTERN IMPLEMENTATION ===
|
|
|
|
## Temporary storage for exchanged sticky during drop operation
|
|
var _last_exchanged_sticky: StickyNote = null
|
|
|
|
## Checks if this card can accept the given draggable
|
|
func can_accept_drop(draggable: Draggable) -> bool:
|
|
return draggable is StickyNote
|
|
|
|
## Handles dropping a sticky note onto this card
|
|
## Returns DropResult indicating success, rejection, or exchange
|
|
func handle_drop(draggable: StickyNote) -> int:
|
|
if not can_accept_drop(draggable):
|
|
return Draggable.DropResult.REJECTED
|
|
|
|
if has_sticky_note_attached():
|
|
# Exchange: remove current, attach new, store old for retrieval
|
|
_last_exchanged_sticky = exchange_sticky_note_with(draggable)
|
|
# Reset z_index for newly attached sticky
|
|
draggable.z_index = 0
|
|
return Draggable.DropResult.EXCHANGED
|
|
else:
|
|
# Simple attach
|
|
if attach_sticky_note(draggable):
|
|
# Reset z_index for newly attached sticky
|
|
draggable.z_index = 0
|
|
return Draggable.DropResult.ACCEPTED
|
|
else:
|
|
# Attach failed (shouldn't happen, but handle it)
|
|
return Draggable.DropResult.REJECTED
|
|
|
|
## Retrieves the sticky that was exchanged during last drop
|
|
## Clears the reference after retrieval
|
|
func get_last_exchanged_sticky() -> StickyNote:
|
|
var result := _last_exchanged_sticky
|
|
_last_exchanged_sticky = null
|
|
return result
|
|
|
|
|
|
# === DRAG LIFECYCLE OVERRIDES ===
|
|
|
|
## Cards always drop back to board dropzone
|
|
func find_drop_target() -> Node:
|
|
return _get_board()
|