My contribution to stabilizing release

Assets/Gothic-Core/Scripts/Adapters/Animations/Morph/AbstractMorphAnimation.cs

@@ -57,6 +57,12 @@ protected void StartAnimation(string morphMeshName, [CanBeNull] string animation
             var newMorph = new MorphAnimationData();
 
             newMorph.MeshMetadata = _resourceCacheService.TryGetMorphMesh(morphMeshName);
+            if (newMorph.MeshMetadata == null)
+            {
+                Logger.LogWarning($"MorphMesh not found: {morphMeshName}", LogCat.Mesh);
+                return;
+            }
+
             newMorph.AnimationMetadata = animationName == null
                 ? newMorph.MeshMetadata.Animations.First()
                 : newMorph.MeshMetadata.Animations.First(anim => anim.Name.EqualsIgnoreCase(animationName));

Assets/Gothic-Core/Scripts/Adapters/Npc/NpcAttackAdapter.cs

@@ -0,0 +1,161 @@
+using System.Linq;
+using Gothic.Core.Const;
+using Gothic.Core.Models.Container;
+using Gothic.Core.Domain.Npc.Actions.AnimationActions;
+using MyBox;
+using UnityEngine;
+using ZenKit.Daedalus;
+
+namespace Gothic.Core.Adapters.Npc
+{
+    /// <summary>
+    /// Attached to NPC/Monster root collider to allow them to deal melee damage via unarmed attacks.
+    /// Fires FightHit events when the NPC's collider hits an opponent during attack animations.
+    /// </summary>
+    public class NpcAttackAdapter : MonoBehaviour
+    {
+        private NpcContainer _npcContainer;
+        private BoxCollider _collider;
+        private float _attackHitCooldown;
+
+        private void Start()
+        {
+            var npcLoader = GetComponentInParent<NpcLoader>();
+            if (npcLoader != null)
+            {
+                _npcContainer = npcLoader.Container;
+            }
+
+            _collider = GetComponent<BoxCollider>();
+        }
+
+        private void Update()
+        {
+            // Reduce cooldown timer each frame
+            if (_attackHitCooldown > 0)
+            {
+                _attackHitCooldown -= Time.deltaTime;
+            }
+        }
+
+        /// <summary>
+        /// Called when the NPC's collider hits something during combat.
+        /// Checks if the NPC is actively attacking and if the target is valid.
+        /// </summary>
+        private void OnTriggerEnter(Collider other)
+        {
+            // Can't hit without a valid container
+            if (_npcContainer == null)
+            {
+                Debug.LogWarning($"[NpcAttackAdapter] No NPC container");
+                return;
+            }
+
+            // Check if this is within attack hit cooldown to prevent multiple hits per attack
+            if (_attackHitCooldown > 0)
+            {
+                Debug.LogWarning($"[NpcAttackAdapter] Hit in cooldown (remaining: {_attackHitCooldown:F2}s)");
+                return;
+            }
+
+            // The target must have a hitbox layer
+            if (other.gameObject.layer != Constants.VobHitbox)
+            {
+                Debug.LogWarning($"[NpcAttackAdapter] Wrong layer: {LayerMask.LayerToName(other.gameObject.layer)}");
+                return;
+            }
+
+            Debug.Log($"[NpcAttackAdapter] Collision with hitbox layer: {other.gameObject.name}");
+
+            // Try to get the target NPC/Player
+            var targetNpcLoader = other.GetComponentInParent<NpcLoader>();
+            if (targetNpcLoader == null)
+            {
+                Debug.LogWarning($"[NpcAttackAdapter] No target NpcLoader found");
+                return;
+            }
+
+            var targetNpcContainer = targetNpcLoader.Container;
+            if (targetNpcContainer == null)
+            {
+                Debug.LogWarning($"[NpcAttackAdapter] No target NpcContainer found");
+                return;
+            }
+
+            Debug.Log($"[NpcAttackAdapter] Target NPC: {targetNpcContainer.Instance.GetName(NpcNameSlot.Slot0)}");
+
+            // Don't let NPCs hit themselves
+            if (targetNpcContainer == _npcContainer)
+            {
+                Debug.LogWarning($"[NpcAttackAdapter] Target is self, ignoring");
+                return;
+            }
+
+            Debug.Log($"[NpcAttackAdapter] Checking if {_npcContainer.Instance.GetName(NpcNameSlot.Slot0)} is attacking...");
+
+            // Check if the NPC is currently attacking
+            if (!IsNpcCurrentlyAttacking())
+            {
+                Debug.LogWarning($"[NpcAttackAdapter] Not in attack state");
+                return;
+            }
+
+            // Fire the hit event
+            var hitPosition = transform.position;
+            Debug.Log($"[NpcAttackAdapter] *** HIT FIRED! {_npcContainer.Instance.GetName(NpcNameSlot.Slot0)} → {targetNpcContainer.Instance.GetName(NpcNameSlot.Slot0)} at {hitPosition}");
+            GlobalEventDispatcher.FightHit.Invoke(_npcContainer, targetNpcContainer, hitPosition);
+
+            // Set cooldown to prevent multiple hits in rapid succession (0.5 seconds)
+            _attackHitCooldown = 0.5f;
+        }
+
+        /// <summary>
+        /// Determines if the NPC is currently in an attack animation.
+        /// Checks if the current animation action is an attack-related action.
+        /// </summary>
+        private bool IsNpcCurrentlyAttacking()
+        {
+            if (_npcContainer?.Props?.CurrentAction == null)
+            {
+                Debug.LogWarning($"[NpcAttackAdapter] No CurrentAction");
+                return false;
+            }
+
+            // Check if the current action is an attack-based action
+            // AttackPlayAni is used for all NPC melee attacks
+            var currentAction = _npcContainer.Props.CurrentAction;
+            var actionTypeName = currentAction.GetType().Name;
+
+            Debug.Log($"[NpcAttackAdapter] CurrentAction type: {actionTypeName}");
+
+            // Direct check for AttackPlayAni type (preferred, most reliable)
+            if (actionTypeName == "AttackPlayAni")
+            {
+                Debug.Log($"[NpcAttackAdapter] IsAttacking=TRUE (AttackPlayAni)");
+                return true;
+            }
+
+            // Also support PlayAni with attack animations by checking the animation name
+            if (actionTypeName == "PlayAni")
+            {
+                // PlayAni stores animation name in Action.String0
+                // Animation names for attacks typically contain "attack" or follow pattern like "s_1hAttack", "s_2hAttack"
+                if (currentAction.Action?.String0 != null)
+                {
+                    var aniName = currentAction.Action.String0.ToLower();
+                    Debug.Log($"[NpcAttackAdapter] PlayAni animation: {aniName}");
+                    var isAttack = aniName.Contains("attack");
+                    Debug.Log($"[NpcAttackAdapter] IsAttacking={isAttack}");
+                    return isAttack;
+                }
+                else
+                {
+                    Debug.LogWarning($"[NpcAttackAdapter] PlayAni but no animation name");
+                }
+            }
+
+            Debug.LogWarning($"[NpcAttackAdapter] IsAttacking=FALSE (type: {actionTypeName})");
+            return false;
+        }
+    }
+}

Assets/Gothic-Core/Scripts/Adapters/Npc/NpcLoader.cs

@@ -12,3 +12,4 @@ public class NpcLoader : MonoBehaviour
         public bool IsLoaded;
     }
 }
+

Assets/Gothic-Core/Scripts/Adapters/Vob/Item/WeaponAttackAdapter.cs

@@ -1,5 +1,9 @@
+using System;
 using Gothic.Core.Const;
+using Gothic.Core.Adapters.Npc;
+using Gothic.Core.Models.Container;
 using UnityEngine;
+using ZenKit.Daedalus;
 
 namespace Gothic.Core.Adapters.Vob.Item
 {
@@ -11,40 +15,135 @@ namespace Gothic.Core.Adapters.Vob.Item
     /// </summary>
     public class WeaponAttackAdapter : MonoBehaviour
     {
+        private VobContainer _weaponVobContainer;
+        private NpcContainer _targetNpcContainer;
+
+        private void Start()
+        {
+            // Get reference to this weapon's VobContainer if it exists
+            var vobLoader = GetComponentInParent<VobLoader>();
+            if (vobLoader != null)
+            {
+                _weaponVobContainer = vobLoader.Container;
+            }
+        }
+
         /// <summary>
-        /// TODO - Need to be updated to support fist collider from monsters and player as well
-        /// Is the other who's hitting me?:
-        /// 1. A VobItem (aka weapon)
-        /// 2. Is the attacker in attack window state
+        /// TODO - We need to handle multiple hitboxes on the same target (e.g. head vs body) and ensure we don't apply multiple hits from one attack.
+        /// TODO - figure out how to do fists
+        /// TODO - figure out how to do NPC-to-NPC hits (e.g. monster attacking hero or monster attacking monster)
+        /// Handles collision between weapon and potential targets (NPCs/Monsters).
+        /// Validates the hit and fires FightHit event if conditions are met.
         /// </summary>
         private void OnTriggerEnter(Collider other)
         {
             if (other.gameObject.layer != Constants.VobHitbox)
+            {
+                Debug.LogWarning($"[WeaponAttackAdapter] Wrong layer: {LayerMask.LayerToName(other.gameObject.layer)}");
+                return;
+            }
+
+            Debug.Log($"[WeaponAttackAdapter] Collision with VobHitbox: {other.gameObject.name}");
+
+            // Try to get the target NPC/Monster from the hitbox
+            var targetNpcLoader = other.GetComponentInParent<NpcLoader>();
+            if (targetNpcLoader == null)
+            {
+                Debug.LogWarning($"[WeaponAttackAdapter] No NpcLoader found");
+                return;
+            }
+
+            var targetNpcContainer = targetNpcLoader.Container;
+            if (targetNpcContainer == null)
+            {
+                Debug.LogWarning($"[WeaponAttackAdapter] No NpcContainer found");
+                return;
+            }
+
+            Debug.Log($"[WeaponAttackAdapter] Target: {targetNpcContainer.Instance.GetName(NpcNameSlot.Slot0)}");
+
+            // Try to fire the hit through VR weapon service if available
+            if (TryFireHitViaVRWeaponService(targetNpcContainer))
+            {
+                Debug.Log($"[WeaponAttackAdapter] *** HIT FIRED (VR)");
                 return;
+            }
 
-            Debug.Log("OnTriggerEnter - VobHitbox");
-            // if (other.gameObject.layer != Constants.VobItemLayer)
-            //     return;
-            //
-            // var vobContainer = other.GetComponentInParent<VobLoader>()?.Container;
-            //
-            // if (!_vrWeaponService.IsWeaponInAttackWindow(vobContainer))
-            //     return;
-            //
-            // var attacker = _vrWeaponService.GetWeaponOwner(vobContainer);
-            // if (attacker == null)
-            //     return;
-            //
-            // var hitPosition = other.ClosestPoint(transform.position);
-            // GlobalEventDispatcher.FightHit.Invoke(attacker, _npcContainer, hitPosition);
+            Debug.LogWarning($"[WeaponAttackAdapter] Failed to fire hit (not in attack window or VR unavailable)");
+            // TODO - Add support for flat-screen weapon hits and NPC-to-NPC hits here
         }
 
         private void OnTriggerExit(Collider other)
         {
             if (other.gameObject.layer != Constants.VobHitbox)
                 return;
+        }
+
+        /// <summary>
+        /// Attempts to validate and fire a hit using VRWeaponService (VR mode only).
+        /// Returns true if the hit was processed, false otherwise.
+        /// </summary>
+        private bool TryFireHitViaVRWeaponService(NpcContainer targetNpcContainer)
+        {
+            try
+            {
+                // Try to dynamically get the VRWeaponService through the Reflex DI container
+                // Using reflection to avoid direct assembly dependency on Gothic.VR
+                var vrWeaponServiceType = Type.GetType("Gothic.VR.Services.VRWeaponService, Gothic.VR");
+                if (vrWeaponServiceType == null)
+                {
+                    Debug.LogWarning($"[WeaponAttackAdapter] VRWeaponService not found (flat-screen mode?)");
+                    return false;
+                }
+
+                var vrWeaponService = ReflexProjectInstaller.DIContainer.Resolve(vrWeaponServiceType);
+                if (vrWeaponService == null)
+                {
+                    Debug.LogWarning($"[WeaponAttackAdapter] VRWeaponService could not be resolved");
+                    return false;
+                }
+
+                // Use reflection to call the methods
+                var isInAttackWindowMethod = vrWeaponServiceType.GetMethod("IsWeaponInAttackWindow");
+                var getWeaponOwnerMethod = vrWeaponServiceType.GetMethod("GetWeaponOwner");
+
+                if (isInAttackWindowMethod == null || getWeaponOwnerMethod == null)
+                {
+                    Debug.LogWarning($"[WeaponAttackAdapter] Required methods not found on VRWeaponService");
+                    return false;
+                }
+
+                // Check if this weapon is currently in an active attack window
+                var isInAttackWindow = (bool)isInAttackWindowMethod.Invoke(vrWeaponService, new object[] { _weaponVobContainer });
+                Debug.Log($"[WeaponAttackAdapter] IsInAttackWindow: {isInAttackWindow}");
+                if (!isInAttackWindow)
+                {
+                    Debug.LogWarning($"[WeaponAttackAdapter] Weapon not in attack window");
+                    return false;
+                }
+
+                // Get who is attacking with this weapon
+                var attacker = (NpcContainer)getWeaponOwnerMethod.Invoke(vrWeaponService, new object[] { _weaponVobContainer });
+                if (attacker == null)
+                {
+                    Debug.LogWarning($"[WeaponAttackAdapter] No attacker found for weapon");
+                    return false;
+                }
+
+                // Get the hit position for effects/knockback later
+                var hitPosition = transform.position;
 
-            Debug.Log("OnTriggerExit - VobHitbox");
+                // Fire the combat event
+                Debug.Log($"[WeaponAttackAdapter] FightHit event: {attacker.Instance.GetName(NpcNameSlot.Slot0)} → {targetNpcContainer.Instance.GetName(NpcNameSlot.Slot0)}");
+                GlobalEventDispatcher.FightHit.Invoke(attacker, targetNpcContainer, hitPosition);
+                return true;
+            }
+            catch (Exception ex)
+            {
+                // VRWeaponService not available or DI resolution failed
+                Debug.LogError($"[WeaponAttackAdapter] Exception in TryFireHitViaVRWeaponService: {ex.Message}");
+                return false;
+            }
         }
     }
 }