BEPUphysics

Code: Select all

private void Events_InitialCollisionDetected(EntityCollisionInformation info, CollisionEntry entry, INarrowPhasePair pair)
{

}

Code: Select all

            CollisionInformationPairHandler p = pair as CollisionInformationPairHandler;

            List<Contact> contacts = new List<Contact>();
            p.GetContacts(contacts);

Code: Select all

    public class CharacterControllerInput
    {
        private Camera camera;                              // Current camera being controlled
        //private CharacterController characterController;    // Physics representation of the character
        private SimpleCharacterController characterController;

        /// <summary>
        /// Current offset from the position of the character to the 'eyes'
        /// </summary>
        public Vector3 CameraOffset = new Vector3();

        /// <summary>
        /// Whether or not to use the character controller's input
        /// </summary>
        public bool IsActive = true;

        private Game1 game;

        /// <summary>
        /// Constructs the character and internal physics character controller.
        /// </summary>
        /// <param name="owningSpace">Space to add the character to.</param>
        /// <param name="cameraToUse">Camera to attach to the character.</param>
        public CharacterControllerInput(Game1 game, Camera cameraToUse)
        {
            this.game = game;

            camera = cameraToUse;
            //characterController = new CharacterController(Vector3.Zero, 3, 1, 20f, 1.4f, .01f, .04f);
            characterController = new SimpleCharacterController(Vector3.Zero, 3, 1, 1.4f, 100f);

            game.Space.Add(characterController);

            Deactivate();
        }

        /// <summary>
        /// Gives the character control over the camera and movement input.
        /// </summary>
        public void Activate()
        {
            if (!IsActive)
            {
                IsActive = true;
                camera.IsIgnoreInput = true;
                characterController.Activate();
                //characterController.Body.TeleportTo(camera.Position);
                characterController.Body.Position = camera.Position;
            }
        }

        /// <summary>
        /// Returns input control to the camera.
        /// </summary>
        public void Deactivate()
        {
            if (IsActive)
            {
                IsActive = false;
                camera.IsIgnoreInput = false;
                characterController.Deactivate();
            }
        }

        /// <summary>
        /// Handles the input and movement of the character.
        /// </summary>
        /// <param name="dt">Time since last frame in simulation seconds.</param>
        /// <param name="previousKeyboardInput">The last frame's keyboard state.</param>
        /// <param name="keyboardInput">The current frame's keyboard state.</param>
        /// <param name="previousGamePadInput">The last frame's gamepad state.</param>
        /// <param name="gamePadInput">The current frame's keyboard state.</param>
        public void Update(GameTime gameTime)
        {
            if (IsActive)
            {
                float dt = (float)gameTime.ElapsedGameTime.TotalSeconds;

                // Note that the character controller's update method is not called here; this is because it is handled within its owning space.
                // This method's job is simply to tell the character to move around based on the camera and input.

                // Puts the camera at eye level
                //camera.Position = characterController.Body.CenterPosition + CameraOffset;
                camera.Position = characterController.Body.Position + CameraOffset;
                Vector2 totalMovement = new Vector2();

                Vector3 forward = camera.Forward;
                forward.Y = 0;
                forward.Normalize();
                Vector3 right = camera.Right;

                totalMovement += game.HID.LeftY(PlayerIndex.One) * new Vector2(forward.X, forward.Z);
                totalMovement += game.HID.LeftX(PlayerIndex.One) * new Vector2(right.X, right.Z);
                characterController.MovementDirection = totalMovement;

                // Jumping
                if (game.HID.IsButtonHit(PlayerIndex.One, Buttons.A))
                {
                    characterController.Jump();
                }

                Vector3 movementDir;

                //Collect the movement impulses.
                if (game.HID.IsKeyDown(PlayerIndex.One, Keys.W))
                {
                    movementDir = camera.Forward;
                    totalMovement += Vector2.Normalize(new Vector2(movementDir.X, movementDir.Z));
                }
                if (game.HID.IsKeyDown(PlayerIndex.One, Keys.S))
                {
                    movementDir = -camera.Forward;
                    totalMovement += Vector2.Normalize(new Vector2(movementDir.X, movementDir.Z));
                }
                if (game.HID.IsKeyDown(PlayerIndex.One, Keys.A))
                {
                    movementDir = -camera.Right;
                    totalMovement += Vector2.Normalize(new Vector2(movementDir.X, movementDir.Z));
                }
                if (game.HID.IsKeyDown(PlayerIndex.One, Keys.D))
                {
                    movementDir = camera.Right;
                    totalMovement += Vector2.Normalize(new Vector2(movementDir.X, movementDir.Z));
                }
                if (totalMovement.X == 0 & totalMovement.Y == 0)
                    characterController.MovementDirection = totalMovement;
                else
                    characterController.MovementDirection = Vector2.Normalize(totalMovement);

                // Jumping
                if (game.HID.IsMouseButtonHit(MouseButtons.Right))
                {
                    characterController.Jump();
                }

                // Shooting
                if (game.HID.IsMouseButtonHit(MouseButtons.Left))
                {
                    //characterController.Jump();
                }
            }
        }

        /// <summary>
        /// Camera to use for input
        /// </summary>
        public Camera Camera
        {
            get { return camera; }
            set
            {
                camera.IsIgnoreInput = false;
                camera = value;
            }
        }

Code: Select all

            CollisionRules.AddRule(collisionPairCollector, Body, CollisionRule.NoBroadPhase);//Prevents the creation of any collision pairs between the body and the collector.