void Start()
{
// Fetch our references.
m_Hinge = GetComponent <HingeJoint2D>();
m_CustomCollider = GetComponent <CustomCollider2D>();
// Start with no shapes.
m_ShapeGroup.Clear();
// Iterate all the paths for our logo.
foreach (var path in m_UnityLogo)
{
// Add the whole path as a set of edges.
m_ShapeGroup.AddEdges(path, 0.01f);
// Iterate each vertex in the path adding a Circle to each to
// demonstrate the compound nature of the PhysicsShapeGroup2D and CustomCollider2D i.e. mixed shape types.
foreach (var vertex in path)
{
m_ShapeGroup.AddCircle(vertex, 0.1f);
}
}
// Assign the shape group to the CustomCollider2D.
m_CustomCollider.SetCustomShapes(m_ShapeGroup);
// Periodically perform a random update.
InvokeRepeating(nameof(SetRandomMotor), 1f, 3f);
}
static void RemoveObjectFromArea(Vector2i areaIndex, int objIndexInArea, CustomCollider2D obj)
{
var area = mCollidersInArea[areaIndex.x, areaIndex.y];
if (area.Count == 0)
{
Debug.Log("Removing object from an area that doesn't contain any objects, areaIndex: " + areaIndex.x + ", " + areaIndex.y + ", objIndexInArea: " + objIndexInArea);
//Debug.Break();
}
//swap the last item with the one we are removing
var tmp = area[area.Count - 1];
area[area.Count - 1] = obj;
area[objIndexInArea] = tmp;
var tmpIds = tmp.mIdsInAreas;
var tmpAreas = tmp.mAreas;
for (int i = 0; i < tmpAreas.Count; ++i)
{
if (tmpAreas[i] == areaIndex)
{
tmpIds[i] = objIndexInArea;
break;
}
}
//remove the last item
area.RemoveAt(area.Count - 1);
}
/// <summary>
/// This will add a collider to the appropriate list. The list that it is assigned to will be determined by whether or not
/// it uses a rigid body to move. (i.e. whether or not it is static
/// </summary>
/// <param name="collider"></param>
public void AddColliderToManager(CustomCollider2D collider)
{
if (collider.isStatic)
{
if (staticColliderList.Contains(collider))
{
Debug.LogWarning("We are trying to add a collider to our static collider list multiplie times");
}
else
{
staticColliderList.Add(collider);
}
}
else
{
if (nonStaticColliderList.Contains(collider))
{
Debug.LogWarning("We are trying to add a collider to our non static collider list multiplie times");
}
else
{
nonStaticColliderList.Add(collider);
}
}
}
/// <summary>
///
/// </summary>
/// <param name="colliderToCheck"></param>
/// <returns></returns>
public override bool ColliderIntersectVertically(CustomCollider2D colliderToCheck)
{
if (colliderToCheck == this)
{
return(false);
}
//if (rigid.velocity.y == 0)
//{
// return false;
//}
if (ColliderIntersectBounds(verticalBounds, colliderToCheck))
{
if (colliderToCheck is CustomBoxCollider2D)
{
float yPosition = IntersectionPointNonstaticCapsuleStaticRect(this, (CustomBoxCollider2D)colliderToCheck, true).y;
this.transform.position = new Vector3(this.transform.position.x, yPosition, this.transform.position.z);
}
else if (colliderToCheck is CustomCircleCollider2D)
{
Vector2 collisionPoint = IntersectionPointNonstaticCapsuleStaticCircle(this, ((CustomCircleCollider2D)colliderToCheck), true);
this.transform.position = new Vector3(this.transform.position.x, collisionPoint.y, this.transform.position.z);
}
else if (colliderToCheck is CustomCapsuleCollider2D)
{
Vector2 collisionPoint = IntersectionPointCapsuleOnCapsule(this, (CustomCapsuleCollider2D)colliderToCheck, true);
this.transform.position = new Vector3(this.transform.position.x, collisionPoint.y, this.transform.position.z);
}
return(true);
}
return(false);
}
/// <summary>
///
/// </summary>
/// <param name="colliderToCheck"></param>
/// <returns></returns>
public override bool ColliderIntersectHorizontally(CustomCollider2D colliderToCheck)
{
if (colliderToCheck == this)
{
return(false);
}
//if (rigid.velocity.x == 0) return false;
if (ColliderIntersectBounds(horizontalBounds, colliderToCheck))
{
if (colliderToCheck is CustomBoxCollider2D)
{
float xPosition = IntersectionPointNonstaticCapsuleStaticRect(this, (CustomBoxCollider2D)colliderToCheck, false).x;
this.transform.position = new Vector3(xPosition, this.transform.position.y, this.transform.position.z);
}
else if (colliderToCheck is CustomCircleCollider2D)
{
Vector2 collisionPoint = IntersectionPointNonstaticCapsuleStaticCircle(this, ((CustomCircleCollider2D)colliderToCheck), false);
transform.position = new Vector3(collisionPoint.x, this.transform.position.y, this.transform.position.z);
}
else if (colliderToCheck is CustomCapsuleCollider2D)
{
Vector2 collisionPoint = IntersectionPointCapsuleOnCapsule(this, (CustomCapsuleCollider2D)colliderToCheck, false);
transform.position = new Vector3(collisionPoint.x, this.transform.position.y, this.transform.position.z);
}
return(true);
}
return(false);
}
/// <summary>
///
/// </summary>
/// <param name="colliderToCheck"></param>
/// <returns></returns>
public override bool ColliderIntersectHorizontally(CustomCollider2D colliderToCheck)
{
if (colliderToCheck == this || GetIngoreLayerCollision(colliderToCheck))
{
return(false);
}
if (ColliderIntersectBounds(horizontalCheckBounds, colliderToCheck))
{
if (colliderToCheck is CustomBoxCollider2D)
{
float xPosition = IntersectionPointRectOnRect(this, (CustomBoxCollider2D)colliderToCheck, false).x;
this.transform.position = new Vector3(xPosition, this.transform.position.y, this.transform.position.z);
}
else if (colliderToCheck is CustomCircleCollider2D)
{
Vector2 collisionPoint = IntersectionPointNonstaticRectOnStaticCircle(this, ((CustomCircleCollider2D)colliderToCheck), false);
transform.position = new Vector3(collisionPoint.x, this.transform.position.y, this.transform.position.z);
}
else if (colliderToCheck is CustomCapsuleCollider2D)
{
Vector2 collisionPoint = IntersectionPointStaticCapsuleNonStaticRect((CustomCapsuleCollider2D)colliderToCheck, this, false);
transform.position = new Vector3(collisionPoint.x, this.transform.position.y, this.transform.position.z);
}
return(true);
}
return(false);
}
/// <summary>
///
/// </summary>
/// <param name="colliderToCheck"></param>
/// <param name="offsetDirection"></param>
/// <returns></returns>
public override bool ColliderIntersectVertically(CustomCollider2D colliderToCheck)
{
if (colliderToCheck == this || GetIngoreLayerCollision(colliderToCheck))
{
return(false);
}
if (rigid.Velocity.y == 0)
{
return(false);
}
if (ColliderIntersectBounds(verticalCheckBounds, colliderToCheck))
{
if (colliderToCheck is CustomBoxCollider2D)
{
float yPosition = IntersectionPointRectOnRect(this, (CustomBoxCollider2D)colliderToCheck, true).y;
this.transform.position = new Vector3(this.transform.position.x, yPosition, this.transform.position.z);
}
else if (colliderToCheck is CustomCircleCollider2D)
{
Vector2 collisionPoint = IntersectionPointNonstaticRectOnStaticCircle(this, ((CustomCircleCollider2D)colliderToCheck), true);
this.transform.position = new Vector3(this.transform.position.x, collisionPoint.y, this.transform.position.z);
}
else if (colliderToCheck is CustomCapsuleCollider2D)
{
Vector2 collisionPoint = IntersectionPointStaticCapsuleNonStaticRect((CustomCapsuleCollider2D)colliderToCheck, this);
this.transform.position = new Vector3(this.transform.position.x, collisionPoint.y, this.transform.position.z);
}
return(true);
}
return(false);
}
/// <summary>
/// This method will be called every time we generate an overlap event
/// </summary>
/// <param name="Collider2D"></param>
public void OnBeginOverlap(CustomCollider2D Collider2D)
{
if (AOnBeginOverlap != null)
{
AOnBeginOverlap.Invoke(Collider2D);
}
}
private Vector3 GetCollisionPoint(CustomCollider2D col1, CustomCollider2D col2)
{
Vector3 dirVector = (col2.transform.position + col2.centerOffset) - (col1.transform.position + col1.centerOffset);
Vector3 closestPoint = dirVector.normalized * col1.radius;
return(col1.transform.position + closestPoint);
}
/// <summary>
/// This method will be called every time we generate an end overlap event
/// </summary>
/// <param name="Collider2D"></param>
public void OnEndOverlap(CustomCollider2D Collider2D)
{
if (UA_OnEndOverlap != null)
{
UA_OnEndOverlap.Invoke(Collider2D);
}
}
/// <summary>
///
/// </summary>
/// <param name="colliderToCheck"></param>
/// <returns></returns>
public override bool ColliderIntersectHorizontally(CustomCollider2D colliderToCheck)
{
if (rigid.Velocity.x == 0)
{
return(false);
}
if (CircleColliderCollisionsAtBounds(horizontalBoundsFromVelocity, colliderToCheck))
{
if (colliderToCheck is CustomBoxCollider2D)
{
Vector2 pointOfCollision = IntersectionPointNonstaticRectOnStaticCircle(((CustomBoxCollider2D)colliderToCheck), this, false);
this.transform.position = new Vector3(pointOfCollision.x, this.transform.position.y, this.transform.position.z);
return(true);
}
else if (colliderToCheck is CustomCircleCollider2D)
{
CustomCircleCollider2D customcircleToCheck = (CustomCircleCollider2D)colliderToCheck;
Vector2 collisionPoint = IntersectionPointCircleOnCircle(this, customcircleToCheck, false);
this.transform.position = new Vector3(collisionPoint.x, this.transform.position.y, this.transform.position.z);
}
else if (colliderToCheck is CustomCapsuleCollider2D)
{
CustomCapsuleCollider2D capCollider = (CustomCapsuleCollider2D)colliderToCheck;
Vector2 collisionPoint = IntersectionPointStaticCapsuleNonstaticCircle(capCollider, this, false);
this.transform.position = new Vector3(collisionPoint.x, this.transform.position.y, this.transform.position.z);
}
return(true);
}
return(false);
}
private void Awake()
{
collider = GetComponent <CustomCollider2D>();
transform = GetComponent <Transform>();
rigidbody = GetComponent <CustomRigidBody2D>();
difficultyMultiplier = 1f;
}
public void RemoveColliderFromManager(CustomCollider2D collider)
{
if (!colliderList.Contains(collider))
{
return;
}
colliderList.Remove(collider);
}
public void AddColliderToManager(CustomCollider2D collider)
{
if (colliderList.Contains(collider))
{
return;
}
colliderList.Add(collider);
}
public void UnregisterCollider(CustomCollider2D collider)
{
if (customSphereColliders2Ds == null)
{
return;
}
customSphereColliders2Ds.Remove(collider);
}
public static void RemoveObjectFromAreas(CustomCollider2D obj)
{
for (int i = 0; i < obj.mAreas.Count; ++i)
{
RemoveObjectFromArea(obj.mAreas[i], obj.mIdsInAreas[i], obj);
}
obj.mAreas.Clear();
obj.mIdsInAreas.Clear();
}
public void UnregisterCollider(CustomCollider2D customCollider2D)
{
if (customCollider2Ds == null)
{
return;
}
customCollider2Ds.Remove(customCollider2D);
}
private bool CheckTeleportedInsideStaticCollider(CustomCollider2D nonstaticCollider)
{
foreach (CustomCollider2D staticCollider in staticColliderList)
{
if (nonstaticCollider.ColliderIntersectHorizontally(staticCollider))
{
return(true);
}
}
return(false);
}
public CollisionData(CustomCollider2D other, Vector2 overlap = default(Vector2), Vector2 speed1 = default(Vector2), Vector2 speed2 = default(Vector2), Vector2 oldPos1 = default(Vector2), Vector2 oldPos2 = default(Vector2), Vector2 pos1 = default(Vector2), Vector2 pos2 = default(Vector2))
{
this.other = other;
this.overlap = overlap;
this.speed1 = speed1;
this.speed2 = speed2;
this.oldPos1 = oldPos1;
this.oldPos2 = oldPos2;
this.pos1 = pos1;
this.pos2 = pos2;
}
/// <summary>
/// Safely Adds a collider2D to our Physics manager
/// </summary>
/// <param name="Collider2D"></param>
public void AddCollider2DToPhysicsManager(CustomCollider2D Collider2D)
{
if (!AllActiveCollider2DComponentsInLevel.ContainsKey(Collider2D.AssignedCollisionType))
{
AllActiveCollider2DComponentsInLevel.Add(Collider2D.AssignedCollisionType, new HashSet <CustomCollider2D>());
}
if (!AllActiveCollider2DComponentsInLevel[Collider2D.AssignedCollisionType].Add(Collider2D))
{
Debug.LogWarning("You are trying to add a collider that was already added to our list.");
}
}
public override bool CheckHitboxIntersect(Hitbox hboxToCheck)
{
if (hboxToCheck is HitboxRect)
{
return(CustomCollider2D.RectIntersectRect(this.bounds, ((HitboxRect)hboxToCheck).bounds));
}
if (hboxToCheck is HitboxCircle)
{
return(CustomCollider2D.RectIntersectCircle(this.bounds, ((HitboxCircle)hboxToCheck).bounds));
}
return(false);
}
/// <summary>
/// Safely removes a collider from our Physics manager
/// </summary>
/// <param name="Collider2D"></param>
public void RemoveCollider2DFromPhysicsManager(CustomCollider2D Collider2D)
{
if (!AllActiveCollider2DComponentsInLevel.ContainsKey(Collider2D.AssignedCollisionType))
{
Debug.LogWarning("You are trying to remove a collider before the collision type has been added. Something may have gone wrong here");
return;
}
if (!AllActiveCollider2DComponentsInLevel[Collider2D.AssignedCollisionType].Remove(Collider2D))
{
Debug.LogWarning("There was no collider found for this Collider2D object. Either you already removed this object or you are removing something that was never added.");
}
}
public virtual bool AddCollider(CustomCollider2D customCollider2D)
{
if (customCollider2DsCollissionning == null)
{
customCollider2DsCollissionning = new List <CustomCollider2D>();
}
if (customCollider2DsCollissionning.Contains(customCollider2D))
{
return(false);
}
customCollider2DsCollissionning.Add(customCollider2D);
return(true);
}
private bool RemoveCollider(CustomCollider2D customCollider2D)
{
if (customCollider2DsCollissionning == null)
{
customCollider2DsCollissionning = new List <CustomCollider2D>();
}
if (!customCollider2DsCollissionning.Contains(customCollider2D))
{
return(false);
}
customCollider2DsCollissionning.Remove(customCollider2D);
return(true);
}
public void RegisterCollider(CustomCollider2D collider)
{
if (customSphereColliders2Ds == null)
{
customSphereColliders2Ds = new List <CustomCollider2D>();
}
if (customSphereColliders2Ds.Contains(collider))
{
return;
}
customSphereColliders2Ds.Add(collider);
}
public override Vector2 GetLeftBoundAtYValue(float y)
{
if (y > bounds.rectBounds.topLeft.y)
{
return(CustomCollider2D.GetLeftBoundAtYValueCircle(bounds.topCircleBounds, y));
}
else if (y < bounds.rectBounds.bottomLeft.y)
{
return(CustomCollider2D.GetLeftBoundAtYValueCircle(bounds.bottomCircleBounds, y));
}
else
{
return(CustomCollider2D.GetLeftBoundAtYValueRect(bounds.rectBounds, y));
}
}
public Vector2 PushOutCollider(CustomCollider2D OtherCollider, out bool ShouldPushOutVertically, out bool ShouldPushOutHorizontally, bool UseBufferForOverlap = false)
{
Vector2 OffsetToBePushedOut = Vector2.zero;
PreviousBounds.ShouldPushOutBounds(OtherCollider.AssociatedBounds, out ShouldPushOutVertically, out ShouldPushOutHorizontally, UseBufferForOverlap);
if (ShouldPushOutVertically)
{
OffsetToBePushedOut += AssociatedBounds.GetOffsetToClosestVerticalPointOnBounds(OtherCollider.AssociatedBounds);
}
if (ShouldPushOutHorizontally)
{
OffsetToBePushedOut += AssociatedBounds.GetOffsetToClosestHorizontalPointOnBounds(OtherCollider.AssociatedBounds);
}
return(OffsetToBePushedOut);
}
/// <summary>
///
/// </summary>
/// <param name="capsuleBounds"></param>
/// <param name="colliderToCheck"></param>
/// <returns></returns>
private bool CheckColliderIntersectFromBounds(BoundsCapsule capsuleBounds, CustomCollider2D colliderToCheck)
{
if (colliderToCheck is CustomBoxCollider2D)
{
return(CapsuleIntersectRect(capsuleBounds, ((CustomBoxCollider2D)colliderToCheck).bounds));
}
else if (colliderToCheck is CustomCircleCollider2D)
{
return(CapsuleIntersectCircle(capsuleBounds, ((CustomCircleCollider2D)colliderToCheck).bounds));
}
else if (colliderToCheck is CustomCapsuleCollider2D)
{
return(CapsuleIntersectCapsule(capsuleBounds, ((CustomCapsuleCollider2D)colliderToCheck).bounds));
}
return(false);
}
/// <summary>
/// Removes a collider object from our physics manager. This should typically only be called upon the collider
/// object being destroyed
/// </summary>
/// <param name="collider"></param>
public void RemoveColliderFromManager(CustomCollider2D collider)
{
if (collider.isStatic)
{
if (staticColliderList.Contains(collider))
{
staticColliderList.Remove(collider);
}
}
else
{
if (nonStaticColliderList.Contains(collider))
{
nonStaticColliderList.Remove(collider);
}
}
}
public static void HandleCollision(CustomCollider2D obj1, CustomCollider2D obj2)
{
//We add in a clause that if both colliders belong to the same entity they ignore eachother
if (obj1.mState == ColliderState.Closed || obj2.mState == ColliderState.Closed || obj1.mEntity == obj2.mEntity)
{
return;
}
//First we'll check to see if its a pushbox collision
if (obj1 is PhysicsBody && obj2 is PhysicsBody)
{
PhysicsCollision((PhysicsBody)obj1, (PhysicsBody)obj2);
}
if (obj1 is Hitbox && obj2 is Hurtbox)
{
HitCollision((Hitbox)obj1, (Hurtbox)obj2);
}
if (obj2 is Hitbox && obj1 is Hurtbox)
{
HitCollision((Hitbox)obj2, (Hurtbox)obj1);
}
if (obj1 is Blockbox && obj2 is Hitbox)
{
BlockCollision((Blockbox)obj1, (Hitbox)obj2);
}
if (obj2 is Blockbox && obj1 is Hitbox)
{
BlockCollision((Blockbox)obj2, (Hitbox)obj1);
}
if (obj1 is Sightbox && obj2 is PhysicsBody)
{
SightCollision((Sightbox)obj1, (PhysicsBody)obj2);
}
if (obj2 is Sightbox && obj1 is PhysicsBody)
{
SightCollision((Sightbox)obj2, (PhysicsBody)obj1);
}
}
