public static void GetShapeMeshData(EntityCollidable collidable, List<VertexPositionNormalTexture> vertices, List<ushort> indices)
        {
            var compoundCollidable = collidable as CompoundCollidable;
            if (compoundCollidable == null)
                throw new ArgumentException("Wrong shape type.");
            var tempIndices = new List<ushort>();
            var tempVertices = new List<VertexPositionNormalTexture>();
            for (int i = 0; i < compoundCollidable.Children.Count; i++)
            {
                var child = compoundCollidable.Children[i];
                ModelDrawer.ShapeMeshGetter shapeMeshGetter;
                if (ModelDrawer.ShapeMeshGetters.TryGetValue(child.CollisionInformation.GetType(), out shapeMeshGetter))
                {
                    shapeMeshGetter(child.CollisionInformation, tempVertices, tempIndices);

                    for (int j = 0; j < tempIndices.Count; j++)
                    {
                        indices.Add((ushort)(tempIndices[j] + vertices.Count));
                    }
                    RigidTransform localTransform = child.Entry.LocalTransform;
                    Vector3 localPosition = child.CollisionInformation.LocalPosition;
                    for (int j = 0; j < tempVertices.Count; j++)
                    {
                        VertexPositionNormalTexture vertex = tempVertices[j];
                        Vector3.Add(ref vertex.Position, ref localPosition, out vertex.Position);
                        RigidTransform.Transform(ref vertex.Position, ref localTransform, out vertex.Position);
                        Vector3.Transform(ref vertex.Normal, ref localTransform.Orientation, out vertex.Normal);
                        vertices.Add(vertex);
                    }

                    tempVertices.Clear();
                    tempIndices.Clear();
                }
            }
        }
Beispiel #2
0
        public static void GetShapeMeshData(EntityCollidable collidable, List<VertexPositionNormalTexture> vertices, List<ushort> indices)
        {
            var convexHullShape = collidable.Shape as ConvexHullShape;
            if (convexHullShape == null)
                throw new ArgumentException("Wrong shape type.");

            var hullTriangleVertices = new List<Vector3>();
            var hullTriangleIndices = new List<int>();
            Toolbox.GetConvexHull(convexHullShape.Vertices, hullTriangleIndices, hullTriangleVertices);
            //The hull triangle vertices are used as a dummy to get the unnecessary hull vertices, which are cleared afterwards.
            hullTriangleVertices.Clear();
            foreach (int i in hullTriangleIndices)
            {
                hullTriangleVertices.Add(convexHullShape.Vertices[i]);
            }

            var toReturn = new VertexPositionNormalTexture[hullTriangleVertices.Count];
            Vector3 normal;
            for (ushort i = 0; i < hullTriangleVertices.Count; i += 3)
            {
                normal = Vector3.Normalize(Vector3.Cross(hullTriangleVertices[i + 2] - hullTriangleVertices[i], hullTriangleVertices[i + 1] - hullTriangleVertices[i]));
                vertices.Add(new VertexPositionNormalTexture(hullTriangleVertices[i], normal, new Vector2(0, 0)));
                vertices.Add(new VertexPositionNormalTexture(hullTriangleVertices[i + 1], normal, new Vector2(1, 0)));
                vertices.Add(new VertexPositionNormalTexture(hullTriangleVertices[i + 2], normal, new Vector2(0, 1)));
                indices.Add(i);
                indices.Add((ushort)(i + 1));
                indices.Add((ushort)(i + 2));
            }
        }
        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 { }*/
        }
Beispiel #5
0
        void HandleCollision(EntityCollidable sender, Collidable other, CollidablePairHandler pair)
        {
            if (soundEffect != null)
            {
                emitter.Position = body.Position / 5.0f;

            }
        }
Beispiel #6
0
 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();
     }
 }
Beispiel #7
0
 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;
     }
 }
        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();
        }
        public static void GetShapeMeshData(EntityCollidable collidable, List<VertexPositionNormalTexture> vertices, List<ushort> indices)
        {
            var minkowskiShape = collidable.Shape as MinkowskiSumShape;
            if (minkowskiShape == null)
                throw new ArgumentException("Wrong shape type.");

            var points = new List<Vector3>();
            Vector3 max;
            var direction = new Vector3();
            float angleChange = MathHelper.TwoPi / NumSamples;

            for (int i = 1; i < NumSamples / 2 - 1; i++)
            {
                float phi = MathHelper.PiOver2 - i * angleChange;
                var sinPhi = (float)Math.Sin(phi);
                var cosPhi = (float)Math.Cos(phi);
                for (int j = 0; j < NumSamples; j++)
                {
                    float theta = j * angleChange;
                    direction.X = (float)Math.Cos(theta) * cosPhi;
                    direction.Y = sinPhi;
                    direction.Z = (float)Math.Sin(theta) * cosPhi;

                    minkowskiShape.GetLocalExtremePoint(direction, out max);
                    points.Add(max);
                }
            }

            minkowskiShape.GetLocalExtremePoint(Toolbox.UpVector, out max);
            points.Add(max);
            minkowskiShape.GetLocalExtremePoint(Toolbox.DownVector, out max);
            points.Add(max);


            var hullTriangleVertices = new List<Vector3>();
            var hullTriangleIndices = new List<int>();
            Toolbox.GetConvexHull(points, hullTriangleIndices, hullTriangleVertices);
            //The hull triangle vertices are used as a dummy to get the unnecessary hull vertices, which are cleared afterwards.
            hullTriangleVertices.Clear();
            foreach (int i in hullTriangleIndices)
            {
                hullTriangleVertices.Add(points[i]);
            }

            Vector3 normal;
            for (ushort i = 0; i < hullTriangleVertices.Count; i += 3)
            {
                normal = Vector3.Normalize(Vector3.Cross(hullTriangleVertices[i + 2] - hullTriangleVertices[i], hullTriangleVertices[i + 1] - hullTriangleVertices[i]));
                vertices.Add(new VertexPositionNormalTexture(hullTriangleVertices[i], normal, new Vector2(0, 0)));
                vertices.Add(new VertexPositionNormalTexture(hullTriangleVertices[i + 1], normal, new Vector2(1, 0)));
                vertices.Add(new VertexPositionNormalTexture(hullTriangleVertices[i + 2], normal, new Vector2(0, 1)));
                indices.Add(i);
                indices.Add((ushort)(i + 1));
                indices.Add((ushort)(i + 2));
            }
        }
Beispiel #10
0
 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();
         }
     }
 }
Beispiel #11
0
 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();
         }
     }
 }
        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();

            }
        }
Beispiel #13
0
 //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++;
     }
 }
Beispiel #14
0
        public override void InitialCollisionDetected(EntityCollidable sender, Collidable other, CollidablePairHandler collisionPair)
        {
            base.InitialCollisionDetected(sender, other, collisionPair);

            //Console.WriteLine(other.Tag + " " + mRunTimer);
            if ((other.Tag is CharacterSynchronizer || other.Tag is PhysicsProp) && mRunTimer > 0.0f)
            {
                float totalImpulse = 0;
                foreach (ContactInformation c in collisionPair.Contacts)
                {
                    totalImpulse += c.NormalImpulse;
                }

                //Console.WriteLine(totalImpulse);

                int damage = 0;
                if (totalImpulse > 150.0f)
                {
                    damage = 2;
                }
                else if (totalImpulse > 45.0f)
                {
                    damage = 1;
                }

                Entity hitEntity;
                if (other.Tag is CharacterSynchronizer)
                {
                    hitEntity = (other.Tag as CharacterSynchronizer).body;
                }
                else
                {
                    hitEntity = (other.Tag as PhysicsProp).Entity;
                }

                Vector3 impulseVector = Vector3.Zero;
                Vector3 impulseDirection = hitEntity.Position - Creature.Position;
                if (impulseDirection != Vector3.Zero)
                {
                    impulseVector = Vector3.Normalize(impulseDirection);
                }

                impulseVector.Y = 0.45f;
                impulseVector.Normalize();
                impulseVector *= damage * DamageImpulseMultiplier;
                hitEntity.ApplyLinearImpulse(ref impulseVector);

                if (other.Tag is CharacterSynchronizer)
                {
                    ((other.Tag as CharacterSynchronizer).body.Tag as Creature).Damage(damage, Creature);
                    ((other.Tag as CharacterSynchronizer).body.Tag as Creature).AllowImpulse();
                }
            }
        }
        /// <summary>
        /// Constructs the query manager for a character.
        /// </summary>
        /// <param name="character">Character to manage queries for.</param>
        public QueryManager(SphereCharacterController character)
        {
            this.character = character;
            //We can share the real shape with the 'current' query object.
            queryObject = new ConvexCollidable<SphereShape>(character.Body.CollisionInformation.Shape);
            //Share the collision rules between the main body and its query objects.  That way, the character's queries return valid results.
            queryObject.CollisionRules = character.Body.CollisionInformation.CollisionRules;


            SupportRayFilter = SupportRayFilterFunction;
        }
Beispiel #16
0
        /// <summary>
        /// Constructs the query manager for a character.
        /// </summary>
        /// <param name="character">Character to manage queries for.</param>
        public QueryManager(CharacterController character)
        {
            this.character = character;
            //We can share the real shape with the 'current' query object.
            currentQueryObject = new ConvexCollidable<CylinderShape>(character.Body.CollisionInformation.Shape);
            standingQueryObject = new ConvexCollidable<CylinderShape>(new CylinderShape(character.StanceManager.StandingHeight, character.Body.Radius));
            crouchingQueryObject = new ConvexCollidable<CylinderShape>(new CylinderShape(character.StanceManager.CrouchingHeight, character.Body.Radius));
            //Share the collision rules between the main body and its query objects.  That way, the character's queries return valid results.
            currentQueryObject.CollisionRules = character.Body.CollisionInformation.CollisionRules;
            standingQueryObject.CollisionRules = character.Body.CollisionInformation.CollisionRules;
            crouchingQueryObject.CollisionRules = character.Body.CollisionInformation.CollisionRules;

            SupportRayFilter = SupportRayFilterFunction;
        }
Beispiel #17
0
        public static void GetShapeMeshData(EntityCollidable collidable, List<VertexPositionNormalTexture> vertices, List<ushort> indices)
        {
            ConeShape coneShape = collidable.Shape as ConeShape;
            if (coneShape == null)
                throw new ArgumentException("Wrong shape type.");

            float verticalOffset = -coneShape.Height / 4;
            float angleBetweenFacets = MathHelper.TwoPi / NumSides;
            float radius = coneShape.Radius;

            //Create the vertex list

            var topVertexPosition = new Vector3(0, coneShape.Height + verticalOffset, 0);

            for (int i = 0; i < NumSides; i++)
            {
                float theta = i * angleBetweenFacets;
                var position = new Vector3((float)Math.Cos(theta) * radius, verticalOffset, (float)Math.Sin(theta) * radius);
                Vector3 offset = topVertexPosition - position;
                Vector3 normal = Vector3.Normalize(Vector3.Cross(Vector3.Cross(offset, Vector3.Up), offset));
                //Top vertex
                vertices.Add(new VertexPositionNormalTexture(topVertexPosition, normal, Vector2.Zero));
                //Sloped vertices
                vertices.Add(new VertexPositionNormalTexture(position, normal, Vector2.Zero));
                //Bottom vertices
                vertices.Add(new VertexPositionNormalTexture(position, Vector3.Down, Vector2.Zero));
            }


            //Create the index list
            for (ushort i = 0; i < vertices.Count; i += 3)
            {
                //Each iteration, the loop advances to the next vertex 'column.'
                //Four triangles per column (except for the four degenerate cap triangles).

                //Sloped Triangles
                indices.Add(i);
                indices.Add((ushort)(i + 1));
                indices.Add((ushort)((i + 4) % vertices.Count));

                //Bottom cap triangles.
                var nextIndex = (ushort)((i + 5) % vertices.Count);
                if (nextIndex != 2) //Don't add cap indices if it's going to be a degenerate triangle.
                {
                    indices.Add((ushort)(i + 2));
                    indices.Add(2);
                    indices.Add(nextIndex);
                }
            }
        }
Beispiel #18
0
 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();
     }
 }
 protected void TryToAdd(EntityCollidable collidable)
 {
     CollisionRule rule;
     if ((rule = CollisionRules.collisionRuleCalculator(DetectorVolume, collidable)) < CollisionRule.NoNarrowPhasePair)
     {
         //Clamp the rule to the parent's rule.  Always use the more restrictive option.
         //Don't have to test for NoNarrowPhasePair rule on the parent's rule because then the parent wouldn't exist!
         if (rule < CollisionRule)
             rule = CollisionRule;
         if (!subPairs.ContainsKey(collidable))
         {
             var newPair = NarrowPhaseHelper.GetPairHandler(DetectorVolume, collidable, rule) as DetectorVolumePairHandler;
             if (newPair != null)
             {
                 newPair.Parent = this;
                 subPairs.Add(collidable, newPair);
             }
         }
         containedPairs.Add(collidable);
     }
 }
Beispiel #20
0
        public static void GetShapeMeshData(EntityCollidable collidable, List<VertexPositionNormalTexture> vertices, List<ushort> indices)
        {
            var triangleShape = collidable.Shape as TriangleShape;
            if(triangleShape == null)
                throw new ArgumentException("Wrong shape type.");
            Vector3 normal = triangleShape.GetLocalNormal();
            vertices.Add(new VertexPositionNormalTexture(triangleShape.VertexA, -normal, new Vector2(0, 0)));
            vertices.Add(new VertexPositionNormalTexture(triangleShape.VertexB, -normal, new Vector2(0, 1)));
            vertices.Add(new VertexPositionNormalTexture(triangleShape.VertexC, -normal, new Vector2(1, 0)));

            vertices.Add(new VertexPositionNormalTexture(triangleShape.VertexA, normal, new Vector2(0, 0)));
            vertices.Add(new VertexPositionNormalTexture(triangleShape.VertexB, normal, new Vector2(0, 1)));
            vertices.Add(new VertexPositionNormalTexture(triangleShape.VertexC, normal, new Vector2(1, 0)));

            indices.Add(0);
            indices.Add(1);
            indices.Add(2);

            indices.Add(3);
            indices.Add(5);
            indices.Add(4);
        }
Beispiel #21
0
 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 { }
 }
Beispiel #22
0
 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();
     }
 }
Beispiel #23
0
 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));
                 }
             }
         }
     }
 }
Beispiel #24
0
        public static void GetShapeMeshData(EntityCollidable collidable, List<VertexPositionNormalTexture> vertices, List<ushort> indices)
        {
            MobileMeshShape shape = collidable.Shape as MobileMeshShape;
            var tempVertices = new VertexPositionNormalTexture[shape.TriangleMesh.Data.Vertices.Length];
            for (int i = 0; i < shape.TriangleMesh.Data.Vertices.Length; i++)
            {
                Vector3 position;
                shape.TriangleMesh.Data.GetVertexPosition(i, out position);
                tempVertices[i] = new VertexPositionNormalTexture(
                    position,
                    Vector3.Zero,
                    Vector2.Zero);
            }

            for (int i = 0; i < shape.TriangleMesh.Data.Indices.Length; i++)
            {
                indices.Add((ushort)shape.TriangleMesh.Data.Indices[i]);
            }
            for (int i = 0; i < indices.Count; i += 3)
            {
                int a = indices[i];
                int b = indices[i + 1];
                int c = indices[i + 2];
                Vector3 normal = Vector3.Normalize(Vector3.Cross(
                    tempVertices[c].Position - tempVertices[a].Position,
                    tempVertices[b].Position - tempVertices[a].Position));
                tempVertices[a].Normal += normal;
                tempVertices[b].Normal += normal;
                tempVertices[c].Normal += normal;
            }

            for (int i = 0; i < tempVertices.Length; i++)
            {
                tempVertices[i].Normal.Normalize();
                vertices.Add(tempVertices[i]);
            }
        }
Beispiel #25
0
 ///<summary>
 /// Constructs a new morphable entity.
 ///</summary>
 ///<param name="collisionInformation">Collidable to use with the entity.</param>
 ///<param name="mass">Mass of the entity.</param>
 /// <param name="inertiaTensor">Inertia tensor of the entity.</param>
 /// <param name="volume">Volume of the entity.</param>
 public MorphableEntity(EntityCollidable collisionInformation, float mass, Matrix3X3 inertiaTensor, float volume)
     : base(collisionInformation, mass, inertiaTensor, volume)
 {
 }
Beispiel #26
0
 ///<summary>
 /// Constructs a new morphable entity.
 ///</summary>
 ///<param name="collisionInformation">Collidable to use with the entity.</param>
 ///<param name="mass">Mass of the entity.</param>
 public MorphableEntity(EntityCollidable collisionInformation, float mass)
     : base(collisionInformation, mass)
 {
 }
Beispiel #27
0
 ///<summary>
 /// Constructs a new morphable entity.
 ///</summary>
 ///<param name="collisionInformation">Collidable to use with the entity.</param>
 public MorphableEntity(EntityCollidable collisionInformation)
     : base(collisionInformation)
 {
 }
Beispiel #28
0
        /// <summary>
        /// Sets the collision information of the entity to another collidable.
        /// </summary>
        /// <param name="newCollisionInformation">New collidable to use.</param>
        /// <param name="newMass">New mass to use for the entity.</param>
        /// <param name="newInertia">New inertia tensor to use for the entity.</param>
        public void SetCollisionInformation(EntityCollidable newCollisionInformation, float newMass, Matrix3X3 newInertia)
        {
            //Temporarily remove the object from the space.  
            //The reset process will update any systems that need to be updated.
            //This is not thread safe, but this operation should not be performed mid-frame anyway.
            ISpace space = Space;
            if (space != null)
                Space.Remove(this);

            CollisionInformation.Entity = null;

            Initialize(newCollisionInformation, newMass, newInertia);

            if (space != null)
                space.Add(this);
        }
Beispiel #29
0
        void QueryContacts(Vector3 position, EntityCollidable queryObject)
        {
            ClearContacts();

            //Update the position and orientation of the query object.
            RigidTransform transform;
            transform.Position = position;
            transform.Orientation = character.Body.Orientation;
            queryObject.UpdateBoundingBoxForTransform(ref transform, 0);

            foreach (var collidable in character.Body.CollisionInformation.OverlappedCollidables)
            {
                if (collidable.BoundingBox.Intersects(queryObject.BoundingBox))
                {
                    var pair = new CollidablePair(collidable, queryObject);
                    var pairHandler = NarrowPhaseHelper.GetPairHandler(ref pair);
                    if (pairHandler.CollisionRule == CollisionRule.Normal)
                    {
                        pairHandler.UpdateCollision(0);
                        foreach (var contact in pairHandler.Contacts)
                        {
                            //Must check per-contact collision rules, just in case
                            //the pair was actually a 'parent pair.'
                            if (contact.Pair.CollisionRule == CollisionRule.Normal)
                            {
                                ContactData contactData;
                                contactData.Position = contact.Contact.Position;
                                contactData.Normal = contact.Contact.Normal;
                                contactData.Id = contact.Contact.Id;
                                contactData.PenetrationDepth = contact.Contact.PenetrationDepth;
                                contacts.Add(contactData);
                            }
                        }
                    }
                    //TODO: It would be nice if this was a bit easier.
                    //Having to remember to clean up AND give it back is a bit weird, especially with the property-diving.
                    //No one would ever just guess this correctly.
                    //At least hide it behind a NarrowPhaseHelper function.
                    pairHandler.CleanUp();
                    pairHandler.Factory.GiveBack(pairHandler);
                }
            }

            CategorizeContacts(ref position);
        }
        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;
        }