private SkeletonController.HandCoords coords(Hand h)
 {
     SkeletonController.HandCoords cs = null;
     if (KinectController.ActiveSkeleton != null)
     {
         cs = KinectController.ActiveSkeleton.AngleCoords(h);
     }
     return(cs);
 }
    void Update()
    {
        if (activated)
        {
            if (KinectController.ActiveSkeleton != null)
            {
                SkeletonController.HandCoords left = KinectController.ActiveSkeleton.NormalizedCoords(Hand.Left, HorizontalAngle, VerticalAngle);
                LeftHitTarget.Move(new Vector3(left.horizontal, left.vertical, left.length));
                SkeletonController.HandCoords right = KinectController.ActiveSkeleton.NormalizedCoords(Hand.Right, HorizontalAngle, VerticalAngle);
                RightHitTarget.Move(new Vector3(right.horizontal, right.vertical, right.length));

/*
 *              switch (explosionGestureState) {
 *                  case ExplosionState.Possible:
 *                      if (left.length > ExplosionMinLength && right.length > ExplosionMinLength) {
 *                          stateInPlace(left.vertical, right.vertical);
 *                      }
 *                      break;
 *                  case ExplosionState.InPlace:
 *                      if (left.length < ExplosionMinLength || right.length > ExplosionMinLength) {
 *                          statePossible();
 *                      } */
                if (left.vertical > ExplosionMinVertical && right.vertical > ExplosionMinVertical && left.length > ExplosionMinLength && right.length > ExplosionMinLength)
                {
                    stateExplosion();
                }

                /*
                 *      break;
                 *
                 *
                 * } */
            }
            else
            {
                LeftHitTarget.Move(new Vector2(-2, .5f));
                RightHitTarget.Move(new Vector2(2, .5f));
            }
        }
        ;
    }
    private void checkHand()
    {
        SkeletonController.HandCoords cs = coords(hand);
        if (cs == null)
        {
            if ((state != GestureState.AnimationToEnd || state != GestureState.End) && state != GestureState.Possible)
            {
                statePossible();
            }
            return;
        }
        if (hand == Hand.Right)
        {
            cs.horizontal = 180 - cs.horizontal;
        }
        switch (state)
        {
        case GestureState.Possible:
            if (cs.vertical > MinSwipeStartVerticalAngle && cs.vertical < MaxSwipeStartVerticalAngle && cs.horizontal > MinSwipeStartHorizontalAngle && cs.horizontal < MaxSwipeStartHorizontalAngle)
            {
                stateAnimationToCanStart();
            }
            break;

        case GestureState.AnimationToPossible:
            if (cs.vertical > MinSwipeStartVerticalAngle && cs.vertical < MaxSwipeStartVerticalAngle && cs.horizontal > MinSwipeStartHorizontalAngle && cs.horizontal < MaxSwipeStartHorizontalAngle)
            {
                stateAnimationToCanStart();
            }
            else
            {
                float v1 = (Time.time - animationStartTime) / animationStartDuration;
                animationValue = Mathf.SmoothStep(animationStartValue, 0, v1);
                //Debug.Log(string.Format("Animation to Possible: v1={0} animationStartTime={1} animationStartDuration={2} animationStartValue={3} animationValue={4}", v1, animationStartTime, animationStartDuration, animationStartValue, animationValue));
                Arrow.position = Vector3.Lerp(ArrowPossiblePosition, ArrowReadyPosition, animationValue);
                Arrow.renderer.material.color = new Color(1, 1, 1, animationValue);
                if (v1 >= 1)
                {
                    statePossible();
                }
            }
            break;

        case GestureState.CanStart:
            if (cs.vertical < MinSwipeStartVerticalAngle || cs.vertical > MaxSwipeStartVerticalAngle || cs.horizontal < MinSwipeStartHorizontalAngle || cs.length < MinSwipeStartLength || cs.length > MaxSwipeStartLength)
            {
                stateAnimationToPossible();
            }
            if (cs.horizontal > MinSwipeEndHorizontalAngle)
            {
                stateSwipe();
            }
            break;

        case GestureState.AnimationToCanStart:
            if (cs.vertical < MinSwipeStartVerticalAngle || cs.vertical > MaxSwipeStartVerticalAngle || cs.horizontal < MinSwipeStartHorizontalAngle || cs.length < MinSwipeStartLength || cs.length > MaxSwipeStartLength)
            {
                stateAnimationToPossible();
            }
            else
            {
                float v2 = (Time.time - animationStartTime) / animationStartDuration;
                animationValue = Mathf.SmoothStep(animationStartValue, 1, v2);
                Arrow.position = Vector3.Lerp(ArrowPossiblePosition, ArrowReadyPosition, animationValue);
                Arrow.renderer.material.color = new Color(1, 1, 1, animationValue);
                //Debug.Log(string.Format("Animation to CanStart: v1={0} animationStartTime={1} animationStartDuration={2} animationStartValue={3} animationValue={4}", v2, animationStartTime, animationStartDuration, animationStartValue, animationValue));
                if (v2 >= 1)
                {
                    stateCanStart();
                }
            }
            break;

        case GestureState.AnimationToEnd:
            float v3 = (Time.time - animationStartTime) / animationStartDuration;
            animationValue = Mathf.SmoothStep(0, 1, v3);
            Arrow.position = Vector3.Lerp(ArrowReadyPosition, ArrowEndPosition, animationValue);
            Arrow.renderer.material.color = new Color(1, 1, 1, 1 - animationValue);
            if (v3 >= 1)
            {
                stateEnd();
            }
            break;
        }
        if (Input.GetKeyUp(KeyCode.R))
        {
            statePossible();
        }
    }