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;
}
