123 lines
4.7 KiB
GDScript
123 lines
4.7 KiB
GDScript
class_name CombatResolver
|
|
extends RefCounted
|
|
|
|
const StatResolverScript := preload("res://scripts/resolvers/stat_resolver.gd")
|
|
const DefenseResolverScript := preload("res://scripts/resolvers/defense_resolver.gd")
|
|
|
|
|
|
static func resolve_hit(emitter: Area2D, receiver: Area2D) -> Dictionary:
|
|
var action: Resource = emitter.get("action_context") as Resource
|
|
var judgement: Dictionary = emitter.get("judgement_context")
|
|
var receiver_context := _receiver_context(receiver, emitter)
|
|
var attacker_effects := _owner_effect_container(emitter)
|
|
var defense := DefenseResolverScript.resolve_effective_defense(receiver_context, _action_tags(action))
|
|
var raw_damage := StatResolverScript.resolve_damage(float(emitter.get("damage")), action, judgement, attacker_effects, null)
|
|
var final_damage := int(round(raw_damage * float(defense.get("damage_mult", 1.0))))
|
|
var attacker_interrupts := _attacker_interrupts(emitter)
|
|
# 受击方免压制钩子（2026-07-05 定案）：Boss 对不耗能量的攻击恒霸体——
|
|
# 伤害照常结算，但打断与击退一并取消。
|
|
if attacker_interrupts and _receiver_shrugs_off(receiver, action):
|
|
attacker_interrupts = false
|
|
var knockback := _resolved_knockback(emitter, action, judgement, attacker_effects, defense) if attacker_interrupts else Vector2.ZERO
|
|
return {
|
|
"damage": final_damage,
|
|
"hit_type": StringName(str(emitter.get("hit_type"))),
|
|
"action": action,
|
|
"action_tags": _action_tags(action),
|
|
"judgement": judgement,
|
|
"from": emitter.global_position,
|
|
"emitter": emitter,
|
|
"receiver": receiver,
|
|
"defense": defense,
|
|
"interrupts": bool(defense.get("interrupts", true)) and attacker_interrupts,
|
|
"knockback": knockback,
|
|
}
|
|
|
|
|
|
static func _attacker_interrupts(emitter: Area2D) -> bool:
|
|
var value = emitter.get("attacker_interrupts")
|
|
if value is bool:
|
|
return value
|
|
return true
|
|
|
|
|
|
static func _receiver_shrugs_off(receiver: Area2D, action: Resource) -> bool:
|
|
var owner := receiver.get_parent()
|
|
if owner == null or not owner.has_method("shrugs_off_hit"):
|
|
return false
|
|
return bool(owner.call("shrugs_off_hit", action))
|
|
|
|
|
|
static func _receiver_context(receiver: Area2D, emitter: Area2D = null) -> Dictionary:
|
|
var owner := receiver.get_parent()
|
|
if owner != null:
|
|
var context := {}
|
|
var state_machine := owner.get_node_or_null("StateMachine")
|
|
if state_machine != null and state_machine.has_method("build_context"):
|
|
context = state_machine.call("build_context")
|
|
var effect_container := owner.get_node_or_null("EffectContainer")
|
|
if effect_container != null:
|
|
context["effect_container"] = effect_container
|
|
var block_judgement := _receiver_block_judgement(owner)
|
|
if not block_judgement.is_empty():
|
|
context["block_judgement"] = block_judgement
|
|
if emitter != null and owner is Node2D:
|
|
context["attack_from_front"] = _attack_from_front(owner as Node2D, emitter)
|
|
return context
|
|
return {}
|
|
|
|
|
|
static func _receiver_block_judgement(owner: Node) -> StringName:
|
|
var action_controller := owner.get_node_or_null("ActionController")
|
|
if action_controller == null:
|
|
return &""
|
|
var intent = action_controller.get("current_intent")
|
|
if intent == null:
|
|
return &""
|
|
var judgement = intent.get("judgement")
|
|
if judgement is Dictionary and judgement.has("label"):
|
|
return StringName(str(judgement["label"]))
|
|
return &""
|
|
|
|
|
|
static func _attack_from_front(owner: Node2D, emitter: Area2D) -> bool:
|
|
var heading = owner.get("heading")
|
|
if not (heading is Vector2) or is_zero_approx((heading as Vector2).x):
|
|
return true
|
|
var to_attacker := emitter.global_position.x - owner.global_position.x
|
|
if is_zero_approx(to_attacker):
|
|
return true
|
|
return signf(to_attacker) == signf((heading as Vector2).x)
|
|
|
|
|
|
static func _owner_effect_container(area: Area2D) -> Node:
|
|
var source = area.get("source_actor")
|
|
if source is Node and is_instance_valid(source):
|
|
return (source as Node).get_node_or_null("EffectContainer")
|
|
var owner := area.get_parent()
|
|
if owner == null:
|
|
return null
|
|
return owner.get_node_or_null("EffectContainer")
|
|
|
|
|
|
static func _action_tags(action: Resource) -> Array[StringName]:
|
|
var result: Array[StringName] = []
|
|
if action != null and action.get("action_tags") is Array:
|
|
for tag: Variant in action.get("action_tags"):
|
|
result.append(StringName(str(tag)))
|
|
return result
|
|
|
|
|
|
static func _resolved_knockback(emitter: Area2D, action: Resource, judgement: Dictionary, attacker_effects: Variant, defense: Dictionary) -> Vector2:
|
|
var defense_state := StringName(str(defense.get("defense_state", &"Vulnerable")))
|
|
if defense_state == &"Invincible" or defense_state == &"SuperArmor":
|
|
return Vector2.ZERO
|
|
return StatResolverScript.resolve_knockback(action, judgement, _base_knockback(emitter), attacker_effects)
|
|
|
|
|
|
static func _base_knockback(emitter: Area2D) -> Vector2:
|
|
var value = emitter.get("base_knockback")
|
|
if value is Vector2:
|
|
return value
|
|
return Vector2.ZERO
|