private static HashSet <TilePos> objectTiles(ICollisionObject obj) { switch (obj.Type) { case CollisionObjectType.Circle: CollisionCircle circle = obj as CollisionCircle; return(tilesByPosition(circle.Center.X - circle.Radius, circle.Center.Y - circle.Radius, circle.Center.X + circle.Radius, circle.Center.Y + circle.Radius)); case CollisionObjectType.Rect: CollisionRect rect = obj as CollisionRect; Vector min = new Vector(double.MaxValue); Vector max = new Vector(double.MinValue); foreach (Vector point in rect.Points) { min.set(Math.Min(point.X, min.X), Math.Min(point.Y, min.Y)); max.set(Math.Max(point.X, max.X), Math.Max(point.Y, max.Y)); } return(tilesByPosition(min.X, min.Y, max.X, max.Y)); } ; return(new HashSet <TilePos>()); }
/// <summary> /// A function used to indicate that a GameObject should check collisions with the BackgroundObjects and other GameObjects /// </summary> /// <param name="collisionObject"></param> protected void AddCollisionObject(ICollisionObject collisionObject) { //Debug.Assert(collisionObject.UsesCollider); //DebugUtils.AssertNotNull(collisionObject.PhysicsBody); CollisionObjects.Add(collisionObject); }
public void NotifyOfCollision(ICollisionObject otherObject) { if (otherObject is Cow) { remove(); } }
/// <summary> /// Creates a new instance /// </summary> /// <param name="collisionObject">The ParentObject this instance will be associated with</param> /// <param name="vertices">The Model vertices used to compute the BEPUPgysics StaticMesh</param> /// <param name="indices">The Model indices used to compute the BEPUPgysics StaticMesh</param> public StaticMeshCollisionMove(ICollisionObject collisionObject, Vector3[] vertices, int[] indices) : base(collisionObject) { ParentObject.World.Decompose(out _collisionObjectScale, out _collisionObjectRotation, out _collisionObjectTranslation); SpaceObject = new StaticMesh(vertices, indices, new AffineTransform(_collisionObjectScale, _collisionObjectRotation, _collisionObjectTranslation)); }
/// <summary> /// Executes collision between two bodies /// </summary> /// <param name="body1"></param> /// <param name="body2"></param> /// <param name="removePair"></param> /// <returns></returns> protected bool Test(ICollisionObject body1, ICollisionObject body2, bool removePair = true) { var result = new CollisionResult(); var paired = FindCollisionPair(body1, body2, removePair); if (TestCollisionShapes(body1.CollisionShape, body2.CollisionShape, ref result)) { result.Type = paired ? CollisionType.Stay : CollisionType.Enter; CacheCollisionPair(body1, body2); body2.OnCollision(result, body1); result.Normal *= -1; result.First = true; body1.OnCollision(result, body2); return(true); } else { if (paired) { result.Type = CollisionType.Exit; body2.OnCollision(result, body1); result.Normal *= -1; result.First = true; body1.OnCollision(result, body2); return(true); } } return(false); }
///Other private List <ICollisionObject> objectsByTilesAndEdgesInfo(Dictionary <TilePos, TileDir[]> tilesInfo) { CollisionRect carRect = new CollisionRect(car); List <ICollisionObject> result = new List <ICollisionObject>(); if (null != tilesInfo) { foreach (TilePos pos in tilesInfo.Keys) { foreach (TileDir dir in tilesInfo[pos]) { ICollisionObject obj = null; if (dir.Correct()) { obj = new CollisionSide(pos, dir); } else { obj = new CollisionCircle(pos, dir); } if (null == CollisionDetector.CheckCollision(carRect, obj)) { result.Add(obj); } } } } return(result); }
public static CollisionInfo CheckCollision(ICollisionObject obj, ICollisionObject obj2) { CollisionInfo info = new CollisionInfo(obj, obj2); if (CheckCollision(info)) { return(info); } return(null); }
/// <summary> /// Creates a new instance /// </summary> /// <param name="collisionObject">The ParentObject this instance will be associated with</param> /// <param name="model">The Model used to compute the BEPUPgysics StaticMesh</param> public StaticMeshCollisionMove(ICollisionObject collisionObject, Model model) : base(collisionObject) { Vector3[] vertices; int[] indices; TriangleMesh.GetVerticesAndIndicesFromModel(model, out vertices, out indices); ParentObject.World.Decompose(out _collisionObjectScale, out _collisionObjectRotation, out _collisionObjectTranslation); SpaceObject = new StaticMesh(vertices, indices, new AffineTransform(_collisionObjectScale, _collisionObjectRotation, _collisionObjectTranslation)); }
/// <summary> /// Adds a body to the CollisionSystem /// </summary> /// <param name="body"></param> /// <returns></returns> public virtual bool AddBody(ICollisionObject body) { if (!bodyList.Contains(body) && bodyList.Count < MaxCollisionBodies) { body.RefId = _uniqueIndex; _uniqueIndex++; bodyList.Add(body); return(true); } return(false); }
/// <summary> /// Creates a new instance /// </summary> /// <param name="collisionObject">The ParentObject this instance will be associated with</param> /// <param name="model">The Model used to compute the ConvexHull shape used for collision & physics</param> /// <remarks>If a previously created instance uses the same Model as the one provided here, it will reuse the computed ConvexHull instance to save CPU</remarks> public ConvexHullCollisionMove(ICollisionObject collisionObject, Model model) : base(collisionObject) { ModelReferencesToDelete.Clear(); foreach (var modelConvexHull in ModelConvexHulls) { if (!modelConvexHull.Key.IsAlive) { ModelReferencesToDelete.Add(modelConvexHull.Key); } else if (modelConvexHull.Key.Target == model) { ConvexHull convexHull = modelConvexHull.Value; TransformableShape shape = new TransformableShape(convexHull.CollisionInformation.Shape, Matrix3X3.CreateFromMatrix(ParentObject.World)); SpaceObject = new Entity <ConvexCollidable <TransformableShape> >( new ConvexCollidable <TransformableShape>(shape), ParentObject.Mass, convexHull.LocalInertiaTensor, convexHull.Volume); Entity.Position = ParentObject.World.Translation; } } foreach (var modelReference in ModelReferencesToDelete) { ModelConvexHulls.Remove(modelReference); } if (SpaceObject == null) { Vector3[] vertices; int[] indices; TriangleMesh.GetVerticesAndIndicesFromModel(model, out vertices, out indices); var modelReference = new WeakReference(model); var convexHull = new ConvexHull(vertices, ParentObject.Mass); ModelConvexHulls.Add(modelReference, convexHull); TransformableShape shape = new TransformableShape(convexHull.CollisionInformation.Shape, Matrix3X3.CreateFromMatrix(ParentObject.World)); SpaceObject = new Entity <ConvexCollidable <TransformableShape> >( new ConvexCollidable <TransformableShape>(shape), ParentObject.Mass, convexHull.LocalInertiaTensor, convexHull.Volume); Entity.Position = ParentObject.World.Translation; } ParentObject.World.GetScaleComponent(out CollisionObjectScale); }
/// <summary> /// Creates a new instance /// </summary> /// <param name="collisionObject">The ParentObject this instance will be associated with</param> public BoxCollisionMove(ICollisionObject collisionObject) : base(collisionObject) { ParentObject.World.GetScaleComponent(out CollisionObjectScale); SpaceObject = new Box( ParentObject.World.Translation, (ParentObject.ObjectBoundingBox.Max.X - ParentObject.ObjectBoundingBox.Min.X) * CollisionObjectScale.X, (ParentObject.ObjectBoundingBox.Max.Y - ParentObject.ObjectBoundingBox.Min.Y) * CollisionObjectScale.Y, (ParentObject.ObjectBoundingBox.Max.Z - ParentObject.ObjectBoundingBox.Min.Z) * CollisionObjectScale.Z, ParentObject.Mass); }
public static bool isCollision(ICollisionObject rect1, ICollisionObject rect2) { if (rect1.position.X < rect2.position.X + rect2.size.X && rect1.position.X + rect1.size.X > rect2.position.X && rect1.position.Y < rect2.position.Y + rect2.size.Y && rect1.size.Y + rect1.position.Y > rect2.position.Y) { return(true); } return(false); }
public static List <CollisionInfo> CollisionsWithMap(ICollisionObject obj) { HashSet <TilePos> tiles = objectTiles(obj); List <ICollisionObject> checkObjects = new List <ICollisionObject>(); foreach (TilePos tile in tiles) { checkObjects.AddRange(MapObjects(tile)); } return(CheckCollision(obj, checkObjects)); }
private bool FindCollisionPair(ICollisionObject a, ICollisionObject b, bool remove = true) { var idx = a.RefId * (MaxCollisionBodies + 1) + b.RefId; if (remove) { return(_pairs.Remove(idx)); } else { return(_pairs.Contains(idx)); } }
public void OnCollision(CollisionResult result, ICollisionObject other) { _gizmoColor = result.Type == CollisionType.Exit ? Color.green : Color.red; if (result.Type == CollisionType.Enter) { life--; if (life == 0) { gameObject.SetActive(false); numberofhide++; } } }
private void Start() { m_clothParticleObjects = GetComponentsInChildren <ClothParticleObject>(); ClothParticleConstraints[] clothParticleConstraints = GetComponentsInChildren <ClothParticleConstraints>(); ParticleClothSettings particleSettings = new ParticleClothSettings(); ParticleData[] particleDatas = new ParticleData[m_clothParticleObjects.Length]; Stack <ConstraintData> constraintDatas = new Stack <ConstraintData>(); for (int i = 0; i < m_clothParticleObjects.Length; i++) { ClothParticleObject obj = m_clothParticleObjects[i]; obj.Index = i; particleDatas[i] = obj.ToParticleData(); } for (int i = 0; i < clothParticleConstraints.Length; i++) { ClothParticleConstraints obj = clothParticleConstraints[i]; int indexA = obj.GetComponent <ClothParticleObject>().Index; for (int j = 0; j < obj.OtherClothParticles.Length; j++) { if (obj.ValidConnection(j)) { ClothParticleObject other = obj.OtherClothParticles[j]; ConstraintData constraintData = new ConstraintData(); constraintData.ParticleAIndex = indexA; constraintData.ParticleBIndex = other.Index; constraintData.Length = Vector3.Distance(obj.transform.position, other.transform.position); constraintDatas.Push(constraintData); } } } particleSettings.SetGravity(m_gravity.x, m_gravity.y, m_gravity.z); particleSettings.SetParticles(particleDatas, constraintDatas.ToArray()); //gather collision Objects ICollisionIntegrator[] collisions = GetComponentsInChildren <ICollisionIntegrator>(); ICollisionObject[] collisionObjects = new ICollisionObject[collisions.Length]; for (int i = 0; i < collisions.Length; i++) { collisionObjects[i] = collisions[i].CollisionObject(); } particleSettings.SetCollisions(collisionObjects); m_clothParticleSystem = new ClothParticleSystem(particleSettings); }
public static List <CollisionInfo> CheckCollision(ICollisionObject obj, List <ICollisionObject> objects) { List <CollisionInfo> result = new List <CollisionInfo>(); foreach (ICollisionObject collisionObj in objects) { CollisionInfo info = new CollisionInfo(obj, collisionObj); if (CheckCollision(info)) { result.Add(info); } } return(result); }
public override bool CheckForCollision(ICollisionObject obj) { /* Get the circular collision */ Circle other = obj as Circle; /* Check the collision */ if (other != null) { float radii = mRadius + other.mRadius; return Vector2.DistanceSquared(other.Parent.GetActualPosition(), Parent.GetActualPosition()) - (radii * radii) < 0.0f; } else { return false; } }
public void NotifyOfCollision(ICollisionObject otherObject) { if (otherObject is Ammunition) { int d = ((Ammunition)otherObject).damage; health -= d; if (health <= 0) { isDead = true; } else { healthBar.takeDamage(d, gameTime); } } }
public bool Remove(ICollisionObject collisionObject, Side side) { switch (side) { case Side.Bottom: return(bottomCollided.Remove(collisionObject)); case Side.Right: return(rightCollided.Remove(collisionObject)); case Side.Left: return(leftCollided.Remove(collisionObject)); case Side.Top: return(topCollided.Remove(collisionObject)); } return(false); }
private void CollidedByEnemyCallback(ObjectColliderBase collider, ICollisionObject enemy) { ClearCollider(); if (!_isFinish) { Explode(); ShakeEffect effect = EffectsManager.GetInstance().CreateEffectByType(EffectType.ShakeEffect) as ShakeEffect; effect.DoShake(0, 5, 1, 5); //ObjectColliderBase newCollider = ColliderManager.GetInstance().CreateColliderByType(eColliderType.Circle); //newCollider.SetSize(_size, _size); //newCollider.SetPosition(_curPos); //newCollider.SetEliminateType(eEliminateDef.PlayerSpellCard); //newCollider.SetColliderGroup(eColliderGroup.Enemy | eColliderGroup.EnemyBullet); //newCollider.SetHitEnemyDamage(_dmg); //newCollider.SetExistDuration(1); _isFinish = true; } }
public bool Contains(ICollisionObject collisionObject) { if (bottomCollided.Contains(collisionObject)) { return(true); } if (rightCollided.Contains(collisionObject)) { return(true); } if (leftCollided.Contains(collisionObject)) { return(true); } if (topCollided.Contains(collisionObject)) { return(true); } return(false); }
public bool RemoveAll(ICollisionObject collisionObject) { if (bottomCollided.Contains(collisionObject)) { bottomCollided.Remove(collisionObject); } if (rightCollided.Contains(collisionObject)) { rightCollided.Remove(collisionObject); } if (leftCollided.Contains(collisionObject)) { leftCollided.Remove(collisionObject); } if (topCollided.Contains(collisionObject)) { topCollided.Remove(collisionObject); } return(true); }
public void Add(ICollisionObject objectToAdd, Side side) { switch (side) { case Side.Bottom: bottomCollided.Add(objectToAdd); break; case Side.Right: rightCollided.Add(objectToAdd); break; case Side.Left: leftCollided.Add(objectToAdd); break; case Side.Top: topCollided.Add(objectToAdd); break; } }
public void Update(ICollisionObject CollisionObject) { if (repeat != 0) { if (collider.Intersects(CollisionObject.Collider)) { try { function.Invoke(instance, new object[] { CollisionObject }); } catch (Exception e) { Irbis.Irbis.WriteLine("Trigger Exception: " + e.Message); Irbis.Irbis.WriteLine("Stacktrace:\n" + e.StackTrace + "\n"); Irbis.Irbis.DisplayInfoText("Trigger Exception: " + e.Message, Color.Red); } if (repeat > 0) { repeat--; } } } }
/// <summary> /// Raises the appropriate ParentObject collision events depending on its CollisionType value /// </summary> /// <param name="sender">The current ISpaceObject instance</param> /// <param name="other">The ISpaceObject instance which collided</param> /// <param name="pair"/> protected void OnCollisionDetected(Collidable sender, Collidable other, CollidablePairHandler pair) { if (sender.Tag == null || other.Tag == null) { return; } ICollisionObject senderCollisionObject = (ICollisionObject)sender.Tag; ICollisionObject otherCollisionObject = (ICollisionObject)other.Tag; switch (ParentObject.CollisionType) { case CollisionType.Trigger: { ParentObject.OnCollisionTrigger(senderCollisionObject, otherCollisionObject); break; } case CollisionType.Collide: { var collisionPoint = new CollisionPoint { ContactObject = otherCollisionObject, ContactPoint = pair.Contacts[0].Contact.Position, ContactTime = pair.TimeOfImpact, Material = null, SurfaceNormal = pair.Contacts[0].Contact.Normal }; ParentObject.OnCollisionReact(senderCollisionObject, otherCollisionObject, collisionPoint, ref _collisionHandled); break; } default: case CollisionType.None: { break; } } }
public CollisionPoint(ICollisionObject collisionObject, PointD point) { CollisionObject = collisionObject; Point = point; }
/// <summary> /// Creates a new instance /// </summary> /// <param name="collisionObject">The parent object this instance will be associataed with</param> protected BEPUCollisionMove(ICollisionObject collisionObject) { ParentObject = collisionObject; }
public CompoundBodyCollisionMove(ICollisionObject collisionObject, IList <CompoundShapeEntry> childrenShapes) : base(collisionObject) { SpaceObject = new CompoundBody(childrenShapes, collisionObject.Mass); }
/* Events */ public void CheckCollision(ICollisionObject obj) { /* Check for collision */ bool this_collides = IsCollideableType(obj.Parent.Parent.GetType()); bool other_collideds = obj.IsCollideableType(Parent.Parent.GetType()); if ((this_collides || other_collideds) && CheckForCollision(obj)) { /* Call this objects 'On Collision' event */ if (this_collides && mOnCollision != null) { mOnCollision(this, obj); } /* Call the other objects 'On Collision' event */ if (other_collideds && obj.OnCollision != null) { obj.OnCollision(obj, this); } } }
public abstract bool CheckForCollision(ICollisionObject obj);
public ObjectCollided(ICollisionObject objectCollided, Side sideCollided) { collisionObject = objectCollided; collisionSide = sideCollided; }
/// <summary> /// Creates a new instance /// </summary> /// <param name="collisionObject">The ParentObject this instance will be associated with</param> public SphereCollisionMove(ICollisionObject collisionObject) : base(collisionObject) { SpaceObject = new Sphere(ParentObject.World.Translation, ParentObject.WorldBoundingSphere.Radius); CollisionObjectScale = ParentObject.WorldBoundingSphere.Radius; }
public void addOther(ICollisionObject other) { otherObjects.Add(other); }
/// <summary> /// Creates new collision informations /// </summary> /// <param name="collider">The collisionobject we checked</param> /// <param name="collidee">The collisionobject it collided with</param> public CollisionInfo(ICollisionObject collider, ICollisionObject collidee) { this.left = collider; this.right = collidee; this.resolved = false; }
/// <summary> /// Removes a body from the CollisionSystem /// </summary> /// <param name="body"></param> /// <returns></returns> public virtual bool RemoveBody(ICollisionObject body) { return(bodyList.Remove(body)); }
public void NotifyOfCollision(ICollisionObject otherObject) { //Don't really care - the cow deletes it if necessary }
public void removeOther(ICollisionObject other) { otherObjects.Remove(other); }
public static CollisionObjectModel ToModel(this ICollisionObject obj) => new CollisionObjectModel { Frame = obj.Frame, Primitives = obj.Primitives.Select(x => x.ToModel()).ToList() };