private void RaiseHandStateChanged(KinectBody body, HandType handType, HandState previousState)
 {
     if (this.HandStateChanged != null)
     {
         this.HandStateChanged(this, new KinectHandStateEventArgs(body, handType, previousState));
     }
 }

 public structRectangle() {
     rect = new Rectangle();
     beginTime = new TimeSpan();
     handState = new HandState();
     position = "";
     gestureTried = false;
 }

        public void Update(TrackingConfidence leftConfidence, HandState leftHand, TrackingConfidence rightConfidence, HandState rightHand)
        {
            if ( leftConfidence == TrackingConfidence.High && leftHand == HandState.Closed )
            {
                if (!this.HasLeftHandWeapon)
                {
                    this.LeftHandWeaponIndex = this.selectRandomWeapon();
                    this.HasLeftHandWeapon = true;
                }
            }
            else
            {
                this.HasLeftHandWeapon = false;
                this.LeftHandWeaponIndex = -1;
            }

            if (rightConfidence == TrackingConfidence.High && rightHand == HandState.Closed)
            {
                if (!this.HasRightHandWeapon)
                {
                    this.RightHandWeaponIndex = this.selectRandomWeapon();
                    this.HasRightHandWeapon = true;
                }
            }
            else
            {
                this.HasRightHandWeapon = false;
                this.RightHandWeaponIndex = -1;
            }
        }

				void Awake ()
				{	
						handState = HandState.NoAction;
						
						leapManager = (GameObject.Find ("LeapManager") as GameObject).GetComponent (typeof(LeapManager)) as LeapManager;
						cueStickController = (GameObject.Find ("CueStickTip") as GameObject).GetComponent (typeof(CueStickController)) as CueStickController;

						leapManager.leapController.EnableGesture (Gesture.GestureType.TYPE_SWIPE);
						leapManager.leapController.Config.SetFloat ("Gesture.Swipe.MinLength", 200.0f);
						leapManager.leapController.Config.SetFloat ("Gesture.Swipe.MinVelocity", 750f);
						leapManager.leapController.Config.Save ();

						gameStates.Add (GameState.CameraAutoAdjust);
						gameStates.Add (GameState.CameraManualAdjust);
						gameStates.Add (GameState.Aiming);
						gameStates.Add (GameState.AfterShot);
						gameStates.Add (GameState.TurnEnd);

						

						viewAdjustmentStateIcon = (GameObject.Find ("ViewAdjustmentStateIcon") as GameObject).GetComponent (typeof(RawImage)) as RawImage; 
						aimingStateIcon = (GameObject.Find ("AimingStateIcon") as GameObject).GetComponent (typeof(RawImage)) as RawImage; 
						swipeActionIcon = (GameObject.Find ("SwipeActionIcon") as GameObject).GetComponent (typeof(RawImage)) as RawImage;

						playerTurn = (GameObject.Find ("PlayerTurn") as GameObject).GetComponent (typeof(Text)) as Text; 
						cueBall = GameObject.FindGameObjectWithTag ("cueBall");

						cueBall = GameObject.FindGameObjectWithTag ("cueBall");
						camera = GameObject.FindGameObjectWithTag ("PlayerCamera");
						ballsParent = GameObject.FindGameObjectWithTag ("balls");
						foreach (Transform ball in ballsParent.transform) {
								balls.Add (ball.gameObject);				
						}
				}

        /// <summary>
        /// Initializes a new instance of the <see cref="CustomBody"/> class.
        /// </summary>
        public CustomBody()
        {
            _clippedEdges = FrameEdges.None;

            _handLeftConfidence = TrackingConfidence.Low;
            _handLeftState = HandState.Unknown;
            _handRightConfidence = TrackingConfidence.Low;
            _handRightState = HandState.Unknown;
            _isDisposed = false;
            _isRestricted = false;
            _isTracked = false;

            _joints = new Dictionary<JointType, IJoint>();
            _jointOrientations = new Dictionary<JointType, IJointOrientation>();
            foreach (var jointType in CustomJointType.AllJoints)
            {
                _joints.Add(jointType, new CustomJoint(jointType));
                _jointOrientations.Add(jointType, new CustomJointOrientation(jointType));
            }

            _lean = new PointF();

            _leanTrackingState = TrackingState.NotTracked;
            _trackingId = ulong.MaxValue;
            _hasMappedDepthPositions = false;
            _hasMappedColorPositions = false;
        }

 public HandSliderControl(HandDetectionType handDetectionType, HandState requirredHandState,
     Directions direction, CoordinateMapper mapper)
     : base(handDetectionType, requirredHandState)
 {
     SmoothLevel = 0;
     Direction = direction;
     _mapper = mapper;
 }

 public RangeTrigger(string name, HandState<int> state)
     : base(name)
 {
     Hand = state.Hand;
     state.ValueChanged += OnStateValueChanged;
     ResistanceTime = 1000000;
     StickinessTime = 1000000;
 }

 public HandOverHeadDetector(HandDetectionType handDetectionType, HandState state, int framesToRegister = 10,
     double headOffset = 0, bool headOffsetAutomatic = true)
     : base(handDetectionType, state)
 {
     FramesToRegister = framesToRegister;
     HeadOffset = headOffset;
     HeadOffsetAutomatic = headOffsetAutomatic;
 }

        /// <summary>
        /// Constructor
        /// </summary>
        /// <param name="body">Kinect body</param>
        /// <param name="handType">Hand type</param>
        /// <param name="previousHandState">Previous hand state</param>
        public KinectHandStateEventArgs(KinectBody body, HandType handType, HandState previousHandState)
        {
            if (body == null)
                throw new ArgumentNullException("body");

            this.body = body;
            this.handType = handType;
            this.previousHandState = previousHandState;
        }

 public TrackerArgs(Body body, HandState left, HandState right, int yaw, int pitch, int roll)
 {
     this.body = body;
     LeftState = left;
     RightState = right;
     Yaw = yaw;
     Pitch = pitch;
     Roll = roll;
 }

 public void getTrackerInfo(out Body body, out HandState left, out HandState right, out int yaw, out int pitch,
     out int roll)
 {
     body = eTracker.Engager;
     left = eTracker.LeftState;
     right = eTracker.RightState;
     yaw = eTracker.Yaw;
     pitch = eTracker.Pitch;
     roll = eTracker.Roll;
 }

 public Person(int id)
 {
     this.id = id;
     this.instance = Send.getInstance ();
     if (instance == null) {
         Console.WriteLine ("Die Instanz ist null");
     }
     leftHandState = HandState.NotTracked;
     rightHandState = HandState.NotTracked;
     message = new string[2];
 }

 public void Add(HandState aNext)
 {
     if (State == aNext)
     {
         Count++;
     }
     else
     {
         State = aNext;
         Count = 1;
     }
 }

 public Cursor()
 {
     //
     deltaPosition = Vector2.zero;
     //
     deltaTime = 0;
     personId = 0;
     leftHand = false;
     rightHand = false;
     cursorId = -1;
     handState = HandState.Open;
     position = Vector2.zero;
 }

 //constructors
 public HandleObject()
 {
     pos = new Point(200, 200);
     vel = new Point(0, 0);
     this.radius = 20;
     inactiveBrush = Brushes.Red;
     activeBrush = Brushes.Green;
     pen = new Pen();
     prevHandState = HandState.Unknown;
     isLeftHandOnObject = false;
     isRightHandOnObject = false;
     isBoundToHand = false;
     currentBrush = inactiveBrush;
     maxRadiusFactor = 1.5;
     minRadiusFactor = 0.75;
 }

        private void DrawHand(HandState handState, Point handPosition)
        {
            switch (handState)
            {
                case HandState.Closed:
                    drawingContext.DrawEllipse(this.handClosedBrush, null, handPosition, HandSize, HandSize);
                    break;

                case HandState.Open:
                    drawingContext.DrawEllipse(this.handOpenBrush, null, handPosition, HandSize, HandSize);
                    break;

                case HandState.Lasso:
                    drawingContext.DrawEllipse(this.handLassoBrush, null, handPosition, HandSize, HandSize);
                    break;
            }
        }

 public static KinectBodyInternal BodyWithRightHandState(ulong id, TrackingConfidence confidence, HandState state)
 {
     var result = new KinectBodyInternal()
     {
         ClippedEdges = FrameEdges.None,
         HandLeftConfidence = TrackingConfidence.High,
         HandLeftState = HandState.NotTracked,
         HandRightConfidence = confidence,
         HandRightState = state,
         IsRestricted = false,
         IsTracked = true,
         JointOrientations = new JointOrientation[Microsoft.Kinect.Body.JointCount],
         Joints = FakeJoints.ValidRandomJoints(),
         LeanTrackingState = TrackingState.NotTracked,
         TrackingId = id
     };
     return result;
 }

	// Use this for initialization
	void Start () {
        spells.Add(new VoidSpear(this.transform.position));

        leftHandState = HandState.idle;
        rightHandState = HandState.idle;

        chargeProgressIndicator = ChargeIndicator.GetComponent<ProgressBar>();
        chargeProgressIndicator.Min = 0;
        chargeProgressIndicator.Max = 100;
        chargeProgressIndicator.Value = 0;
        chargeProgressIndicator.DecimalPlaces = 0;
        chargeProgressIndicator.valueType = ProgressBar.ValueType.Percentage;

        cooldownProgressIndicator = CooldownIndicator.GetComponent<ProgressBar>();
        cooldownProgressIndicator.Value = 0;
        cooldownProgressIndicator.DecimalPlaces = 1;
        cooldownProgressIndicator.valueType = ProgressBar.ValueType.Float;
        cooldownProgressIndicator.color = Color.red;
	}

 public Person(string ID, Point3D location, string gesture, trackingStates trackState,Joint leftHand, Joint rightHand, HandState leftHandState, HandState rightHandState, TrackingConfidence leftHandConfidence, TrackingConfidence rightHandConfidence)
 {
     this.ID = ID;
     this.location = location;
     this.gesture = gesture;
     this.trackingState = (int)trackState;
     this.leftHandLocation = null;
     this.rightHandLocation = null;
     if (leftHand.TrackingState == TrackingState.Tracked) {
         this.leftHandLocation = new Point3D((double)leftHand.Position.X, (double)leftHand.Position.Y, (double)leftHand.Position.Z);
         this.leftHandState = leftHandState.ToString();
         this.leftHandConfidence = leftHandConfidence.ToString();
         this.rightHandConfidence = rightHandConfidence.ToString();
     }
     if (rightHand.TrackingState == TrackingState.Tracked)
     {
         this.rightHandLocation = new Point3D((double)rightHand.Position.X, (double)rightHand.Position.Y, (double)rightHand.Position.Z);
         this.rightHandState = rightHandState.ToString();
     }
     
 }

        internal Hand(ulong trackingID, HandState state, IList<DepthPointEx> contour, IList<DepthPointEx> fingers, CoordinateMapper coordinateMapper)
        {
            TrackingId = trackingID;

            if (state == HandState.Open)
            {
                Fingers = fingers.Select(f => new Finger(f, coordinateMapper)).ToList();
            }
            else
            {
                Fingers = new List<Finger>();
            }

            ushort[] depths = contour.Select(d => (ushort)d.Z).ToArray();

            ContourDepth = contour.Select(p => new DepthSpacePoint { X = p.X, Y = p.Y }).ToArray();

            ContourCamera = new CameraSpacePoint[ContourDepth.Count];
            coordinateMapper.MapDepthPointsToCameraSpace((DepthSpacePoint[])ContourDepth, depths, (CameraSpacePoint[])ContourCamera);

            ContourColor = new ColorSpacePoint[ContourDepth.Count];
            coordinateMapper.MapDepthPointsToColorSpace((DepthSpacePoint[])ContourDepth, depths, (ColorSpacePoint[])ContourColor);
        }