public override void Update(double totalSeconds)
{
base.Update(totalSeconds);
#region Collision update
if (TranslationVector != Vector2.Zero)
{
_boundingCircle.Center = new Point2(WorldPosition.X, WorldPosition.Y);
}
foreach (AEntity entity in GameDatas.AllEntities.Values)
{
if (entity is CollidableEntity && this != entity)
{
if (_boundingCircle.Intersects(((CollidableEntity)entity)._boundingCircle))
{
if (!_collideWith.ContainsKey(entity.Id))
{
((CollidableEntity)entity).OnCollisionEnter?.Invoke(null, this);
OnCollisionEnter?.Invoke(null, (CollidableEntity)entity);
}
else
{
((CollidableEntity)entity).OnCollisionStay?.Invoke(null, this);
OnCollisionStay?.Invoke(null, (CollidableEntity)entity);
}
}
else
{
((CollidableEntity)entity).OnCollisionExit?.Invoke(null, this);
OnCollisionExit?.Invoke(null, (CollidableEntity)entity);
}
}
}
#endregion Collision update
}
private void OnCollisionEnter2D(Collision2D other)
{
if (IsPenguin(other.collider))
{
OnCollisionEnter.Invoke(currentPenguin);
}
}
public void CheckForNewIntersection(Collider other)
{
if (!IntersectingColliders.Contains(other) && shape.Intersects(other.shape))
{
OnCollisionEnter?.Invoke(this, new Collision()
{
Caller = this, otherCollider = other
});
}
}
public void HandlePhysicsEvents()
{
for (int i = 0; i < currentlyCollidingWith.Count; i++)
{
if (lastCollidedWith.Contains(currentlyCollidingWith[i]))
{
//Collided with it last frame.
if (coll.isTrigger)
{
OnTriggerStay?.Invoke(currentlyCollidingWith[i]);
}
else
{
OnCollisionStay?.Invoke(new TFCollision(currentlyCollidingWith[i]));
}
}
else
{
//Did not collide with last frame.
if (coll.isTrigger)
{
OnTriggerEnter?.Invoke(currentlyCollidingWith[i]);
}
else
{
OnCollisionEnter?.Invoke(new TFCollision(currentlyCollidingWith[i]));
}
}
}
for (int w = 0; w < lastCollidedWith.Count; w++)
{
//If we've exited collision with a collider.
if (!currentlyCollidingWith.Contains(lastCollidedWith[w]))
{
if (coll.isTrigger)
{
OnTriggerExit?.Invoke(lastCollidedWith[w]);
}
else
{
OnCollisionExit?.Invoke(new TFCollision(lastCollidedWith[w]));
}
}
}
lastCollidedWith = new List <TFCollider>(currentlyCollidingWith);
currentlyCollidingWith.Clear();
}
protected virtual void OnCollisionEnter2D(Collision2D other)
{
OnCollisionEnter?.Invoke(other);
if (other.gameObject.CompareTag(TagNames.Character) == true)
{
ICharacter otherCharacter = other.gameObject.GetComponent <ICharacter>();
switch (State)
{
case CharacterState.Flying:
otherCharacter.OnHit(this, launchDamage);
OnLaunchEnd();
transform.DOKill();
break;
case CharacterState.Dodge:
transform.DOKill();
OnDodgeEnd();
break;
case CharacterState.Charging:
CancelCharge();
break;
default:
break;
}
}
else if (other.gameObject.CompareTag(TagNames.Map) == true)
{
switch (State)
{
case CharacterState.Flying:
transform.DOKill();
OnLaunchEnd();
break;
case CharacterState.Dodge:
transform.DOKill();
break;
default:
break;
}
rigidBody.velocity = Vector2.zero;
}
}
public override void Update(float deltaTime)
{
Vector2 mousePos = Scene.Active.MainViewport.ScreenToWorldCoordinates(InputHandler.MousePosition);
// TODO
bool contains = this.shape.Contains(GameObject.Transform, mousePos);
if (contains && !contained)
{
OnCollisionEnter?.Invoke(this, null, null); // TODO
}
else if (!contains && contained)
{
OnCollisionExit?.Invoke(this, null, null); // TODO
}
this.contained = contains;
}
void DispatchOnCollisionEnter(Collision collision)
{
OnCollisionEnter?.Invoke(collision, GetCollidingBone(collision));
}
void OnCollisionEnter2D(Collision2D collision)
{
OnCollisionEnter?.Invoke(collision);
}
private void OnCollisionEnter2D(Collision2D other)
{
OnCollisionEnter?.Invoke(other);
}
private void OnCollisionEnter2D(Collision2D other)
{
OnCollisionEnter?.Invoke(other, gameObject);
}
public void DoCollisionCheck(bool triggered = false, CollidAble collidable = null)
{
if (IsActiv)
{
List <CollidAble> collisions;
List <int> alreadyExists = new List <int>();
if (!triggered)
{
grids = CollisionDetection.ActivCollisionDetection.UpdateGrids(this);
collisions = CollisionDetection.ActivCollisionDetection.CheckCollision(this);
}
else
{
collisions = new List <CollidAble>();
collisions.Add(collidable);
}
if (OnCollisionExit != null || OnTriggerExit != null)
{
for (int i = 0; i < previouseCollisions.Length; i++)
{
if (!collisions.Contains(previouseCollisions[i]))
{
if (blocking && previouseCollisions[i].blocking)
{
OnCollisionExit?.Invoke(previouseCollisions[i], new CollisionArgs(previouseCollisions[i]));
if (!triggered)
{
collisions[i].DoCollisionCheck(true, this);
}
}
else
{
OnTriggerExit?.Invoke(previouseCollisions[i], new CollisionArgs(previouseCollisions[i]));
if (!triggered)
{
collisions[i].DoCollisionCheck(true, this);
}
}
}
else
{
alreadyExists.Add(i);
}
}
}
for (int i = 0; i < collisions.Count; i++)
{
if (!alreadyExists.Contains(i))
{
if (blocking && collisions[i].blocking)
{
OnCollisionEnter?.Invoke(collisions[i], new CollisionArgs(collisions[i]));
if (!triggered)
{
collisions[i].DoCollisionCheck(true, this);
}
}
else
{
OnTriggerEnter?.Invoke(collisions[i], new CollisionArgs(collisions[i]));
if (!triggered)
{
collisions[i].DoCollisionCheck(true, this);
}
}
}
else
{
if (blocking && collisions[i].blocking)
{
OnCollision?.Invoke(collisions[i], new CollisionArgs(collisions[i]));
if (!triggered)
{
collisions[i].DoCollisionCheck(true, this);
}
}
else
{
OnTrigger?.Invoke(collisions[i], new CollisionArgs(collisions[i]));
if (!triggered)
{
collisions[i].DoCollisionCheck(true, this);
}
}
}
}
}
}
void DispatchOnCollisionEnter(Collision collision, CollisionEventDispatcher dispatcher)
{
OnCollisionEnter?.Invoke(collision, bones[dispatcher]);
}
public void HandleCollision(Collider2D col)
{
OnCollisionEnter?.Invoke(col);
AfterCollisionEnter?.Invoke();
}
private void OnCollEnter(Collider other)
{
OnCollisionEnter?.Invoke(other);
}
public static void CollisionEnter(BC_CollisionData data)
{
//DebugManager.LogToFile("[OnCollisionEnter] " + data.collider.name + " entered collision with " + data.myCollider.name + " at point " + data.point.ToString() + " with normal of " + data.normal.ToString());
OnCollisionEnter?.Invoke(data);
}
