public static void Postfix(WeaponDamage __instance, Character _targetCharacter)
        {
            if (_targetCharacter.Alive || Time.time - _targetCharacter.TimeOfDeath < 1f)
            {
                var damages = __instance.m_tempList.Clone();
                var weapon  = __instance.m_weapon;

                _targetCharacter.ProcessDamageReduction(weapon, damages, false);

                DamageLabels.AddDamageLabel(damages, _targetCharacter.CenterPosition, _targetCharacter);
            }
        }
        public static void Postfix(PunctualDamage __instance, Character _targetCharacter)
        {
            if (_targetCharacter.Alive || Time.time - _targetCharacter.TimeOfDeath < 1f)
            {
                bool ignoreBarrier = false;
                if (__instance.ParentSynchronizer is StatusEffect status)
                {
                    ignoreBarrier = status.IgnoreBarrier;
                }

                var damages = __instance.m_tempList.Clone();
                var weapon  = __instance.ParentSynchronizer as Weapon;

                _targetCharacter.ProcessDamageReduction(weapon, damages, ignoreBarrier);

                DamageLabels.AddDamageLabel(damages, _targetCharacter.CenterPosition, _targetCharacter);
            }
        }
        public static void Prefix(Weapon __instance, Character _hitCharacter, Vector3 _hitPos, Vector3 _dir, bool _blocked)
        {
            var selfChar   = __instance.m_ownerCharacter;
            var alreadyhit = __instance.m_alreadyHitChars;

            bool eligible = _hitCharacter &&
                            (_hitCharacter != selfChar) &&
                            (__instance.CanHitEveryoneButOwner || selfChar.TargetingSystem.IsTargetable(_hitCharacter));

            if (eligible && !alreadyhit.Contains(_hitCharacter))
            {
                if (!_blocked)
                {
                    DamageList damages = __instance.GetDamage(0);
                    _hitCharacter.ProcessDamageReduction(__instance, damages, false);

                    DamageLabels.AddDamageLabel(damages, _hitPos, _hitCharacter);
                }
            }
        }
        public static void Prefix(Weapon __instance, RaycastHit _hit)
        {
            Hitbox hitbox = _hit.collider?.GetComponent <Hitbox>();

            if (!hitbox)
            {
                return;
            }

            var owner  = __instance.OwnerCharacter;
            var target = hitbox.OwnerChar;

            if (!target || !owner)
            {
                return;
            }

            if (!__instance.m_alreadyHitChars.Contains(target) &&
                target != owner &&
                (__instance.CanHitEveryoneButOwner || owner.TargetingSystem.IsTargetable(target)))
            {
                float angle = Vector3.Angle(hitbox.OwnerChar.transform.forward, owner.transform.position - hitbox.OwnerChar.transform.position);
                if (!__instance.Unblockable &&
                    hitbox.OwnerChar.Blocking &&
                    angle < (hitbox.OwnerChar.ShieldEquipped ? Weapon.SHIELD_BLOCK_ANGLE : Weapon.BLOCK_ANGLE))
                {
                    return;
                }

                if (__instance.m_attackID >= 0)
                {
                    DamageList damages = __instance.GetDamage(__instance.m_attackID).Clone();
                    target.ProcessDamageReduction(__instance, damages, false);

                    DamageLabels.AddDamageLabel(damages, _hit.point, target);
                }
            }
        }