public AceExorcistGame()
	{
        //Create Deck and Hand for Exorcist, and draw 5 cards from Deck to Hand
        ExorcistLibrary = new Deck(IsExorcist);
        ExorcistHand = new Hand();
        for (int i = 1; i < 6; i++)
        {
            ExorcistHand.addCard( ExorcistLibrary.TakeCard() );
        }

        //Create Deck and Hand for Exorcist, and draw 5 cards from Deck to Hand
        IsExorcist = false;
        SummonerLibrary = new Deck(IsExorcist);
        for (int i = 1; i < 6; i++)
        {
            SummonerHand.addCard(SummonerLibrary.TakeCard());
        }


        //Create Summon Zone
        SummonZone = new Hand();

        //Create Discards (as a Hand - but not in this implementation)

	}

 //Test the initial posture of the hand to start the gesture
 protected override void TestInitialGesture(Hand hand)
 {
     InitialPosition = hand.PalmPosition.x;
     PreviousHand = hand;
     ListeGesture[0].TestGesture(hand);
     //ReceiveBeginningRightMoveEvent();
 }

    void HandleMovement(Hand currentFrameHand)
    {
        horizontalMove = 0;
        verticalMove = 0;
        horizontalLook = 0;

        if(currentFrameHand.IsValid)
        {
            horizontalMove =  hMoveScale * currentFrameHand.PalmNormal.Roll / Mathf.PI ;
            verticalMove =  vMoveScale * currentFrameHand.Direction.Pitch / Mathf.PI;
            horizontalLook = hLookScale * currentFrameHand.Direction.Yaw / Mathf.PI;

            // debug visualization
            //Debug.DrawLine(transform.position, transform.position + new Vector3(currentFrameHand.PalmNormal.Roll , 0, 0) * 2.150f, Color.green, 0, false);
            //Debug.DrawLine(transform.position, transform.position + new Vector3(0 , currentFrameHand.Direction.Pitch, 0) * 2.150f, Color.blue, 0, false);
            //Debug.DrawLine(transform.position, transform.position + new Vector3(0 , 0, currentFrameHand.Direction.Yaw) * 2.150f, Color.red, 0, false);
        }
        if(Mathf.Abs(horizontalMove) < 5)
        {
            acrobaticsScript.RotateToInitialRotation();
        }
        else
        {
            playerScript.HandleControls(-horizontalMove, -verticalMove);
        }

        //Debug.Log(horizontalMove);
    }

    // Update is called once per frame
    void Update()
    {
        frame = lp.CurrentFrame;
        if (frame.Hands.Count > 0) {
            if (frame.Hands.Leftmost.IsLeft) {
                righty = frame.Hands.Leftmost;
                rfingers = right.fingers;
            }
        }

        if (right.isActiveAndEnabled) {
            if (Vector3.Distance (right.GetPalmPosition (), rfingers [0].GetTipPosition ()) > trigger &&
                Vector3.Distance (right.GetPalmPosition (), rfingers [1].GetTipPosition ()) > trigger &&
                Vector3.Distance (right.GetPalmPosition (), rfingers [2].GetTipPosition ()) < trigger &&
                Vector3.Distance (right.GetPalmPosition (), rfingers [3].GetTipPosition ()) < trigger &&
                Vector3.Distance (right.GetPalmPosition (), rfingers [4].GetTipPosition ()) < trigger ) {
                Debug.Log ("rockgod!!");
                rockgod = true;
            } else {
                rockgod = false;
            }
            if (rockgod) {
                line.enabled = true;
                Ray ray = new Ray (rfingers [1].GetTipPosition (), rfingers[1].GetBoneDirection(2));
        //				Ray ray1 = new Ray (rfingers [4].GetTipPosition (), rfingers [4].GetBoneDirection ());

                line.SetPosition (0, ray.origin);
                line.SetPosition (1, ray.GetPoint (100));
            } else {
                line.enabled = false;
            }
        }
    }

 public void SetLeapHand(Hand hand) {
   hand_ = hand;
   for (int i = 0; i < fingers.Length; ++i) {
     if (fingers[i] != null)
       fingers[i].SetLeapHand(hand_);
   }
 }

        [TestMethod]                                                                               // ♣
        public void ToString_StringEmptyHand()                                                     // ♦
        {                                                                                          // ♥
            IHand hand = new Hand(new List<ICard>());                                              // ♠

            string actual = hand.ToString();
            Assert.AreEqual(String.Empty, actual, "Tostring() method of Hand not implemented currenctly.");
        }

    public void twoHandsWithDifferentCardsShouldNotBeEqual()
    {
        var Hand = new Hand(asCardArray("J-H", "A-S", "5-C", "7-D", "3-C"));
        var OtherHand = new Hand(asCardArray("A-C", "K-D", "4-D", "3-S", "6-H"));

        Assert.IsFalse(Hand.Equals(OtherHand));
    }

        public Card MakePlay(Card Down, Hand Hand)
        {
            List<Card> V = new List<Card>();
            foreach (Card Card in Hand)
            {
                if (_Function.Invoke(Down, Card)) V.Add(Card);
            }

            int M = Int32.MaxValue;
            Card Choice = null;
            foreach (Card Card in V)
            {
                int N = 0;
                foreach (Card DownCard in _ImaginaryDeck)
                {
                    if (_Function.Invoke(DownCard, Card)) N++;
                }
                if (N < M)
                {
                    M = N;
                    Choice = Card;
                }
            }
            return Choice;
        }

 public static int EvaluateCards(Hand hand)
 {
     int[] cards = new int[hand.Count];
     for (int i = 0; i < hand.Count; i++)
         cards[i] = hand.ElementAt(i).Number;
     return EvaluateCards(cards);
 }

    //public City CurrentCity;
    //public int cityID;
    public void Start()
    {
        //roleCard = new GameObject("roleCard").AddComponent<_roleCard>();
        print("Start of Player");

        hand = new GameObject("hand").AddComponent<Hand>();
    }

 void checkGrabbed(Hand hand)
 {
     if (hand.GrabStrength > OnGrabStrength)
         Globals.SetSlowMotionTrue();
     if (hand.GrabStrength <= OffGrabStrength)
         Globals.SetSlowMotionFalse();
 }

 public HandCoords NormalizedCoords(Hand h, float HorizontalAngle, float VerticalAngle)
 {
     HandCoords coords = AngleCoords(h);
     coords.horizontal = (coords.horizontal - (90 - HorizontalAngle/2))/HorizontalAngle;
     coords.vertical = (coords.vertical - (90 - VerticalAngle / 2)) / VerticalAngle;
     return coords;
 }

 public void TestIsValidHand_WithNoCards()
 {
     Hand currentHand = new Hand(new List<ICard>());
     PokerHandsChecker checker = new PokerHandsChecker();
     bool isValidHand = checker.IsValidHand(currentHand);
     Assert.AreEqual(false, isValidHand);
 }

    private bool checkStabiliseGesture(Hand leftHand, Hand rightHand)
    {
        float leftHandHeight = leftHand.PalmPosition.y;
        float rightHandHeight = rightHand.PalmPosition.y;
        float averageHandHeight = (leftHandHeight + rightHandHeight) / 2;

        if(!stabiliseTopHit){
            if(averageHandHeight > 175){
                stabiliseTopHit = true;
                startTime = Time.time;
                return false;
            }
        }else{
            if(averageHandHeight <= 120){
                float timeDiff = Time.time - startTime;
                if(timeDiff < 0.9){
                    Debug.Log("Time Diff: " + timeDiff);
                    stabiliseTopHit = false;
                    return true;
                }else{
                    stabiliseTopHit = false;
                    Debug.Log ("Out of Time");
                }
            }
        }
        return false;
    }

	// Use this for initialization
	void Start () {
		//for now, has the same amount as a normal deck?
		cardAmount = 30;
		cardsRemaining=cardAmount;
		maxHandValue = 6;       //this is also specified in AceExorcistGames.cs???
		//deck = new Deck(); - moved this into AceExorcistGames.cs

		//create references to the player's Hand component and the enemy's
		playerH = GameObject.Find("Player_Hand").GetComponent<Hand>();
		enemyH = GameObject.Find("Enemy_Hand").GetComponent<Hand>();

		
		//Tests to see if card deck really works
		Debug.Log("Amount of cards: " + deck.Cards.Count);
		
		//shuffles deck
		deck.shuffleDeck();
		
		//Shows each card for that deck
		Debug.Log("Cards on this deck");
		for(int i =0;i< deck.Cards.Count;i++)
		{
			Debug.Log(deck.Cards[i].cardValue + " of "+ deck.Cards[i].Suit);
		}
		
	}

 public void SwitchGesture(string nextGesture, Hand side)
 {
     switch (side)
     {
         case Hand.left:
             foreach (var gesture in sGestures_L)
             {
                 if (gesture == nextGesture)
                     animator.SetBool("l_" + gesture, true);
                 else
                     animator.SetBool("l_" + gesture, false);
                 actualGestureL = nextGesture;
             }
             break;
         case Hand.right:
             foreach (var gesture in sGestures_R)
             {
                 if (gesture == nextGesture)
                     animator.SetBool("r_" + gesture, true);
                 else
                     animator.SetBool("r_" + gesture, false);
                 actualGestureR = nextGesture;
             }
             break;
         default:
             break;
     }
 }

        public WarViewModel(HandResult result)
        {
            PlayerOneHand = result.PlayerOneHand;
            PlayerTwoHand = result.PlayerTwoHand;

            RecentResults = result;
        }

	void Update() {
		Controller controller = new Controller();
		Frame frame = controller.Frame();
		HandList hands = frame.Hands;
		hand = hands[0];
		otherHand = hands[1];
	}

    public void twoHandsThatAreNotEqualShouldHaveDifferentHashCodes()
    {
        var Hand = new Hand(asCardArray("A-S", "K-H", "Q-D", "J-C", "10-S"));
        var OtherHand = new Hand(asCardArray("Q-D", "10-C", "K-H", "A-S", "J-C"));

        Assert.AreNotEqual(Hand.GetHashCode(), OtherHand.GetHashCode());
    }

    protected override void UpdateTracker()
    {
        previousPosition = Position;
        previousOrientation = Orientation;
        previousGrabbingStrength = currentGrabbingStrength;

        //get the rightmost hand in the frame
        if (handController.GetAllGraphicsHands().Length != 0)
        {
            handModel = handController.GetAllGraphicsHands()[0];
            handModel.transform.GetComponentInChildren<SkinnedMeshRenderer>().enabled = visibleHand;
            hand = handModel.GetLeapHand();
            currentGrabbingStrength = lowPassFilter(hand.GrabStrength, previousGrabbingStrength);

            Position = lowPassFilter(handModel.GetPalmPosition(), previousPosition);
            Orientation = lowPassFilter(handModel.GetPalmDirection(), previousOrientation);
        }

        //mask/display the graphical hand on key down
        if (Input.GetKeyDown(visibleHandKey))
        {
            var smr = handModel.transform.GetComponentInChildren<SkinnedMeshRenderer>();
            visibleHand = !visibleHand;
        }

        Translation = Position - previousPosition;
        Rotation = previousOrientation - Orientation;
    }