private void Events_InitialCollisionDetected(EntityCollidable sender, Collidable info, CollidablePairHandler pair, ContactData contact) { try { //var contact = pair.Contacts[0].Contact; //if(contact.PenetrationDepth>2f) //DebugSystem.Instance.DebugCommandUI.Echo(contact.PenetrationDepth.ToString()); // Select collisionInformation for object in contact with instead of the ships own collisionInformation Collidable candidate = (pair.BroadPhaseOverlap.EntryA == racerEntity.CollisionInformation ? pair.BroadPhaseOverlap.EntryB : pair.BroadPhaseOverlap.EntryA) as Collidable; if (candidate.Equals(Physics.currentTrackFloor)) { ReactToTrackHit(contact); } else if (candidate.Equals(Physics.currentTrackWall)) { ReactToWallHit(contact); } else { ReactToShipShipCollision(contact, candidate); } } catch (Exception e) { // System.Diagnostic.Debug.WriteLine("Unfound pair"); } }
public override void collisionEvent(EntityCollidable eCollidable, Collidable collidable, CollidablePairHandler pairHandler) { // bool valid = false; if (collidable.Tag != null && collidable.Tag is CollisionBase) { SceneObject collidee = ((CollisionBase)collidable.Tag).Parent; if (collidee != null && !(collidee is Projectile) && Parent != null && Parent != collidee) { if (collidee is Ship) { collidee.onCollide(this, Damage); /*if (collidee is Ship) { valid = true; }*/ } else { } } else { } } else { } /*if (valid == true) { SceneObjectFactory.createExplosion(Position, Rotation); } else { }*/ }
/// <summary> /// Constructs a new demo. /// </summary> /// <param name="game">Game owning this demo.</param> public FishInABarrelDemo(DemosGame game) : base(game) { game.Camera.Position = new Vector3(0, 7, 30); var detector = new Box(new Vector3(0, 0, 0), 1.5f, 1.5f, 1.5f); detector.CollisionInformation.CollisionRules.Personal = CollisionRule.NoSolver; var acceptedTriggerEntity = new Box(new Vector3(5, 0, 0), 1.6f, .7f, .4f, 1); acceptedTrigger = acceptedTriggerEntity.CollisionInformation; detector.Tag = "noDisplayObject"; acceptedTriggerEntity.Tag = "noDisplayObject"; Space.Add(detector); Space.Add(acceptedTriggerEntity); var fish = game.Content.Load<Model>("fish"); game.ModelDrawer.Add(new DisplayEntityModel(acceptedTriggerEntity, fish, game.ModelDrawer)); var barrelAndPlatform = game.Content.Load<Model>("barrelAndPlatform"); Vector3[] staticTriangleVertices; int[] staticTriangleIndices; TriangleMesh.GetVerticesAndIndicesFromModel(barrelAndPlatform, out staticTriangleVertices, out staticTriangleIndices); //Note that the final 'margin' parameter is optional, but can be used to specify a collision margin on triangles in the static triangle group. var fishDepositoryGroup = new StaticMesh(staticTriangleVertices, staticTriangleIndices); CollisionRules.AddRule(fishDepositoryGroup, detector, CollisionRule.NoBroadPhase); Space.Add(fishDepositoryGroup); game.ModelDrawer.Add(fishDepositoryGroup); movedBox = new Box(new Vector3(-4, 5, 0), 1, 1, 1, 1); detector.Space.Add(movedBox); detector.CollisionInformation.Events.InitialCollisionDetected += InitialCollisionDetected; detector.CollisionInformation.Events.CollisionEnded += CollisionEnded; }
void HandleCollision(EntityCollidable sender, Collidable other, CollidablePairHandler pair) { if (soundEffect != null) { emitter.Position = body.Position / 5.0f; } }
void HandleCollision(EntityCollidable sender, Collidable other, CollidablePairHandler pair) { Console.WriteLine("Got here!"); emitter.Position = body.Position / 5; ; listener.Position = XNAGame.Instance.Camera.Position / 5; soundEffectInstance.Apply3D(listener, emitter); soundEffectInstance.Play(); }
protected void HandleCollision(EntityCollidable sender, Collidable other, CollidablePairHandler pair) { GameEntity ge = other.Tag as GameEntity; if (ge != null && ge.Name == "player") { Game.DrinkBeer(physicalData.Position); Entity.KillEntity(); } }
protected void HandleCollision(EntityCollidable sender, Collidable other, CollidablePairHandler pair) { GameEntity ge = other.Tag as GameEntity; if (ge != null && ge.Name == "punch") { Game.PunchProp(); Entity.Dead = true; } }
public override void InitialCollisionDetected(EntityCollidable sender, Collidable other, CollidablePairHandler collisionPair) { if (other.Tag is CharacterSynchronizer) { if ((other.Tag as CharacterSynchronizer).body.Tag is Creature) { ((other.Tag as CharacterSynchronizer).body.Tag as Creature).Die(); } } }
public override void CollisionEnded(EntityCollidable sender, Collidable other, CollidablePairHandler collisionPair) { if (other.Tag is CharacterSynchronizer) { if ((other.Tag as CharacterSynchronizer).body.Tag is PlayerCreature) { OnExit(); } } }
/// <summary> /// [Utility] Recovers the object from collidable. /// </summary> /// <param name="collidable">The collidable.</param> /// <returns></returns> public static IObject RecoverObjectFromCollidable(BEPUphysics.Collidables.Collidable collidable) { IPhysicObject phy = (collidable.Tag as IPhysicObject); if (phy != null) { return(phy.ObjectOwner); } return(null); }
public override void InitialCollisionDetected(BEPUphysics.Collidables.MobileCollidables.EntityCollidable sender, Collidable other, BEPUphysics.NarrowPhaseSystems.Pairs.CollidablePairHandler collisionPair) { base.InitialCollisionDetected(sender, other, collisionPair); if (other.Tag is CharacterSynchronizer) { ((other.Tag as CharacterSynchronizer).body.Tag as Creature).Poisoned = true; ((other.Tag as CharacterSynchronizer).body.Tag as Creature).Damage(0, mOwner as Creature); } World.Remove(this); }
//Removes the coin from the game if it contacts the character //coin is sender , other is whatever hits it public void coinHit(EntityCollidable sender, Collidable other, CollidablePairHandler pair) { var otherEntityInformation = other as EntityCollidable; if (otherEntityInformation != null && otherEntityInformation.Entity.Tag == cube) { Components.Remove((CoinModel)sender.Entity.Tag); space.Remove(sender.Entity); Console.WriteLine("removed ring"); numRingsHit++; } }
void HandleCollision(EntityCollidable sender, Collidable other, CollidablePairHandler pair) { if (soundEffect != null) { emitter.Position = body.Position / 5.0f; listener.Position = XNAGame.Instance.Camera.Position / 5.0f; soundEffectInstance.Apply3D(listener, emitter); soundEffectInstance.Play(); } }
///<summary> /// Initializes the manifold. ///</summary> ///<param name="newCollidableA">First collidable.</param> ///<param name="newCollidableB">Second collidable.</param> public override void Initialize(Collidable newCollidableA, Collidable newCollidableB) { convex = newCollidableA as ConvexCollidable; mesh = newCollidableB as StaticMesh; if (convex == null || mesh == null) { convex = newCollidableB as ConvexCollidable; mesh = newCollidableA as StaticMesh; if (convex == null || mesh == null) throw new Exception("Inappropriate types used to initialize contact manifold."); } }
protected void HandleCollision(EntityCollidable sender, Collidable other, CollidablePairHandler pair) { GameEntity ge = other.Tag as GameEntity; if (ge != null && ge.Name != "player" && ge.Name != "derper") { if (ge.Name == "prop") { if (player) { Game.PunchObject(ge); } else { Game.AddStupid(0); } } Entity.KillEntity(); } }
public override void InitialCollisionDetected(EntityCollidable sender, Collidable other, CollidablePairHandler collisionPair) { if (mRopeLimit == null) { base.InitialCollisionDetected(sender, other, collisionPair); // If hit physics object link projectile to it then grapple to projectile, otherwise set projectile to kinematic and grapple to projectile if (other.Tag is CharacterSynchronizer) { StickToEntity((other.Tag as CharacterSynchronizer).body); ((other.Tag as CharacterSynchronizer).body.Tag as Creature).Damage(0, (mOwner as Creature)); } else if (other.Tag is IEntityOwner) { StickToEntity((other.Tag as IEntityOwner).Entity); } else { Entity.BecomeKinematic(); } CreateRope(); } }
public override void collisionEvent(EntityCollidable eCollidable, Collidable collidable, CollidablePairHandler pairHandler) { if (collidable.Tag != null && collidable.Tag is CollisionBase) { SceneObject collidee = ((CollisionBase)collidable.Tag).Parent; if (collidee != null && !(collidee is Projectile) && collidee != Parent) { collidee.onCollide(this, Damage); } else { // Was another laser or parent if (collidee != null && collidee is Projectile) { LogCat.updateValue("Collide", "With projectile!"); } else { } } } else { } }
public override void InitialCollisionDetected(EntityCollidable sender, Collidable other, CollidablePairHandler collisionPair) { if (other.Tag is CharacterSynchronizer && !mLoaded) { CharacterSynchronizer synchronizer = (other.Tag as CharacterSynchronizer); if (synchronizer.body.Tag is PlayerCreature) { // Check that the player has the requested part. bool hasCorrectPart = false; foreach (Creature.PartAttachment partAttachment in (synchronizer.body.Tag as Creature).PartAttachments) { if (partAttachment != null && partAttachment.Part.GetType() == PartType) { hasCorrectPart = true; break; } } if (hasCorrectPart) { // Load the next level. mLoaded = true; // TODO: Investigate last frame object additions to next world. World.Clear(); // TODO: Make scale globally accessible or modifiable. if (LevelManager.Exists(mNextLevel)) { World.AddLevelFromFile(mNextLevel, Vector3.Zero, Quaternion.Identity, new Vector3(8.0f, 0.01f, 8.0f)); } else { InputAction.IsMouseLocked = false; ChimeraGame.PopState(); ChimeraGame.PushState(new SuccessMenu(ChimeraGame.Game)); } } } } }
/// <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; } } }
protected void onCollision(EntityCollidable sender, Collidable other, CollidablePairHandler pair) { if(!(other.Tag is Box)) return; joint.Motor.Settings.Servo.Goal = -0.7f; if(!pressed) MediaSystem.PlaySoundEffect(SFXOptions.Machine_Button_Press); pressed = true; }
///<summary> /// Updates the time of impact for the pair. ///</summary> ///<param name="requester">Collidable requesting the update.</param> ///<param name="dt">Timestep duration.</param> public override void UpdateTimeOfImpact(Collidable requester, float dt) { var collidableA = CollidableA as ConvexCollidable; var collidableB = CollidableB as ConvexCollidable; var overlap = BroadPhaseOverlap; if ( (overlap.entryA.IsActive || overlap.entryB.IsActive) && //At least one has to be active. ( ( collidableA.entity.PositionUpdateMode == PositionUpdateMode.Continuous && //If both are continuous, only do the process for A. collidableB.entity.PositionUpdateMode == PositionUpdateMode.Continuous && overlap.entryA == requester ) || ( collidableA.entity.PositionUpdateMode == PositionUpdateMode.Continuous ^ //If only one is continuous, then we must do it. collidableB.entity.PositionUpdateMode == PositionUpdateMode.Continuous ) ) ) { //Only perform the test if the minimum radii are small enough relative to the size of the velocity. //Discrete objects have already had their linear motion integrated, so don't use their velocity. Vector3 velocity; if (collidableA.entity.PositionUpdateMode == PositionUpdateMode.Discrete) velocity = collidableB.entity.linearVelocity; else if (collidableB.entity.PositionUpdateMode == PositionUpdateMode.Discrete) Vector3.Negate(ref collidableA.entity.linearVelocity, out velocity); else Vector3.Subtract(ref collidableB.entity.linearVelocity, ref collidableA.entity.linearVelocity, out velocity); Vector3.Multiply(ref velocity, dt, out velocity); float velocitySquared = velocity.LengthSquared(); var minimumRadiusA = collidableA.Shape.minimumRadius * MotionSettings.CoreShapeScaling; timeOfImpact = 1; if (minimumRadiusA * minimumRadiusA < velocitySquared) { //Spherecast A against B. RayHit rayHit; if (GJKToolbox.CCDSphereCast(new Ray(collidableA.worldTransform.Position, -velocity), minimumRadiusA, collidableB.Shape, ref collidableB.worldTransform, timeOfImpact, out rayHit)) timeOfImpact = rayHit.T; } var minimumRadiusB = collidableB.Shape.minimumRadius * MotionSettings.CoreShapeScaling; if (minimumRadiusB * minimumRadiusB < velocitySquared) { //Spherecast B against A. RayHit rayHit; if (GJKToolbox.CCDSphereCast(new Ray(collidableB.worldTransform.Position, velocity), minimumRadiusB, collidableA.Shape, ref collidableA.worldTransform, timeOfImpact, out rayHit)) timeOfImpact = rayHit.T; } //If it's intersecting, throw our hands into the air and give up. //This is generally a perfectly acceptable thing to do, since it's either sitting //inside another object (no ccd makes sense) or we're still in an intersecting case //from a previous frame where CCD took place and a contact should have been created //to deal with interpenetrating velocity. Sometimes that contact isn't sufficient, //but it's good enough. if (timeOfImpact == 0) timeOfImpact = 1; } }
///<summary> /// Initializes the pair tester. ///</summary> ///<param name="shapeA">First shape in the pair.</param> ///<param name="shapeB">Second shape in the pair.</param> public void Initialize(Collidable shapeA, Collidable shapeB) { collidableA = (ConvexCollidable)shapeA; collidableB = (ConvexCollidable)shapeB; cachedSimplex = new CachedSimplex { State = SimplexState.Point };// new CachedSimplex(informationA.Shape, informationB.Shape, ref informationA.worldTransform, ref informationB.worldTransform); }
///<summary> /// Updates the time of impact for the pair. ///</summary> ///<param name="requester">Collidable requesting the update.</param> ///<param name="dt">Timestep duration.</param> public override void UpdateTimeOfImpact(Collidable requester, float dt) { //TODO: This conditional early outing stuff could be pulled up into a common system, along with most of the pair handler. var overlap = BroadPhaseOverlap; var convexMode = convex.entity == null ? PositionUpdateMode.Discrete : convex.entity.PositionUpdateMode; if ( (mobileMesh.IsActive || (convex.entity == null ? false : convex.entity.activityInformation.IsActive)) && //At least one has to be active. ( ( convexMode == PositionUpdateMode.Continuous && //If both are continuous, only do the process for A. mobileMesh.entity.PositionUpdateMode == PositionUpdateMode.Continuous && overlap.entryA == requester ) || ( convexMode == PositionUpdateMode.Continuous ^ //If only one is continuous, then we must do it. mobileMesh.entity.PositionUpdateMode == PositionUpdateMode.Continuous ) ) ) { //TODO: This system could be made more robust by using a similar region-based rejection of edges. //CCD events are awfully rare under normal circumstances, so this isn't usually an issue. //Only perform the test if the minimum radii are small enough relative to the size of the velocity. Vector3 velocity; if (convex.entity != null) Vector3.Subtract(ref convex.entity.linearVelocity, ref mobileMesh.entity.linearVelocity, out velocity); else Vector3.Negate(ref mobileMesh.entity.linearVelocity, out velocity); Vector3.Multiply(ref velocity, dt, out velocity); float velocitySquared = velocity.LengthSquared(); var minimumRadius = convex.Shape.minimumRadius * MotionSettings.CoreShapeScaling; timeOfImpact = 1; if (minimumRadius * minimumRadius < velocitySquared) { TriangleSidedness sidedness = mobileMesh.Shape.Sidedness; Matrix3X3 orientation; Matrix3X3.CreateFromQuaternion(ref mobileMesh.worldTransform.Orientation, out orientation); var triangle = Resources.GetTriangle(); triangle.collisionMargin = 0; //Spherecast against all triangles to find the earliest time. for (int i = 0; i < MeshManifold.overlappedTriangles.count; i++) { MeshBoundingBoxTreeData data = mobileMesh.Shape.TriangleMesh.Data; int triangleIndex = MeshManifold.overlappedTriangles.Elements[i]; data.GetTriangle(triangleIndex, out triangle.vA, out triangle.vB, out triangle.vC); Matrix3X3.Transform(ref triangle.vA, ref orientation, out triangle.vA); Matrix3X3.Transform(ref triangle.vB, ref orientation, out triangle.vB); Matrix3X3.Transform(ref triangle.vC, ref orientation, out triangle.vC); Vector3.Add(ref triangle.vA, ref mobileMesh.worldTransform.Position, out triangle.vA); Vector3.Add(ref triangle.vB, ref mobileMesh.worldTransform.Position, out triangle.vB); Vector3.Add(ref triangle.vC, ref mobileMesh.worldTransform.Position, out triangle.vC); //Put the triangle into 'localish' space of the convex. Vector3.Subtract(ref triangle.vA, ref convex.worldTransform.Position, out triangle.vA); Vector3.Subtract(ref triangle.vB, ref convex.worldTransform.Position, out triangle.vB); Vector3.Subtract(ref triangle.vC, ref convex.worldTransform.Position, out triangle.vC); RayHit rayHit; if (GJKToolbox.CCDSphereCast(new Ray(Toolbox.ZeroVector, velocity), minimumRadius, triangle, ref Toolbox.RigidIdentity, timeOfImpact, out rayHit) && rayHit.T > Toolbox.BigEpsilon) { if (sidedness != TriangleSidedness.DoubleSided) { Vector3 AB, AC; Vector3.Subtract(ref triangle.vB, ref triangle.vA, out AB); Vector3.Subtract(ref triangle.vC, ref triangle.vA, out AC); Vector3 normal; Vector3.Cross(ref AB, ref AC, out normal); float dot; Vector3.Dot(ref normal, ref rayHit.Normal, out dot); //Only perform sweep if the object is in danger of hitting the object. //Triangles can be one sided, so check the impact normal against the triangle normal. if (sidedness == TriangleSidedness.Counterclockwise && dot < 0 || sidedness == TriangleSidedness.Clockwise && dot > 0) { timeOfImpact = rayHit.T; } } else { timeOfImpact = rayHit.T; } } } Resources.GiveBack(triangle); } } }
/// <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"/> private void OnStaticMeshCollisionDetected(StaticMesh sender, Collidable other, CollidablePairHandler pair) { OnCollisionDetected(sender, other, pair); }
/// <summary> /// Used to handle a collision event triggered by an entity specified above. /// </summary> /// <param name="sender">Entity that had an event hooked.</param> /// <param name="other">Entity causing the event to be triggered.</param> /// <param name="pair">Collision pair between the two objects in the event.</param> void HandleCollision(EntityCollidable sender, Collidable other, CollidablePairHandler pair) { //This type of event can occur when an entity hits any other object which can be collided with. //They aren't always entities; for example, hitting a StaticMesh would trigger this. //Entities use EntityCollidables as collision proxies; see if the thing we hit is one. var otherEntityInformation = other as EntityCollidable; if (otherEntityInformation != null) { //We hit an entity! remove it. space.Remove(otherEntityInformation.Entity); //Remove the graphics too. Components.Remove((EntityModel)otherEntityInformation.Entity.Tag); } }
void Events_InitialCollisionDetected(EntityCollidable sender, Collidable other, CollidablePairHandler pair) { Explode(); }
private void OnCollision(EntityCollidable sender, Collidable other, CollidablePairHandler pair) { var otherEntity = other as EntityCollidable; if(otherEntity != null) { if(otherEntity.Tag is Box) { if(UsesLaserSound) { (otherEntity.Tag as Box).PlayParticles(); MediaSystem.PlaySoundEffect(SFXOptions.Laser); } GameManager.CurrentLevel.DestroyBox((Box)otherEntity.Tag); } } }
public virtual void CollisionEnded(EntityCollidable sender, Collidable other, CollidablePairHandler collisionPair) { if (other.Tag is CharacterSynchronizer) { CollidingObjects.Remove((other.Tag as CharacterSynchronizer).body.Tag as IGameObject); } else { CollidingObjects.Remove(other.Tag as IGameObject); } }
public virtual void InitialCollisionDetected(EntityCollidable sender, Collidable other, CollidablePairHandler collisionPair) { if (other.Tag is CharacterSynchronizer) { CharacterSynchronizer synchronizer = (other.Tag as CharacterSynchronizer); CollidingObjects.Add(synchronizer.body.Tag as IGameObject); } else { CollidingObjects.Add(other.Tag as IGameObject); } }
/// <summary> /// Computes the intersection, if any, between a ray and the objects in the character's bounding box. /// </summary> /// <param name="ray">Ray to test.</param> /// <param name="length">Length of the ray to use in units of the ray's length.</param> /// <param name="earliestHit">Earliest intersection location and information.</param> /// <param name="hitObject">Collidable intersected by the ray, if any.</param> /// <returns>Whether or not the ray hit anything.</returns> public bool RayCast(Ray ray, float length, out RayHit earliestHit, out Collidable hitObject) { earliestHit = new RayHit(); earliestHit.T = float.MaxValue; hitObject = null; foreach (var collidable in character.Body.CollisionInformation.OverlappedCollidables) { //Check to see if the collidable is hit by the ray. float? t = ray.Intersects(collidable.BoundingBox); if (t != null && t < length) { //Is it an earlier hit than the current earliest? RayHit hit; if (collidable.RayCast(ray, length, SupportRayFilter, out hit) && hit.T < earliestHit.T) { earliestHit = hit; hitObject = collidable; } } } if (earliestHit.T == float.MaxValue) return false; return true; }
/// <summary> /// Handle collision event triggered by entity /// </summary> /// <param name="sender">Entity that had an event hooked</param> /// <param name="other">Entity causing event to be triggered</param> /// <param name="pair">Collision pair between the two objects in the event</param> void HandleCollision(EntityCollidable sender, Collidable other, CollidablePairHandler pair) { var otherEntityInformation = other as EntityCollidable; if (otherEntityInformation != null) { // hit an entity, remove it _space.Remove(otherEntityInformation.Entity); // also remove graphics Components.Remove((EntityModel)otherEntityInformation.Entity.Tag); } }