protected RuntimeWaypoint FindNearestReachableWaypoint(Vector3 position) { var orderedWaypoints = waypoints.GetWaypointsOrderedByProximity(position); for (var i = 0; i < orderedWaypoints.Length; i++) { var wp = orderedWaypoints[i]; if (PhysicsExtensions.CheckSightBetweenTwoPositions(position, wp.position, ~layersToIgnoreInSightTest)) { if (debugReachabilityTest) { Debug.DrawLine(position, wp.position, Color.green); } return(wp); } else if (debugReachabilityTest) { Debug.DrawLine(position, wp.position, Color.red); } } return(null); }
public static bool isObjectColliding( GameObject go, List <GameObject> ignoreGameObjects = null, float expandBy = 0.0f, bool useBoundingBoxInChecks = false ) { if (ignoreGameObjects == null) { ignoreGameObjects = new List <GameObject>(); } ignoreGameObjects.Add(go); HashSet <Collider> ignoreColliders = new HashSet <Collider>(); foreach (GameObject toIgnoreGo in ignoreGameObjects) { foreach (Collider c in toIgnoreGo.GetComponentsInChildren <Collider>()) { ignoreColliders.Add(c); } } int layerMask = 1 << 8 | 1 << 10; foreach (CapsuleCollider cc in go.GetComponentsInChildren <CapsuleCollider>()) { foreach (Collider c in PhysicsExtensions.OverlapCapsule(cc, layerMask, QueryTriggerInteraction.Ignore, expandBy)) { if (!ignoreColliders.Contains(c)) { return(true); } } } foreach (BoxCollider bc in go.GetComponentsInChildren <BoxCollider>()) { if ("BoundingBox" == bc.gameObject.name && (!useBoundingBoxInChecks)) { continue; } foreach (Collider c in PhysicsExtensions.OverlapBox(bc, layerMask, QueryTriggerInteraction.Ignore, expandBy)) { if (!ignoreColliders.Contains(c)) { return(true); } } } foreach (SphereCollider sc in go.GetComponentsInChildren <SphereCollider>()) { foreach (Collider c in PhysicsExtensions.OverlapSphere(sc, layerMask, QueryTriggerInteraction.Ignore, expandBy)) { if (!ignoreColliders.Contains(c)) { return(true); } } } return(false); }
public bool OverlapsWithTags(string[] tagsToCheck) { return(PhysicsExtensions.OverlapCapsule(Capsule) .Where(x => x != currentCollider && x != rootCollider) .ToList() .Any(collider => tagsToCheck.Any(tag => tag == collider.tag))); }
public List <GameObject> GetCurrentOverlapping() { return(PhysicsExtensions.OverlapCapsule(Capsule) .Select(x => x.gameObject) .Where(x => x != currentCollider && x != rootCollider) .ToList()); }
private void DetectAndShowItems() { var colliders = Physics.OverlapSphere(transform.position, radius, itemsLayerMask); for (var i = 0; i < colliders.Length; i++) { var collider = colliders[i]; if (!PhysicsExtensions.IsColliderInSight(transform.position, collider, ~ignoreOnSightTest)) { continue; } var diffVector = collider.transform.position - transform.position; var itemPosition = transform.position + (diffVector * scale); var itemComponent = (Item)collider.GetComponent <Item>(); if (itemComponent == null) { throw new Exception("Item component not found on object."); } var item = PoolManager.instance.Spawn <RadarItemRepresentation>(transform, itemPosition, collider.transform.rotation); item.SetColor(itemComponent.colorOnRadar); Items.Add(item); } }
private void DetectCollisions() { var colliders = PhysicsExtensions.OverlapCapsule(this.Collider, this.CollisionLayerMask, QueryTriggerInteraction.Ignore); if (colliders.Length > 0) { var velMag = mCurrentVelocity.sqrMagnitude * this.Mass * this.CollisionAppliedMassRatio; for (var i = 0; i < colliders.Length; ++i) { var c = colliders[i]; if (this.Collider != c) { HandleCollision(c, velMag); } } this.IsFalling = !this.Sensors.GroundSensors.HasCollidedWithGround(); if (!this.IsFalling) { mCurrentVelocity.y = 0f; } } else { this.IsFalling = true; } }
void Update() { Ray floorRay = new Ray(transform.position, Vector3.down); RaycastHit hit; if (PhysicsExtensions.CapsuleCast(ownCollider, -transform.up, out hit, Mathf.Infinity, 11)) { transform.rotation = Quaternion.LookRotation(transform.forward, hit.normal); } }
private void AddEntity(float x, float y) { _entityService.AddEntity(new Entity() { X = x, Y = y, Mass = PhysicsExtensions.GenerateMass(), Color = ColorExtensions.GenerateColor() }); }
public static Collider[] collidersObjectCollidingWith(GameObject go, List <GameObject> ignoreGameObjects = null, float expandBy = 0.0f) { if (ignoreGameObjects == null) { ignoreGameObjects = new List <GameObject>(); } ignoreGameObjects.Add(go); HashSet <Collider> ignoreColliders = new HashSet <Collider>(); foreach (GameObject toIgnoreGo in ignoreGameObjects) { foreach (Collider c in toIgnoreGo.GetComponentsInChildren <Collider>()) { ignoreColliders.Add(c); } } HashSet <Collider> collidersSet = new HashSet <Collider>(); int layerMask = 1 << 8 | 1 << 10; foreach (CapsuleCollider cc in go.GetComponentsInChildren <CapsuleCollider>()) { foreach (Collider c in PhysicsExtensions.OverlapCapsule(cc, layerMask, QueryTriggerInteraction.Ignore, expandBy)) { if (!ignoreColliders.Contains(c)) { collidersSet.Add(c); } } } foreach (BoxCollider bc in go.GetComponentsInChildren <BoxCollider>()) { foreach (Collider c in PhysicsExtensions.OverlapBox(bc, layerMask, QueryTriggerInteraction.Ignore, expandBy)) { if (!ignoreColliders.Contains(c)) { collidersSet.Add(c); } } } foreach (SphereCollider sc in go.GetComponentsInChildren <SphereCollider>()) { foreach (Collider c in PhysicsExtensions.OverlapSphere(sc, layerMask, QueryTriggerInteraction.Ignore, expandBy)) { if (!ignoreColliders.Contains(c)) { collidersSet.Add(c); } } } return(collidersSet.ToArray()); }
private bool CheckCollisionAtPosition(Collider collider) { if (collider is SphereCollider) { return(PhysicsExtensions.CheckSphere(collider as SphereCollider, layerMask, QueryTriggerInteraction.Ignore)); } if (collider is BoxCollider) { return(PhysicsExtensions.CheckBox(collider as BoxCollider, layerMask, QueryTriggerInteraction.Ignore)); } if (collider is CapsuleCollider) { return(PhysicsExtensions.CheckCapsule(collider as CapsuleCollider, layerMask, QueryTriggerInteraction.Ignore)); } return(false); }
public static RaycastHit[] CastAllPrimitiveColliders(GameObject go, Vector3 direction, float maxDistance = Mathf.Infinity, int layerMask = Physics.DefaultRaycastLayers, QueryTriggerInteraction queryTriggerInteraction = QueryTriggerInteraction.UseGlobal) { HashSet <Transform> transformsToIgnore = new HashSet <Transform>(); foreach (Transform t in go.GetComponentsInChildren <Transform>()) { transformsToIgnore.Add(t); } List <RaycastHit> hits = new List <RaycastHit>(); foreach (CapsuleCollider cc in go.GetComponentsInChildren <CapsuleCollider>()) { foreach (RaycastHit h in PhysicsExtensions.CapsuleCastAll(cc, direction, maxDistance, layerMask, queryTriggerInteraction)) { if (!transformsToIgnore.Contains(h.transform)) { hits.Add(h); } } } foreach (BoxCollider bc in go.GetComponentsInChildren <BoxCollider>()) { foreach (RaycastHit h in PhysicsExtensions.BoxCastAll(bc, direction, maxDistance, layerMask, queryTriggerInteraction)) { if (!transformsToIgnore.Contains(h.transform)) { hits.Add(h); } } } foreach (SphereCollider sc in go.GetComponentsInChildren <SphereCollider>()) { foreach (RaycastHit h in PhysicsExtensions.SphereCastAll(sc, direction, maxDistance, layerMask, queryTriggerInteraction)) { if (!transformsToIgnore.Contains(h.transform)) { hits.Add(h); } } } return(hits.ToArray()); }
public override void NetShoot(IAmmoEffect effect, float timeDelay, Vector3 startPosition, Vector3 rayDirection) { // THIS IS A MODDED SHOOT COMMAND TO SUPPORT NETWORKTIME ROLLBACK // Just return if there is no effect if (effect == null) { return; } // Get root game object to prevent impacts with body Transform ignoreRoot = GetRootTransform(); // could possibly lag comp the gun pos as well, but for not take the location of player shot. base.StartRayRollback(timeDelay); // Check for raycast hit Ray ray = new Ray(startPosition, rayDirection); Vector3 hitPoint; bool didHit = PhysicsExtensions.RaycastNonAllocSingle(ray, out m_Hit, m_MaxDistance, m_Layers, ignoreRoot, QueryTriggerInteraction.Ignore); if (didHit) { hitPoint = m_Hit.point; } else { hitPoint = startPosition + (rayDirection * m_MaxDistance); } if (didHit) { effect.Hit(m_Hit, ray.direction, m_Hit.distance, float.PositiveInfinity, firearm as IDamageSource); } base.StopRayRollback(timeDelay); // Draw the tracer line out to max distance if (m_TracerPrototype != null) { StartCoroutine(ShowTracer(hitPoint)); } base.NetShoot(effect, timeDelay, startPosition, rayDirection); }
private void DetectAndShowEnemies() { var colliders = Physics.OverlapSphere(transform.position, radius, enemyLayerMask); for (var i = 0; i < colliders.Length; i++) { var collider = colliders[i]; if (!PhysicsExtensions.IsColliderInSight(transform.position, collider, ~ignoreOnSightTest)) { continue; } var diffVector = collider.transform.position - transform.position; var enemyPosition = transform.position + (diffVector * scale); var enemy = PoolManager.instance.Spawn <RadarEnemyShipRepresentation>(transform, enemyPosition, collider.transform.rotation); Enemies.Add(enemy); } }
public void TestGravitationalForceCalculation() { var xEntity = new Entity() { X = 800, Y = 800, Color = ColorExtensions.GenerateColor(), Mass = 1f }; var yEntity = new Entity() { X = 0, Y = 0, Color = ColorExtensions.GenerateColor(), Mass = 1f }; TestContext.WriteLine(PhysicsExtensions.CalculateGravitationalForce(xEntity, yEntity)); Assert.Greater(PhysicsExtensions.CalculateGravitationalForce(xEntity, yEntity), 0); }
public override void Shoot(float accuracy, IAmmoEffect effect) { if (m_ProjectilePrefab != null) { IProjectile projectile = PoolManager.GetPooledObject <IProjectile>(m_ProjectilePrefab, false); InitialiseProjectile(projectile); Transform ignoreRoot = GetRootTransform(); //if (firearm.wielder != null) // ignoreRoot = firearm.wielder.gameObject.transform; // Get the forward vector Vector3 muzzlePosition = m_MuzzleTip.position; Vector3 startPosition = muzzlePosition; Vector3 forwardVector = m_MuzzleTip.forward; bool useCamera = false; if (firearm.wielder != null) { switch (m_UseCameraAim) { case UseCameraAim.HipAndAimDownSights: useCamera = true; break; case UseCameraAim.AimDownSightsOnly: if (firearm.aimer != null) { useCamera = firearm.aimer.isAiming; } break; case UseCameraAim.HipFireOnly: if (firearm.aimer != null) { useCamera = !firearm.aimer.isAiming; } else { useCamera = true; } break; } } if (useCamera) { Transform aimTransform = firearm.wielder.fpCamera.aimTransform; startPosition = aimTransform.position; forwardVector = aimTransform.forward; } // Get the direction (with accuracy offset) Vector3 rayDirection = forwardVector; float spread = Mathf.Lerp(m_MinimumSpread, m_MaximumSpread, 1f - accuracy); if (spread > Mathf.Epsilon) { Quaternion randomRot = UnityEngine.Random.rotationUniform; rayDirection = Quaternion.Slerp(Quaternion.identity, randomRot, spread / 360f) * forwardVector; } Ray ray = new Ray(startPosition, rayDirection); Vector3 hitPoint; if (PhysicsExtensions.RaycastNonAllocSingle(ray, out m_Hit, k_MaxDistance, m_Layers, ignoreRoot, QueryTriggerInteraction.Ignore)) { hitPoint = m_Hit.point; } else { hitPoint = startPosition + (rayDirection * k_MaxDistance); } if (useCamera) { Vector3 newDirection = hitPoint - muzzlePosition; newDirection.Normalize(); projectile.Fire(muzzlePosition, newDirection * m_MuzzleSpeed, m_Gravity, effect, firearm.wielder.gameObject.transform, m_Layers, firearm as IDamageSource); SendNetShootEvent(muzzlePosition, newDirection); projectile.gameObject.SetActive(true); } else { projectile.Fire(startPosition, rayDirection * m_MuzzleSpeed, m_Gravity, effect, ignoreRoot, m_Layers, firearm as IDamageSource); SendNetShootEvent(startPosition, rayDirection); projectile.gameObject.SetActive(true); } } base.Shoot(accuracy, effect); }
private void UpdateLockingSystem() { if (lockingSystemOn) { var screenCenter = ((RectTransform)lockCrosshair.canvas.transform).sizeDelta / 2f; var LockAreaLimitHelperPos = RectTransformUtility.WorldToScreenPoint(lockingSystemCamera, ((RectTransform)LockAreaLimitHelper.transform).position); var lockAreaRadius = Vector2.Distance(screenCenter, LockAreaLimitHelperPos); if (targetBeingLocked != null) { if (Vector2.Distance(RectTransformUtility.WorldToScreenPoint(lockingSystemCamera, targetBeingLocked.transform.position), screenCenter) > lockAreaRadius) { targetBeingLocked = null; leftGuidedMissileCannon.target = null; rightGuidedMissileCannon.target = null; lockCrosshair.enabled = false; } else if (Time.time - targetBeingLockedStartTime > timeToLockTarget) { lockCrosshair.color = lockCrosshairLockedColor; leftGuidedMissileCannon.target = targetBeingLocked.transform; rightGuidedMissileCannon.target = targetBeingLocked.transform; } } if (targetBeingLocked == null) { var allEnemies = GameObject.FindObjectsOfType <EnemyShipControllerV2>(); float selectedEnemySqrMagnitude = float.MaxValue; foreach (var enemy in allEnemies) { var collider = enemy.GetComponent <Collider>(); if (collider == null) { continue; } if (PhysicsExtensions.IsColliderInSight(targetDetectorOrigin.position, collider, ~targetDetectionLayersToIgnore)) { var enemyScreenPoint = RectTransformUtility.WorldToScreenPoint(lockingSystemCamera, enemy.transform.position); if (Vector2.Distance(enemyScreenPoint, screenCenter) > lockAreaRadius) { continue; } var currSqrMagnitude = (targetDetectorOrigin.position - collider.transform.position).sqrMagnitude; if (currSqrMagnitude < selectedEnemySqrMagnitude) { selectedEnemySqrMagnitude = currSqrMagnitude; targetBeingLocked = enemy; targetBeingLockedStartTime = Time.time; lockCrosshair.enabled = true; lockCrosshair.color = lockCrosshairUnlockedColor; ((RectTransform)lockCrosshair.transform).localScale = new Vector3(.15f, .15f, .15f); ((RectTransform)lockCrosshair.transform).DOScale(new Vector3(.04f, .04f, .04f), timeToLockTarget); lockCrosshair.color = lockCrosshairUnlockedColor.Copy(0); lockCrosshair.DOFade(1f, timeToLockTarget); } } } } if (targetBeingLocked != null) { Vector2 screenPoint = RectTransformUtility.WorldToScreenPoint(lockingSystemCamera, targetBeingLocked.transform.position); ((RectTransform)lockCrosshair.transform).anchoredPosition = screenPoint - ((RectTransform)lockCrosshair.canvas.transform).sizeDelta / 2f; } else { lockCrosshair.enabled = false; } } }
protected virtual int GetHitResults(Vector3 start, Vector3 end) { return(PhysicsExtensions.LinecastAllNonAlloc(start, end, _hitResults, _layerMask, _triggerInteraction)); }
public override void Shoot(float accuracy, IAmmoEffect effect) { // Just return if there is no effect if (effect == null) { return; } // Get root game object to prevent impacts with body Transform ignoreRoot = GetRootTransform(); //if (firearm.wielder != null) // ignoreRoot = firearm.wielder.gameObject.transform; // Get the forward vector Vector3 muzzlePosition = m_MuzzleTip.position; Vector3 startPosition = muzzlePosition; Vector3 forwardVector = m_MuzzleTip.forward; bool useCamera = false; if (firearm.wielder != null) { switch (m_UseCameraAim) { case UseCameraAim.HipAndAimDownSights: useCamera = true; break; case UseCameraAim.AimDownSightsOnly: if (firearm.aimer != null) { useCamera = firearm.aimer.isAiming; } break; case UseCameraAim.HipFireOnly: if (firearm.aimer != null) { useCamera = !firearm.aimer.isAiming; } else { useCamera = true; } break; } } if (useCamera) { Transform aimTransform = firearm.wielder.fpCamera.aimTransform; startPosition = aimTransform.position; forwardVector = aimTransform.forward; } // Get the direction (with accuracy offset) Vector3 rayDirection = forwardVector; float spread = Mathf.Lerp(m_MinimumSpread, m_MaximumSpread, 1f - accuracy); if (spread > Mathf.Epsilon) { Quaternion randomRot = UnityEngine.Random.rotationUniform; rayDirection = Quaternion.Slerp(Quaternion.identity, randomRot, spread / 360f) * forwardVector; } // Check for raycast hit Ray ray = new Ray(startPosition, rayDirection); Vector3 hitPoint; bool didHit = PhysicsExtensions.RaycastNonAllocSingle(ray, out m_Hit, m_MaxDistance, m_Layers, ignoreRoot, QueryTriggerInteraction.Ignore); if (didHit) { hitPoint = m_Hit.point; } else { hitPoint = startPosition + (rayDirection * m_MaxDistance); } // Double check hit from gun muzzle to prevent near scenery weirdness if (useCamera) { Vector3 newRayDirection = hitPoint - muzzlePosition; newRayDirection.Normalize(); ray = new Ray(muzzlePosition, newRayDirection); if (PhysicsExtensions.RaycastNonAllocSingle(ray, out m_Hit, m_MaxDistance, m_Layers, ignoreRoot, QueryTriggerInteraction.Ignore)) { hitPoint = m_Hit.point; effect.Hit(m_Hit, newRayDirection, m_Hit.distance, float.PositiveInfinity, firearm as IDamageSource); } } else { if (didHit) { effect.Hit(m_Hit, ray.direction, m_Hit.distance, float.PositiveInfinity, firearm as IDamageSource); } } // Draw the tracer line out to max distance if (m_TracerPrototype != null) { StartCoroutine(ShowTracer(hitPoint)); } SendNetShootEvent(startPosition, rayDirection); base.Shoot(accuracy, effect); }
void FixedUpdate() { if (m_Release) { if (m_RecycleDelay <= 0f) { ReleaseProjectile(); } else { if (m_MeshRenderer != null && m_MeshRenderer.enabled) { m_MeshRenderer.enabled = false; } m_Timeout -= Time.deltaTime; if (m_Timeout < 0f) { ReleaseProjectile(); } } } else { float time = Time.deltaTime; // Set position to target localTransform.position = m_LerpToPosition; // Reset interpolation for Update() frames before next fixed m_LerpTime = Time.fixedTime; m_LerpFromPosition = m_LerpToPosition; Vector3 moveVelocity = (m_Velocity * time); Vector3 catchupValue = Vector3.zero; if (m_CatchupDistance.magnitude > 0f) { Vector3 steps = (m_CatchupDistance * time); m_CatchupDistance -= steps; if (m_CatchupDistance.magnitude < (m_Velocity * 0.1f).magnitude) { catchupValue += m_CatchupDistance; m_CatchupDistance = Vector3.zero; } } Vector3 desiredPosition = m_LerpFromPosition + (moveVelocity + catchupValue); float distance = Vector3.Distance(m_LerpFromPosition, desiredPosition); localTransform.LookAt(desiredPosition); // Enable renderer if travelled far enough (check based on from position due to lerp) if (!m_PassedMinimum && m_Distance > m_MinDistance) { m_PassedMinimum = true; if (m_ForgetIgnoreRoot) { m_IgnoreRoot = null; } if (m_MeshRenderer != null && m_MeshRenderer.enabled == false) { m_MeshRenderer.enabled = true; } } Ray ray = new Ray(localTransform.position, localTransform.forward); if (PhysicsExtensions.RaycastNonAllocSingle(ray, out m_Hit, distance, m_Layers, m_IgnoreRoot, QueryTriggerInteraction.Ignore)) { // Set lerp target m_LerpToPosition = m_Hit.point; // Release back to pool m_Release = true; // Update distance travelled m_Distance += m_Hit.distance; m_AmmoEffect.Hit(m_Hit, localTransform.forward, m_Distance, m_Velocity.magnitude, m_DamageSource); OnHit(); } else { // Set lerp target m_LerpToPosition = desiredPosition; // Update distance travelled m_Distance += distance; // Should the bullet just give up and retire? if (m_Distance > k_MaxDistance) { ReleaseProjectile(); } } // Apply forces to the projectile m_Velocity = ApplyForces(m_Velocity); } }
private void UpdateCannonAim() { Vector3?targetPosition = null; RaycastHit straightHit; if (Physics.Raycast(targetDetectorOrigin.position, targetDetectorOrigin.forward, out straightHit, ~targetDetectionLayersToIgnore)) { if (enemyLayerMask.ContainsLayer(straightHit.collider.gameObject.layer)) { targetPosition = straightHit.transform.position; } } if (!targetPosition.HasValue) { var hits = PhysicsExtensions.RaycastCilinderWithEightRays( targetDetectorOrigin.position, targetDetectorOrigin.position + targetDetectorOrigin.forward * 10f, targetDetectionRadius, ~targetDetectionLayersToIgnore, debugTargetDetection, debugTargetDetection ); foreach (var hit in hits) { if (enemyLayerMask.ContainsLayer(hit.collider.gameObject.layer)) { if (debugTargetDetection) { Debug.DrawLine(targetDetectorOrigin.position, hit.point, Color.red); } targetPosition = hit.transform.position; break; } } } if (targetPosition.HasValue) { AimCannonsToPosition(targetPosition.Value); enemyOnTarget = true; if (debugTargetDetection) { Debug.DrawLine(targetDetectorOrigin.position, targetPosition.Value, Color.red); } } else { AimCannonsForward(); enemyOnTarget = false; } crosshair.color = currentCrosshairColor; primaryWeaponLeftCannonAttachment.transform.rotation = currentPrimaryWeaponLeftCannonRotation; primaryWeaponRightCannonAttachment.transform.rotation = currentPrimaryWeaponRightCannonRotation; secondaryWeaponLeftCannonAttachment.transform.rotation = currentSecondaryWeaponLeftCannonRotation; secondaryWeaponRightCannonAttachment.transform.rotation = currentSecondaryWeaponRightCannonRotation; }
/// <summary> /// Move the transform trying to stop being overlaping other colliders /// </summary> /// <param name="position">start position. Bottom of the collider</param> /// <returns>Final position</returns> Vector3 FixOverlaps(Vector3 position, Vector3 offset, out Vector3 nResult) { Vector3 nTemp = Vector3.zero; // what if you sum all the penetration directions to give the final result // and with each collision, add a CollisionFlag accordingly with the axis collided? CapsuleCollider coll = ownCollider as CapsuleCollider; //Vector3 p = position - (position - coll.transform.position) + (coll.bounds.center - new Vector3(0, coll.bounds.extents.y, 0)); //int nColls = Physics.OverlapCapsuleNonAlloc(p, new Vector3(p.x, p.y + coll.height, p.z), coll.radius, overlapingColliders, GroundLayer, QueryTriggerInteraction.Ignore); // when dead, collide onlly with the world LayerMask overlapMask; if (IsAlive) { overlapMask = m_SolidLayer | m_EnemyLayer; } else { overlapMask = m_SolidLayer; } int nColls = PhysicsExtensions.OverlapCapsuleNonAlloc(coll, offset, overlapingColliders, overlapMask, QueryTriggerInteraction.Ignore); for (int i = 0; i < nColls; i++) { Collider c = overlapingColliders[i]; if (c == ownCollider) { continue; // ignore itself } Vector3 normal; float dist; float dot; if (Physics.ComputePenetration(ownCollider, position, transform.rotation, c, c.transform.position, c.transform.rotation, out normal, out dist)) { // TODO: report bug if (float.IsNaN(normal.x) || float.IsNaN(normal.y) || float.IsNaN(normal.y)) { continue; } // depenetration value for preventing doors // from overlapping with player when it shouldn't dist += Depenetration; dot = Vector3.Dot(normal, Vector3.up); if (dot > m_Settings.SlopeLimit && dot <= 1) { Collisions = Collisions | CC_Collision.CollisionBelow; position += normal * dist; State &= ~CC_State.OnPlatform; } if (dot >= 0 && dot < m_Settings.SlopeLimit) { Collisions = Collisions | CC_Collision.CollisionSides; } if (dot < 0) { Collisions = Collisions | CC_Collision.CollisionAbove; } nTemp += normal; } } nResult = nTemp; return(position); }
protected bool IsPositionDirectlyReachable(Vector3 targetPosition) { var sqrMagnitudeToPosition = (targetPosition - transform.position).sqrMagnitude; // First, check for straight line of sight, from center to center. RaycastHit hit; if (Physics.Raycast(transform.position, targetPosition - transform.position, out hit, float.MaxValue, ~layersToIgnoreInSightTest)) { var sqrMagnitudeToHit = (hit.point - transform.position).sqrMagnitude; // If the hit point is closer than the position that we want to see, there is something in between. if (sqrMagnitudeToHit < sqrMagnitudeToPosition) { Debug.DrawLine(transform.position, hit.point); return(false); } } // Now we check if the boundaries of the object are also directly reachable to destination point. var hits = PhysicsExtensions.RaycastCilinderWithEightRays( transform.position, targetPosition, sightTestSphereCastRadius, ~layersToIgnoreInSightTest, debugReachabilityTest ); var obstructed = false; foreach (var h in hits) { var sqrMagnitudeToHit = (h.point - transform.position).sqrMagnitude; // If the hit point is closer than the position that we want to see, there is something in between. if (sqrMagnitudeToHit < sqrMagnitudeToPosition) { obstructed = true; break; } } return(!obstructed); //var origins = new Vector3[8]; //origins[0] = transform.TransformPoint(Vector3.up * sightTestSphereCastRadius); //origins[1] = transform.TransformPoint((Vector3.up + Vector3.right).normalized * sightTestSphereCastRadius); //origins[2] = transform.TransformPoint(Vector3.right * sightTestSphereCastRadius); //origins[3] = transform.TransformPoint((Vector3.down + Vector3.right).normalized * sightTestSphereCastRadius); //origins[4] = transform.TransformPoint(Vector3.down * sightTestSphereCastRadius); //origins[5] = transform.TransformPoint((Vector3.down + Vector3.left).normalized * sightTestSphereCastRadius); //origins[6] = transform.TransformPoint(Vector3.left * sightTestSphereCastRadius); //origins[7] = transform.TransformPoint((Vector3.up + Vector3.left).normalized * sightTestSphereCastRadius); //var direction = targetPosition - transform.position; //var sqrMagnitudeToPosition = (targetPosition - transform.position).sqrMagnitude; //RaycastHit hit; //foreach (var origin in origins) //{ // if (Physics.Raycast(origin, direction, out hit, float.MaxValue, ~layersToIgnoreInSightTest)) // { // if (debugReachabilityTest) // { // Debug.DrawLine(origin, hit.point); // } // var sqrMagnitudeToHit = (hit.point - transform.position).sqrMagnitude; // // If the hit point is closer than the position that we want to see, there is something in between. // if (sqrMagnitudeToHit < sqrMagnitudeToPosition) // { // return false; // } // } //} //// If nothing was hit, there is nothing between the position and the observer. //return true; }