public Gesture(DateTime timestamp, double magnitude, GestureID id, Joint guestureSource)
 {
     this._timestamp = timestamp;
     this._magnitude = magnitude;
     this._id = id;
     this._guestureSource = guestureSource;
 }

 public KinectSkeleton(Joint ankleLeft, Joint ankleRight, Joint elbowLeft, Joint elbowRight, Joint footLeft, 
                       Joint footRight, Joint handLeft, Joint handRight, Joint head, Joint hipCenter, 
                       Joint hipLeft, Joint hipRight, Joint kneeLeft, Joint kneeRight, Joint shoulderCenter, 
                       Joint shoulderLeft, Joint shoulderRight, Joint spine, Joint wristLeft, Joint wristRight)
 {
     this.ankleLeft = ankleLeft;
     this.ankleRight = ankleRight;
     this.elbowLeft = elbowLeft;
     this.elbowRight = elbowRight;
     this.footLeft = footLeft;
     this.footRight = footRight;
     this.handLeft = handLeft;
     this.handRight = handRight;
     this.head = head;
     this.hipCenter = hipCenter;
     this.hipLeft = hipLeft;
     this.hipRight = hipRight;
     this.kneeLeft = kneeLeft;
     this.kneeRight = kneeRight;
     this.shoulderCenter = shoulderCenter;
     this.shoulderLeft = shoulderLeft;
     this.shoulderRight = shoulderRight;
     this.spine = spine;
     this.wristLeft = wristLeft;
     this.wristRight = wristRight;
 }

 public Direction(Joint i, Joint j)
 {
     createDirection(
         j.Position.X - i.Position.X,
         j.Position.Y - i.Position.Y,
         j.Position.Z - i.Position.Z);
 }

        private void SetUIElementPosition(FrameworkElement element, Joint joint, int yOffset)
        {
            var scaledJoint = joint.ScaleTo(1024, 768, .99f, .99f);

            Canvas.SetLeft(element, scaledJoint.Position.X);
            Canvas.SetTop(element, scaledJoint.Position.Y - yOffset);
        }

        /// <summary>
        /// Process walking/running. Calculates how far forward the right foot
        /// is from the left foot.
        /// </summary>
        /// <param name="rightFoot"></param>
        /// <param name="leftFoot"></param>
        private void detectWalking(Joint rightFoot, Joint leftFoot) {
          
            double feetDifferential = leftFoot.Position.Z - rightFoot.Position.Z;

            // Move forward
            if (feetDifferential > walkThresh)
            {
                if (feetDifferential > runThresh)
                {
                    InputSimulator.SimulateKeyDown(VirtualKeyCode.VK_2);
                }
                else
                {
                    InputSimulator.SimulateKeyDown(VirtualKeyCode.VK_W);
                }

            }
            // Move backward
            else if (feetDifferential < -walkThresh)
            {
                InputSimulator.SimulateKeyDown(VirtualKeyCode.VK_S);
            }
            else
            {
                if (InputSimulator.IsKeyDown(VirtualKeyCode.VK_W)) InputSimulator.SimulateKeyUp(VirtualKeyCode.VK_W);
                if (InputSimulator.IsKeyDown(VirtualKeyCode.VK_S)) InputSimulator.SimulateKeyUp(VirtualKeyCode.VK_S);
                if (InputSimulator.IsKeyDown(VirtualKeyCode.VK_2)) InputSimulator.SimulateKeyUp(VirtualKeyCode.VK_2);
            }
        }

    void SetGrapple(GameObject targ, int grappleType)
    {
        if (targ == null) return;

        if (curTarget != null) FreeGrapple ();

        swinging = true;
        curTarget = targ;
        Rigidbody targRigid = curTarget.GetComponent<Rigidbody> ();
        if (targRigid != null) {

            if (grappleType == 0) {
                HingeJoint target_hinge = targRigid.gameObject.AddComponent <HingeJoint> ();
                target_hinge.connectedBody = rigid;
        //				parentRigid.isKinematic = true;
                target_hinge.autoConfigureConnectedAnchor = false;
                target_hinge.connectedAnchor = targRigid.transform.position;
                hingeTarget = target_hinge;

        //				target_hinge.maxDistance = 50;
        //				target_hinge.minDistance = 45;
            } else if (grappleType == 1) {
                SpringJoint target_spring = targRigid.gameObject.AddComponent <SpringJoint> ();
                target_spring.connectedBody = rigid;
                target_spring.autoConfigureConnectedAnchor = false;
                target_spring.connectedAnchor = targRigid.transform.position;
                target_spring.maxDistance = 50;
                target_spring.minDistance = 5;
                hingeTarget = target_spring;
            }
        }
    }

 public void release()
 {
     Joint oldGrip = grip;
     grip = null;
     Object.Destroy(oldGrip);
     grabee = null;
 }

        public Grammar()
        {
            Options     = RuntimeOptions.Default;

            Productions = new ProductionCollection(this);
            Symbols     = new SymbolCollection(this);
            Conditions  = new ConditionCollection(this);
            Matchers    = new MatcherCollection(this);
            Mergers     = new MergerCollection(this);
            Contexts    = new ForeignContextCollection(this);
            Reports     = new ReportCollection();
            GlobalContextProvider = new ForeignContextProvider { Owner = this.Contexts };
            Joint       = new Joint();

            for (int i = PredefinedTokens.Count; i != 0; --i)
            {
                Symbols.Add(null); // stub
            }

            Symbols[PredefinedTokens.Propagated]      = new Symbol("#");
            Symbols[PredefinedTokens.Epsilon]         = new Symbol("$eps");
            Symbols[PredefinedTokens.AugmentedStart]  = new Symbol("$start");
            Symbols[PredefinedTokens.Eoi]             = new Symbol("$")
                                          {
                                              Categories = SymbolCategory.DoNotInsert
                                                         | SymbolCategory.DoNotDelete
                                          };
            Symbols[PredefinedTokens.Error]           = new Symbol("$error");

            AugmentedProduction = Productions.Define((Symbol)Symbols[PredefinedTokens.AugmentedStart], new Symbol[] { null });
        }

 public void NullCanBeAddedAndHasNoEffect()
 {
     var target = new Joint();
     target.Add(null);
     Assert.IsFalse(target.Has<object>());
     Assert.IsNull(target.Get<object>());
     Assert.Throws<InvalidOperationException>(() => target.The<object>());
 }

 public static Vector3D vectorFromJoint(Joint j)
 {
     Vector3D v = new Vector3D();
     v.X = j.Position.X;
     v.Y = j.Position.Y;
     v.Z = j.Position.Z;
     return v;
 }

 void OnCollisionEnter(Collision col)
 {
     if (col.gameObject.name == "BrickNew (5)")
     {
         theJoint = gameObject.AddComponent<FixedJoint>();
         theJoint.connectedBody = col.rigidbody;
     }
 }

	public new void Awake() {
		base.Awake();

		_path = transform.Find("Path").GetComponent<BoxCollider>();
		_cursor = transform.Find("Path/Cursor").GetComponent<Joint>();

		_slothSnapper = GameObject.FindGameObjectWithTag("SlothNinja").GetComponent<Snapper>();
	}

 // OnCollisionEnter is called when this
 // collider/rigidbody has begun touching
 // another rigidbody/collider.
 void OnCollisionEnter(Collision collision)
 {
     Linkable linkee = collision.gameObject.GetComponent<Linkable>();
     if (linkee != null) {
         joint = this.gameObject.AddComponent<FixedJoint>();
         joint.connectedBody = linkee.gameObject.rigidbody;
     }
 }

    public static List<GameObject> NetworkLink(Vector3 currentPosition, Vector3 finalPosition, Joint hook, Rigidbody anchor, bool gravity)
    {
        List<GameObject> links = new List<GameObject>();

        GameObject link = ResourceFactory.GetInstance().GetPrefab(Registry.Prefab.ChainLink);
        float linkHeight = link.GetComponent<Renderer>().bounds.max.y * 2;

        // Get any vector perpindicular to the direction towards the bird in order to get the Quaternion
        Vector3 direction = finalPosition - currentPosition;
        Vector3 forward = Vector3.RotateTowards(direction, -direction, Mathf.PI/2f, 0);
        Quaternion linkRotation = Quaternion.LookRotation(forward, direction);

        GameObject currentLink = null;
        ConfigurableJoint prevBody = null;
        while(Vector3.Distance(currentPosition, finalPosition) > linkHeight)
        {
            if(uLink.Network.isServer)
            {
                currentLink = uLink.Network.Instantiate(uLink.Network.player, Registry.Prefab.ProxyChainLink, Registry.Prefab.ServerChainLink,
                                                        Registry.Prefab.ServerChainLink, currentPosition, linkRotation, 0);
            }
            else
            {
                currentLink = uLink.Network.Instantiate(uLink.Network.player, Registry.Prefab.ProxyChainLink, Registry.Prefab.ServerChainLink,
                                                        Registry.Prefab.ProxyChainLink, currentPosition, linkRotation, 0);
            }
            currentLink.transform.parent = hook.transform;

            currentPosition += currentLink.transform.up * linkHeight;

            links.Add(currentLink);

            Rigidbody currentBody = currentLink.GetComponent<Rigidbody>();
            currentBody.useGravity = gravity;
            if(hook.connectedBody == null)
            {
                hook.connectedBody = currentBody;
            }
            else
            {
                ConnectJoint(prevBody, currentBody);
            }
            prevBody = currentLink.GetComponent<ConfigurableJoint>();
        }

        if(anchor != null)
        {
            ConnectJoint(currentLink.GetComponent<ConfigurableJoint>(), anchor);
        }
        else
        {
            currentLink.GetComponent<ConfigurableJoint>().connectedAnchor = finalPosition;
        }
        currentLink.GetComponent<ConfigurableJoint>().autoConfigureConnectedAnchor = true;

        return links;
    }

 /*
      Constructor: Plane
      Initializes x,y,z.
 */
 public Plane(Joint a, Joint b, Joint c)
 {
     Direction d1 = new Direction(a, b);
     Direction d2 = new Direction(a, c);
     Direction per = Mathematics.crossProduct(d1, d2);
     x = per.x;
     y = per.y;
     z = per.z;
 }

        /**********************************la fonction du skeletons*************************************************************/

        private Point getDisplayPosition(Joint joint)
        {
            float depthX, depthY;
            _nui.SkeletonEngine.SkeletonToDepthImage(joint.Position, out depthX, out depthY);
            depthX = Math.Max(0, Math.Min(depthX * 320, 320));
            depthY = Math.Max(0, Math.Min(depthY * 240, 240));
            int colorX, colorY;
            ImageViewArea iv = new ImageViewArea();
            _nui.NuiCamera.GetColorPixelCoordinatesFromDepthPixel(ImageResolution.Resolution640x480, iv, (int)depthX, (int)depthY, (short)0, out colorX, out colorY);
            return new Point((int)(skeleton.Width * colorX / 640.0), (int)(skeleton.Height * colorY / 480));
        }

 public void SayGoodbye(Joint joint)
 {
     if (test._mouseJoint == joint)
     {
         test._mouseJoint = null;
     }
     else
     {
         test.JointDestroyed(joint);
     }
 }

	/// <summary>
	/// Grip a rigidbody with a hand
	/// </summary>
	/// <param name="target">Target rigidbody</param>
	/// <param name="hand">Which hand to grip with, "left" or "right"</param>
	public void Grip(Joint target, string hand) {
		_ragdoller.ragdolled = true;
        IsGripped = true;


        if (hand == "left") {
			target.connectedBody = this._leftHand;
		} else {
			target.connectedBody = this._rightHand;
		}
	}

        private void compute(Joint shoulder, Joint elbow, Joint wrist)
        {
            Vector3D shoulderVec = Util.vectorFromJoint(shoulder);
            Vector3D elbowVec = Util.vectorFromJoint(elbow);
            Vector3D wristVec = Util.vectorFromJoint(wrist);

            Vector3D elbowToShoulder = shoulderVec - elbowVec;
            Vector3D elbowToWrist = wristVec - elbowVec;

            Yaw = Util.degToRad(Vector3D.AngleBetween(elbowToWrist, elbowToShoulder));
        }

        public void Flip(Joint activeHand)
        {
            double scaleX = activeHand.JointType == JointType.HandRight ? 1.0 : -1.0;

            ScaleTransform transform = root.RenderTransform as ScaleTransform;

            if (transform.ScaleX != scaleX)
            {
                transform.ScaleX = scaleX;
            }
        }