/// <summary> /// The camera has been destroyed. /// </summary> private void OnDestroy() { OnAttachCharacter(null); #if THIRD_PERSON_CONTROLLER if (m_ObjectFader != null) { m_ObjectFader.IndependentCharacterFadeCount -= 1; } #endif EventHandler.UnregisterEvent <GameObject>(m_CameraController.gameObject, "OnCameraAttachCharacter", OnAttachCharacter); }
/// <summary> /// Rotates the camera to face the character. /// </summary> /// <param name="horizontalMovement">-1 to 1 value specifying the amount of horizontal movement.</param> /// <param name="verticalMovement">-1 to 1 value specifying the amount of vertical movement.</param> /// <param name="immediateUpdate">Should the camera be updated immediately?</param> /// <returns>The updated rotation.</returns> public override Quaternion Rotate(float horizontalMovement, float verticalMovement, bool immediateUpdate) { #if ULTIMATE_CHARACTER_CONTROLLER_VR if (m_VREnabled && immediateUpdate) { EventHandler.ExecuteEvent("OnTryRecenterTracking"); } #endif var up = m_CharacterLocomotion.AlignToGravity ? m_CharacterLocomotion.Up : m_UpAxis; var rotation = Quaternion.LookRotation(-m_Ray.direction, up); return(immediateUpdate ? rotation : Quaternion.Slerp(m_Transform.rotation, rotation, m_RotationSpeed * m_CharacterLocomotion.TimeScale * Time.timeScale * Time.deltaTime)); }
/// <summary> /// Adds amount to health and then to the shield if there is still an amount remaining. Will not go over the maximum health or shield value. /// </summary> /// <param name="amount">The amount of health or shield to add.</param> /// <returns>True if the object was healed.</returns> public virtual bool Heal(float amount) { #if ULTIMATE_CHARACTER_CONTROLLER_MULTIPLAYER if (m_NetworkInfo != null && m_NetworkInfo.IsLocalPlayer()) { m_NetworkHealthMonitor.Heal(amount); } #endif var healAmount = 0f; // Contribute the amount of the health first. if (m_HealthAttribute != null && m_HealthAttribute.Value < m_HealthAttribute.MaxValue) { var healthAmount = Mathf.Min(amount, m_HealthAttribute.MaxValue - m_HealthAttribute.Value); amount -= healthAmount; m_HealthAttribute.Value += healthAmount; healAmount += healthAmount; } // Add any remaining amount to the shield. if (m_ShieldAttribute != null && amount > 0 && m_ShieldAttribute.Value < m_ShieldAttribute.MaxValue) { var shieldAmount = Mathf.Min(amount, m_ShieldAttribute.MaxValue - m_ShieldAttribute.Value); m_ShieldAttribute.Value += shieldAmount; healAmount += shieldAmount; } // Don't play any effects if the object wasn't healed. if (healAmount == 0) { return(false); } // Play any heal audio. m_HealAudioClipSet.PlayAudioClip(m_GameObject); EventHandler.ExecuteEvent <float>(m_GameObject, "OnHealthHeal", healAmount); if (m_OnHealEvent != null) { m_OnHealEvent.Invoke(healAmount); } if (m_DamagePopupManager != null) { m_DamagePopupManager.OpenHealPopup(m_Transform.position, amount); } return(true); }
/// <summary> /// Rotates the camera to face the character. /// </summary> /// <param name="horizontalMovement">-1 to 1 value specifying the amount of horizontal movement.</param> /// <param name="verticalMovement">-1 to 1 value specifying the amount of vertical movement.</param> /// <param name="immediateUpdate">Should the camera be updated immediately?</param> /// <returns>The updated rotation.</returns> public override Quaternion Rotate(float horizontalMovement, float verticalMovement, bool immediateUpdate) { #if ULTIMATE_CHARACTER_CONTROLLER_VR if (m_VREnabled) { EventHandler.ExecuteEvent("OnTryRecenterTracking"); } #endif Quaternion targetRotation; var activeMovementType = m_CharacterLocomotion.ActiveMovementType as Character.MovementTypes.Pseudo3D; if (activeMovementType != null && activeMovementType.Path != null) { targetRotation = Quaternion.LookRotation(Vector3.Cross(activeMovementType.Path.GetTangent(GetAnchorPosition(), ref m_PathIndex), m_CharacterLocomotion.Up)) * Quaternion.LookRotation(m_ForwardAxis); } else { targetRotation = Quaternion.LookRotation(m_ForwardAxis); } return((immediateUpdate ? targetRotation : Quaternion.Slerp(m_Transform.rotation, targetRotation, m_RotationSmoothing)) * Quaternion.Euler(m_SecondaryRotationSpring.Value)); }
/// <summary> /// Initialize the default values. /// </summary> protected override void Awake() { base.Awake(); m_GameObject = gameObject; m_Transform = transform; m_ForceObject = m_GameObject.GetCachedComponent <IForceObject>(); m_Rigidbody = m_GameObject.GetCachedComponent <Rigidbody>(); m_AttributeManager = GetComponent <AttributeManager>(); if (!string.IsNullOrEmpty(m_HealthAttributeName)) { m_HealthAttribute = m_AttributeManager.GetAttribute(m_HealthAttributeName); } if (!string.IsNullOrEmpty(m_ShieldAttributeName)) { m_ShieldAttribute = m_AttributeManager.GetAttribute(m_ShieldAttributeName); } m_AliveLayer = m_GameObject.layer; #if ULTIMATE_CHARACTER_CONTROLLER_MULTIPLAYER m_NetworkInfo = m_GameObject.GetCachedComponent <INetworkInfo>(); m_NetworkHealthMonitor = m_GameObject.GetCachedComponent <INetworkHealthMonitor>(); if (m_NetworkInfo != null && m_NetworkHealthMonitor == null) { Debug.LogError("Error: The object " + m_GameObject.name + " must have a NetworkHealthMonitor component."); } #endif if (m_Hitboxes != null && m_Hitboxes.Length > 0) { m_ColliderHitboxMap = new Dictionary <Collider, Hitbox>(); for (int i = 0; i < m_Hitboxes.Length; ++i) { m_ColliderHitboxMap.Add(m_Hitboxes[i].Collider, m_Hitboxes[i]); } m_RaycastHits = new RaycastHit[m_MaxHitboxCollisionCount]; m_RaycastHitComparer = new Utility.UnityEngineUtility.RaycastHitComparer(); } EventHandler.RegisterEvent(m_GameObject, "OnRespawn", OnRespawn); }
/// <summary> /// Initializes the default values. /// </summary> private void Awake() { if (m_GameObject != null) { return; } m_GameObject = gameObject; m_CameraController = m_GameObject.GetCachedComponent <CameraController>(); if (m_CameraController == null) { // If the camera controller is null then the component has been added to the first person child camera. m_CameraController = gameObject.GetCachedParentComponent <CameraController>(); m_SwapMask = SwapMask.FirstPerson; } else { var viewTypes = m_CameraController.ViewTypes; // The component exists on the main camera GameObject. If there is no child first person camera then the single component is responsible for // swapping both first and third person renderer materials. for (int i = 0; i < viewTypes.Length; ++i) { if (viewTypes[i] is ViewTypes.FirstPerson) { var firstPersonViewType = viewTypes[i] as ViewTypes.FirstPerson; #if ULTIMATE_CHARACTER_CONTROLLER_UNIVERSALRP || ULTIMATE_CHARACTER_CONTROLLER_HDRP m_SwapMask = firstPersonViewType.OverlayRenderType == ViewTypes.FirstPerson.ObjectOverlayRenderType.SecondCamera ? SwapMask.ThirdPerson : (SwapMask.FirstPerson | SwapMask.ThirdPerson); #else m_SwapMask = firstPersonViewType.UseFirstPersonCamera ? SwapMask.ThirdPerson : (SwapMask.FirstPerson | SwapMask.ThirdPerson); #endif #if UNITY_EDITOR if ((m_SwapMask & SwapMask.ThirdPerson) != 0) { // Ensure the child camera has the Material Swapper component. if (firstPersonViewType.FirstPersonCamera != null) { var firstPersonMaterialSwapper = firstPersonViewType.FirstPersonCamera.GetComponent <MaterialSwapper>(); if (firstPersonMaterialSwapper == null) { Debug.LogWarning("Warning: The First Person Camera should have the Material Swapper component added to the GameObject."); } else { firstPersonMaterialSwapper.Awake(); } } } #endif break; } } #if THIRD_PERSON_CONTROLLER m_ObjectFader = m_CameraController.GetComponent <ThirdPersonController.Camera.ObjectFader>(); if (m_ObjectFader != null) { m_ObjectFader.IndependentCharacterFadeCount += 1; } #endif } m_Camera = m_CameraController.GetComponent <Camera>(); // Instantiate the storage objects based on the swap mode. if ((m_SwapMask & SwapMask.FirstPerson) != 0) { m_AddedFirstPersonRenderers = new HashSet <Renderer>(); m_FirstPersonRenderers = new List <Renderer>(); m_FirstPersonOriginalMaterials = new List <Material[]>(); m_FirstPersonInvisibleMaterials = new List <Material[]>(); m_FirstPersonBaseObjects = new HashSet <GameObject>(); } if ((m_SwapMask & SwapMask.ThirdPerson) != 0) { m_AddedThirdPersonRenderers = new HashSet <Renderer>(); m_ThirdPersonRenderers = new List <Renderer>(); m_ThirdPersonOriginalMaterials = new List <Material[]>(); m_ThirdPersonInvisibleMaterials = new List <Material[]>(); } enabled = false; EventHandler.RegisterEvent <GameObject>(m_CameraController.gameObject, "OnCameraAttachCharacter", OnAttachCharacter); }
/// <summary> /// Attaches the component to the specified character. /// </summary> /// <param name="character">The handler to attach the camera to.</param> protected virtual void OnAttachCharacter(GameObject character) { // Don't do anything if the character is the same. if (m_Character != null && character == m_Character) { return; } if (m_Character != null) { // The character is being changed. if (m_FirstPersonRenderers != null) { m_AddedFirstPersonRenderers.Clear(); m_FirstPersonRenderers.Clear(); m_FirstPersonOriginalMaterials.Clear(); m_FirstPersonInvisibleMaterials.Clear(); m_FirstPersonBaseObjects.Clear(); } if (m_ThirdPersonRenderers != null) { m_AddedThirdPersonRenderers.Clear(); m_ThirdPersonRenderers.Clear(); m_ThirdPersonOriginalMaterials.Clear(); m_ThirdPersonInvisibleMaterials.Clear(); } EventHandler.UnregisterEvent <bool>(m_Character, "OnCameraChangePerspectives", OnChangePerspectives); EventHandler.UnregisterEvent <Item>(m_Character, "OnInventoryAddItem", OnAddItem); EventHandler.UnregisterEvent(m_Character, "OnRespawn", OnRespawn); m_Character = null; } enabled = !m_ManualSwap && character != null; if (character == null) { return; } var characterLocomotion = character.GetCachedComponent <UltimateCharacterLocomotion>(); m_Character = characterLocomotion.gameObject; m_FirstPersonPerspective = characterLocomotion.FirstPersonPerspective; #if THIRD_PERSON_CONTROLLER // Force the character into using third person materials so the correct materials can be cached. var perspectiveMonitor = character.GetCachedComponent <ThirdPersonController.Character.PerspectiveMonitor>(); if (perspectiveMonitor != null) { perspectiveMonitor.UpdateThirdPersonMaterials(true); } #endif if ((m_SwapMask & SwapMask.FirstPerson) != 0) { var firstPersonBaseObjects = character.GetComponentsInChildren <FirstPersonBaseObject>(true); for (int i = 0; i < firstPersonBaseObjects.Length; ++i) { CacheFirstPersonRenderers(firstPersonBaseObjects[i].gameObject); // Remember the base objects so they are not added again if a runtime item is picked up. m_FirstPersonBaseObjects.Add(firstPersonBaseObjects[i].gameObject); } } if ((m_SwapMask & SwapMask.ThirdPerson) != 0) { var thirdPersonObjects = character.GetComponentsInChildren <ThirdPersonObject>(true); for (int i = 0; i < thirdPersonObjects.Length; ++i) { CacheThirdPersonRenderers(thirdPersonObjects[i].gameObject); } } #if THIRD_PERSON_CONTROLLER if (perspectiveMonitor != null) { perspectiveMonitor.UpdateThirdPersonMaterials(false); } #endif EventHandler.RegisterEvent <bool>(m_Character, "OnCameraChangePerspectives", OnChangePerspectives); EventHandler.RegisterEvent <Item>(m_Character, "OnInventoryAddItem", OnAddItem); EventHandler.RegisterEvent(m_Character, "OnRespawn", OnRespawn); // Assume the first person objects are not rendering. EnableThirdPersonMaterials(); }
/// <summary> /// Do the explosion. /// </summary> /// <param name="damageAmount">The amount of damage to apply to the hit objects.</param> /// <param name="impactForce">The amount of force to apply to the hit object.</param> /// <param name="impactForceFrames">The number of frames to add the force to.</param> /// <param name="originator">The originator of the object.</param> public void Explode(float damageAmount, float impactForce, int impactForceFrames, GameObject originator) { Health health = null; Rigidbody colliderRigidbody = null; IForceObject forceObject = null; var hitCount = Physics.OverlapSphereNonAlloc(m_Transform.position, m_Radius, m_CollidersHit, m_ImpactLayers, QueryTriggerInteraction.Ignore); #if UNITY_EDITOR if (hitCount == m_MaxCollisionCount) { Debug.LogWarning("Warning: The maximum number of colliders have been hit by " + m_GameObject.name + ". Consider increasing the Max Collision Count value."); } #endif for (int i = 0; i < hitCount; ++i) { // A GameObject can contain multiple colliders. Prevent the explosion from occurring on the same GameObject multiple times. if (m_ObjectExplosions.Contains(m_CollidersHit[i].gameObject)) { continue; } m_ObjectExplosions.Add(m_CollidersHit[i].gameObject); // The base character GameObject should only be checked once. if ((forceObject = m_CollidersHit[i].gameObject.GetCachedParentComponent <IForceObject>()) != null) { if (m_ObjectExplosions.Contains(forceObject)) { continue; } m_ObjectExplosions.Add(forceObject); } // OverlapSphere can return objects that are in a different room. Perform a cast to ensure the object is within the explosion range. if (m_LineOfSight) { // Add a slight vertical offset to prevent a floor collider from getting in the way of the cast. var position = m_Transform.TransformPoint(0, 0.1f, 0); var direction = m_CollidersHit[i].transform.position - position; if (Physics.Raycast(position - direction.normalized * 0.1f, direction, out m_RaycastHit, direction.magnitude, m_ImpactLayers, QueryTriggerInteraction.Ignore) && !(m_RaycastHit.transform.IsChildOf(m_CollidersHit[i].transform) #if FIRST_PERSON_CONTROLLER // The cast should not hit any colliders who are a child of the camera. || m_RaycastHit.transform.gameObject.GetCachedParentComponent <FirstPersonController.Character.FirstPersonObjects>() != null #endif )) { // If the collider is part of a character then ensure the head can't be hit. var parentAnimator = m_CollidersHit[i].transform.gameObject.GetCachedParentComponent <Animator>(); if (parentAnimator != null && parentAnimator.isHuman) { var head = parentAnimator.GetBoneTransform(HumanBodyBones.Head); direction = head.position - position; if (Physics.Raycast(position, direction, out m_RaycastHit, direction.magnitude, m_ImpactLayers, QueryTriggerInteraction.Ignore) && !m_RaycastHit.transform.IsChildOf(m_CollidersHit[i].transform) && !m_CollidersHit[i].transform.IsChildOf(m_RaycastHit.transform) && m_RaycastHit.transform.IsChildOf(m_Transform) #if FIRST_PERSON_CONTROLLER // The cast should not hit any colliders who are a child of the camera. && m_RaycastHit.transform.gameObject.GetCachedParentComponent <FirstPersonController.Character.FirstPersonObjects>() == null #endif ) { continue; } } else { continue; } } } // The shield can absorb some (or none) of the damage from the explosion. var hitDamageAmount = damageAmount; #if ULTIMATE_CHARACTER_CONTROLLER_MELEE ShieldCollider shieldCollider; if ((shieldCollider = m_CollidersHit[i].transform.gameObject.GetCachedComponent <ShieldCollider>()) != null) { hitDamageAmount = shieldCollider.Shield.Damage(this, hitDamageAmount); } #endif // ClosestPoint only works with a subset of collider types. Vector3 closestPoint; if (m_CollidersHit[i] is BoxCollider || m_CollidersHit[i] is SphereCollider || m_CollidersHit[i] is CapsuleCollider || (m_CollidersHit[i] is MeshCollider && (m_CollidersHit[i] as MeshCollider).convex)) { closestPoint = m_CollidersHit[i].ClosestPoint(m_Transform.position); } else { closestPoint = m_CollidersHit[i].ClosestPointOnBounds(m_Transform.position); } var hitDirection = closestPoint - m_Transform.position; // Allow a custom event to be received. EventHandler.ExecuteEvent <float, Vector3, Vector3, GameObject, object, Collider>(m_CollidersHit[i].transform.gameObject, "OnObjectImpact", hitDamageAmount, closestPoint, hitDirection * m_ImpactForce, originator, this, m_CollidersHit[i]); if (m_OnImpactEvent != null) { m_OnImpactEvent.Invoke(hitDamageAmount, closestPoint, hitDirection * m_ImpactForce, originator); } // If the shield didn't absorb all of the damage then it should be applied to the character. if (hitDamageAmount > 0) { // If the Health component exists it will apply an explosive force to the character/character in addition to deducting the health. // Otherwise just apply the force to the character/rigidbody. if ((health = m_CollidersHit[i].gameObject.GetCachedParentComponent <Health>()) != null) { // The further out the collider is, the less it is damaged. var damageModifier = Mathf.Max(1 - (hitDirection.magnitude / m_Radius), 0.01f); health.Damage(hitDamageAmount * damageModifier, m_Transform.position, hitDirection.normalized, impactForce * damageModifier, impactForceFrames, m_Radius, originator, this, null); } else if (forceObject != null) { var damageModifier = Mathf.Max(1 - (hitDirection.magnitude / m_Radius), 0.01f); forceObject.AddForce(hitDirection.normalized * impactForce * damageModifier); } else if ((colliderRigidbody = m_CollidersHit[i].gameObject.GetCachedComponent <Rigidbody>()) != null) { colliderRigidbody.AddExplosionForce(impactForce * MathUtility.RigidbodyForceMultiplier, m_Transform.position, m_Radius); } } } m_ObjectExplosions.Clear(); // An audio clip can play when the object explodes. m_ExplosionAudioClipSet.PlayAudioClip(m_GameObject); Scheduler.Schedule(m_Lifespan, Destroy); }
/// <summary> /// The GameObject has been destroyed. /// </summary> private void OnDestroy() { EventHandler.UnregisterEvent(m_GameObject, "OnRespawn", OnRespawn); }
/// <summary> /// The object is no longer alive. /// </summary> /// <param name="position">The position of the damage.</param> /// <param name="force">The amount of force applied to the object while taking the damage.</param> /// <param name="attacker">The GameObject that killed the character.</param> public virtual void Die(Vector3 position, Vector3 force, GameObject attacker) { #if ULTIMATE_CHARACTER_CONTROLLER_MULTIPLAYER if (m_NetworkInfo != null && m_NetworkInfo.IsLocalPlayer()) { m_NetworkHealthMonitor.Die(position, force, attacker); } #endif // Spawn any objects on death, such as an explosion if the object is an explosive barrel. if (m_SpawnedObjectsOnDeath != null) { for (int i = 0; i < m_SpawnedObjectsOnDeath.Length; ++i) { var spawnedObject = ObjectPoolBase.Instantiate(m_SpawnedObjectsOnDeath[i], m_Transform.position, m_Transform.rotation); Explosion explosion; if ((explosion = spawnedObject.GetCachedComponent <Explosion>()) != null) { explosion.Explode(gameObject); } var rigidbodies = spawnedObject.GetComponentsInChildren <Rigidbody>(); for (int j = 0; j < rigidbodies.Length; ++j) { rigidbodies[j].AddForceAtPosition(force, position); } } } // Destroy any objects on death. The objects will be placed back in the object pool if they were created within it otherwise the object will be destroyed. if (m_DestroyedObjectsOnDeath != null) { for (int i = 0; i < m_DestroyedObjectsOnDeath.Length; ++i) { if (ObjectPoolBase.InstantiatedWithPool(m_DestroyedObjectsOnDeath[i])) { ObjectPoolBase.Destroy(m_DestroyedObjectsOnDeath[i]); } else { Object.Destroy(m_DestroyedObjectsOnDeath[i]); } } } // Change the layer to a death layer. if (m_DeathLayer.value != 0) { m_AliveLayer = m_GameObject.layer; m_GameObject.layer = m_DeathLayer; } // Play any take death audio. Use PlayAtPosition because the audio won't play if the GameObject is inactive. m_DeathAudioClipSet.PlayAtPosition(m_Transform.position); // Deactivate the object if requested. if (m_DeactivateOnDeath) { SchedulerBase.Schedule(m_DeactivateOnDeathDelay, Deactivate); } // The attributes shouldn't regenerate. if (m_ShieldAttribute != null) { m_ShieldAttribute.CancelAutoUpdate(); } if (m_HealthAttribute != null) { m_HealthAttribute.CancelAutoUpdate(); } // Notify those interested. EventHandler.ExecuteEvent <Vector3, Vector3, GameObject>(m_GameObject, "OnDeath", position, force, attacker); if (m_OnDeathEvent != null) { m_OnDeathEvent.Invoke(position, force, attacker); } }
/// <summary> /// The object has taken been damaged. /// </summary> /// <param name="damageData">The data associated with the damage.</param> public virtual void OnDamage(DamageData damageData) { if (damageData == null) { return; } // Add a multiplier if a particular collider was hit. Do not apply a multiplier if the damage is applied through a radius because multiple // collider are hit. if (damageData.Radius == 0 && damageData.Direction != Vector3.zero && damageData.HitCollider != null) { if (m_ColliderHitboxMap != null && m_ColliderHitboxMap.Count > 0) { Hitbox hitbox; if (m_ColliderHitboxMap.TryGetValue(damageData.HitCollider, out hitbox)) { damageData.Amount *= hitbox.DamageMultiplier; } else { // The main collider may be overlapping child hitbox colliders. Perform one more raycast to ensure a hitbox collider shouldn't be hit. float distance = 0.2f; if (damageData.HitCollider is CapsuleCollider capsuleCollider) { distance = capsuleCollider.radius; } else if (damageData.HitCollider is SphereCollider sphereCollider) { distance = sphereCollider.radius; } // The hitbox collider may be underneath the base collider. Fire a raycast to detemine if there are any colliders underneath the hit collider // that should apply a multiplier. var hitCount = Physics.RaycastNonAlloc(damageData.Position, damageData.Direction, m_RaycastHits, distance, ~(1 << LayerManager.IgnoreRaycast | 1 << LayerManager.Overlay | 1 << LayerManager.VisualEffect), QueryTriggerInteraction.Ignore); for (int i = 0; i < hitCount; ++i) { var closestRaycastHit = QuickSelect.SmallestK(m_RaycastHits, hitCount, i, m_RaycastHitComparer); if (closestRaycastHit.collider == damageData.HitCollider) { continue; } // A new collider has been found - stop iterating if the hitbox map exists and use the hitbox multiplier. if (m_ColliderHitboxMap.TryGetValue(closestRaycastHit.collider, out hitbox)) { damageData.Amount *= hitbox.DamageMultiplier; damageData.HitCollider = hitbox.Collider; break; } } } } } // Apply the damage to the shield first because the shield can regenrate. if (m_ShieldAttribute != null && m_ShieldAttribute.Value > m_ShieldAttribute.MinValue) { var shieldAmount = Mathf.Min(damageData.Amount, m_ShieldAttribute.Value - m_ShieldAttribute.MinValue); damageData.Amount -= shieldAmount; m_ShieldAttribute.Value -= shieldAmount; } // Decrement the health by remaining amount after the shield has taken damage. if (m_HealthAttribute != null && m_HealthAttribute.Value > m_HealthAttribute.MinValue) { m_HealthAttribute.Value -= Mathf.Min(damageData.Amount, m_HealthAttribute.Value - m_HealthAttribute.MinValue); } var force = damageData.Direction * damageData.ForceMagnitude; if (damageData.ForceMagnitude > 0) { // Apply a force to the object. if (m_ForceObject != null) { m_ForceObject.AddForce(force, damageData.Frames); } else { // Apply a force to the rigidbody if the object isn't a character. if (m_Rigidbody != null && !m_Rigidbody.isKinematic) { if (damageData.Radius == 0) { m_Rigidbody.AddForceAtPosition(force * MathUtility.RigidbodyForceMultiplier, damageData.Position); } else { m_Rigidbody.AddExplosionForce(force.magnitude * MathUtility.RigidbodyForceMultiplier, damageData.Position, damageData.Radius); } } } } var attacker = damageData.DamageOriginator?.Owner; // Let other interested objects know that the object took damage. EventHandler.ExecuteEvent <float, Vector3, Vector3, GameObject, Collider>(m_GameObject, "OnHealthDamage", damageData.Amount, damageData.Position, force, attacker, damageData.HitCollider); EventHandler.ExecuteEvent <DamageData>(m_GameObject, "OnHealthDamageWithData", damageData); if (m_OnDamageEvent != null) { m_OnDamageEvent.Invoke(damageData.Amount, damageData.Position, force, attacker); } if (m_DamagePopupManager != null) { m_DamagePopupManager.OpenDamagePopup(damageData); } // The object is dead when there is no more health or shield. if (!IsAlive()) { #if ULTIMATE_CHARACTER_CONTROLLER_MULTIPLAYER if (m_NetworkInfo == null || m_NetworkInfo.IsLocalPlayer()) { #endif Die(damageData.Position, force, attacker); #if ULTIMATE_CHARACTER_CONTROLLER_MULTIPLAYER } #endif } else { // Play any take damage audio if the object did not die. If the object died then the death audio will play. m_TakeDamageAudioClipSet.PlayAudioClip(m_GameObject); } }