// Update is called once per frame
 void Update()
 {
     if (MagicRoomKinectV2Manager.instance.MagicRoomKinectV2Manager_active)
     {
         temporarySkeleton = null;
         foreach (KinectBodySkeleton c in MagicRoomKinectV2Manager.instance.skeletons)
         {
             //Debug.Log(c);
             if (temporarySkeleton == null && c.SpineBase.z > 0)
             {
                 temporarySkeleton = c;
             }
             else if (temporarySkeleton == null)
             {
                 continue;
             }
             else if (temporarySkeleton.SpineBase.z > c.SpineBase.z && c.SpineBase.z > 0)
             {
                 temporarySkeleton = c;
             }
         }
         skeleton = temporarySkeleton;
         if (skeleton != null)
         {
             _tr.position = new Vector2((skeleton.HandRight.x * 9f), (skeleton.HandRight.y * 5f));
         }
     }
 }
    //la mano segue il mouse
    void FollowMouseOrKinectHand()
    {
        Vector2 mousePositionInWorldCoordinates;

        if (inMagicRoom)
        {
            Vector3 randomOffset = new Vector3(Random.Range(-0.001f, 0.001f), Random.Range(-0.001f, 0.001f), 0);
            currentSkeleton = MagicRoomKinectV2Manager.instance.GetCloserSkeleton();
            if (MagicRoomKinectV2Manager.instance.MagicRoomKinectV2Manager_active)
            {
                mousePositionInWorldCoordinates = (MagicRoomKinectV2Manager.instance.GetCloserSkeleton().HandRight * 11) + randomOffset;
            }
            else
            {
                mousePositionInWorldCoordinates = Camera.main.ScreenToWorldPoint(new Vector3(Input.mousePosition.x, Input.mousePosition.y, 0));
            }
        }
        else
        {
            mousePositionInWorldCoordinates = Camera.main.ScreenToWorldPoint(new Vector3(Input.mousePosition.x, Input.mousePosition.y, 0));
        }

        Vector2 newPosition;

        newPosition = new Vector2(Mathf.Lerp(transform.position.x, mousePositionInWorldCoordinates.x, lerpingFactor), Mathf.Lerp(transform.position.y, mousePositionInWorldCoordinates.y, lerpingFactor));
        rigid.MovePosition(newPosition);
    }
Beispiel #3
0
    /* <summary>
     * Update is called once per frame
     * </summary>
     */
    void Update()
    {
        // If movement not on, i do not care about position
        if (!isMovementEnabled)
        {
            return;
        }

        // Looking to the nearest skelpos
        KinectBodySkeleton skel = MagicOrchestraUtils.GetNearestSkeleton();

        if (skel == null)
        {
            Debug.Log("No MagicRoomKinectV2Manager founded");
            return;
        }

        Vector3 skelpos = skel.SpineBase;

        // Computing new Vector3 position
        //tr.position = new Vector3(skelpos.x * 8 * _AdapterRoomSize.x + shiftX, gameObject.transform.position.y, (-6 + shiftY) * -_AdapterRoomSize.y - skelpos.z * 3.5f * _AdapterRoomSize.y);
        tr.position = new Vector3(multX * skelpos.x * 8 * _AdapterRoomSize.x + shiftX, gameObject.transform.position.y, (-6 + shiftY) * -_AdapterRoomSize.y * multY - skelpos.z * 3.5f * _AdapterRoomSize.y * multY);

        // Moving pillar on the game
        gameObject.transform.position = tr.position;
    }
Beispiel #4
0
    /* <summary>
     * Function to get the nearest skelton
     * </summary>
     */
    public static KinectBodySkeleton GetNearestSkeleton()
    {
        if (MagicRoomKinectV2Manager.instance.MagicRoomKinectV2Manager_active)
        {
            // User position part
            Vector3 skelpos = Vector3.zero;

            float minZfounded          = 0.0f;
            KinectBodySkeleton minSkel = null;

            foreach (KinectBodySkeleton skel in MagicRoomKinectV2Manager.instance.skeletons)
            {
                // Is the skel valid?
                if (skel != null && skel.SpineBase != Vector3.zero && (skelpos.z == 0 || skelpos.z > skel.SpineBase.z))
                {
                    if (minSkel == null)
                    {
                        minZfounded = skel.SpineBase.z;
                        minSkel     = skel;
                    }
                    else
                    {
                        if (skel.SpineBase.z < minZfounded)
                        {
                            minZfounded = skel.SpineBase.z;
                            minSkel     = skel;
                        }
                    }
                }
            }

            return(minSkel);
        }
        else
        {
            return(null);
        }
    }
Beispiel #5
0
    // Update is called once per frame
    void Update()
    {
        if (MagicRoomKinectV2Manager.instance.MagicRoomKinectV2Manager_active)
        {
            temporarySkeleton = null;

            foreach (KinectBodySkeleton c in MagicRoomKinectV2Manager.instance.skeletons)
            {
                //Debug.Log(c);
                if (temporarySkeleton == null && c.SpineBase.z > 0)
                {
                    temporarySkeleton = c;
                }
                else if (temporarySkeleton == null)
                {
                    continue;
                }
                else if (temporarySkeleton.SpineBase.z > c.SpineBase.z && c.SpineBase.z > 0)
                {
                    temporarySkeleton = c;
                }
            }
            skeleton = temporarySkeleton;
            RaycastHit2D hitRight = Physics2D.Raycast(new Vector2((skeleton.HandRight.x * 9f), (skeleton.HandRight.y * 5f)), Vector2.zero);
            RaycastHit2D hitLeft  = Physics2D.Raycast(new Vector2((skeleton.HandLeft.x * 9f), (skeleton.HandLeft.y * 5f)), Vector2.zero);
            if (feet)
            {
                timePassed += Time.deltaTime;
                if (((skeleton.SpineBase.x + 0.7f) * 6.35f) + 14.2f < feetObject.GetComponent <Transform>().position.x + 1.5f && ((skeleton.SpineBase.x + 0.7f) * 6.35f) + 14.2f > feetObject.GetComponent <Transform>().position.x - 1.5)
                {
                    onthefeet = true;
                    onFeet   += Time.deltaTime;
                    //MagicRoomLightManager.instance.sendColour(Color.green, 40);
                    notOnFeet = 0;
                }
                else
                {
                    onFeet     = 0;
                    notOnFeet += Time.deltaTime;
                    onthefeet  = false;
                }
                if (notOnFeet > 2)
                {
                    MagicRoomLightManager.instance.sendColour(Color.red, 100);
                    notOnFeet = 0;
                }
                if (onFeet > 2)
                {
                    MagicRoomLightManager.instance.sendColour(Color.blue, 40);
                    onFeet = 0;
                }

                if (timePassed > 15f)
                {
                    feetObject.GetComponent <Transform>().position = new Vector3(UnityEngine.Random.Range(16, 23), -1.8f);
                    timePassed = 0;
                    MagicRoomLightManager.instance.sendColour(Color.red, 40);
                    onFeet = 1;
                }
            }
            if (hitRight.collider != null && skeleton.isRightHandClosed(0.07f) && onlyOneRight && onthefeet)
            {
                clickedRight = hitRight.transform.gameObject;
                clickedRight.GetComponent <Movement>().follow         = true;
                clickedRight.GetComponent <Rigidbody2D>().isKinematic = false;
                clickedRight.GetComponent <Movement>().follow_x       = skeleton.HandRight.x * 9f;
                clickedRight.GetComponent <Movement>().follow_y       = skeleton.HandRight.y * 5f;
                colorRight = clickedRight.GetComponent <Renderer>().material.GetColor("_Color");
                clickedRight.GetComponent <Renderer>().material.SetColor("_Color", Color.gray);
                onlyOneRight = false;
            }
            else if (clickedRight != null)
            {
                clickedRight.GetComponent <Movement>().follow = false;
                clickedRight.GetComponent <Renderer>().material.SetColor("_Color", Color.white);
                clickedRight.GetComponent <Rigidbody2D>().isKinematic = true;
                onlyOneRight = true;
            }
            else
            {
                onlyOneRight = true;
            }
            if (hitLeft.collider != null && skeleton.isLeftHandClosed(0.07f) && onlyOneLeft && onthefeet)
            {
                clickedLeft = hitLeft.transform.gameObject;
                clickedLeft.GetComponent <Movement>().follow         = true;
                clickedLeft.GetComponent <Rigidbody2D>().isKinematic = false;
                clickedLeft.GetComponent <Movement>().follow_x       = skeleton.HandLeft.x * 9f;
                clickedLeft.GetComponent <Movement>().follow_y       = skeleton.HandLeft.y * 5f;
                colorLeft = clickedLeft.GetComponent <Renderer>().material.GetColor("_Color");
                clickedLeft.GetComponent <Renderer>().material.SetColor("_Color", Color.gray);
                onlyOneLeft = false;
            }
            else if (clickedLeft != null)
            {
                clickedLeft.GetComponent <Movement>().follow = false;
                clickedLeft.GetComponent <Renderer>().material.SetColor("_Color", Color.white);
                clickedLeft.GetComponent <Movement>().first          = false;
                clickedLeft.GetComponent <Rigidbody2D>().isKinematic = true;
                onlyOneLeft = true;
            }
            else
            {
                onlyOneLeft = true;
            }
        }

        /*
         * RaycastHit2D hit = Physics2D.Raycast(Camera.main.ScreenToWorldPoint(Input.mousePosition), Vector2.zero);
         * if (hit.collider != null && Input.GetMouseButtonDown(0))
         * {
         *   if (first)
         *   {
         *       clicked = hit.transform.gameObject;
         *       clicked.GetComponent<Movement>().follow = true;
         *       clicked.GetComponent<Rigidbody2D>().isKinematic = false;
         *       first = false;
         *       clicked.GetComponent<Movement>().first = true;
         *       color1 = clicked.GetComponent<Renderer>().material.GetColor("_Color");
         *       clicked.GetComponent<Renderer>().material.SetColor("_Color", Color.gray);
         *   }
         *   else if(!second && hit.transform.gameObject != clicked)
         *   {
         *       clicked2 = hit.transform.gameObject;
         *       clicked2.GetComponent<Movement>().follow = true;
         *       clicked2.GetComponent<Rigidbody2D>().isKinematic = false;
         *       second = true;
         *       color2 = clicked2.GetComponent<Renderer>().material.GetColor("_Color");
         *       clicked2.GetComponent<Renderer>().material.SetColor("_Color", Color.gray);
         *   }
         * }
         * else if(!first && second && Input.GetMouseButtonUp(0))
         * {
         *   clicked2.GetComponent<Movement>().follow = false;
         *   clicked2.GetComponent<Renderer>().material.SetColor("_Color", color2);
         *   clicked2.GetComponent<Rigidbody2D>().isKinematic = true;
         *   second = false;
         * }
         */
        if (destroyed == SpawnNumber)
        {
            destroyed = 0;
            Destroy(SpawnManager);
            RestartManager.gameOver();
            feet = false;
            _background.GetComponent <SpriteRenderer>().sprite = backgrounds[5];
            AudioManager.GetComponent <AudioManager>().gameWon();
        }
        if (skeleton.isRightHandClosed(0.07f))
        {
            rightHand.transform.GetChild(1).gameObject.SetActive(true);
            rightHand.transform.GetChild(0).gameObject.SetActive(false);
        }
        else
        {
            rightHand.transform.GetChild(1).gameObject.SetActive(false);
            rightHand.transform.GetChild(0).gameObject.SetActive(true);
        }
        if (skeleton.isLeftHandClosed(0.07f))
        {
            leftHand.transform.GetChild(1).gameObject.SetActive(true);
            leftHand.transform.GetChild(0).gameObject.SetActive(false);
        }
        else
        {
            leftHand.transform.GetChild(1).gameObject.SetActive(false);
            leftHand.transform.GetChild(0).gameObject.SetActive(true);
        }
    }
    // Update is called once for frame
    void Update()
    {
        if (this.isRaycasterEnabled)
        {
            // Looking to the nearest skelpos
            KinectBodySkeleton skel = MagicOrchestraUtils.GetNearestSkeleton();

            if (skel == null)
            {
                Debug.Log("No MagicRoomKinectV2Manager founded");
                return;
            }

            // Computing new Vector3 position
            this.tr.position = new Vector3(multX * skel.HandLeft.x * _AdapterRoomSize.x + shiftX, gameObject.transform.position.y, multZ * skel.HandLeft.y + shiftZ);

            // Moving cursor on the game
            gameObject.transform.position = tr.position;

            // Select the object to drag
            if (skel.isLeftHandClosed())
            {
                gameObject.GetComponent <SpriteRenderer>().sprite = spritesHands[1];

                if (!this.isDrag)
                {
                    RaycastHit hitInfo;
                    this.target = GetHitTargetObject(out hitInfo);
                    //this.oldScale = this.target.transform.localScale;

                    if (Game1Parameters.ConfirmSound)
                    {
                        this.transform.parent.gameObject.transform.parent.gameObject.GetComponent <AudioSource>().Play();
                    }
                }

                if (this.target != null)
                {
                    this.isDrag = true;
                    this.CallTargetScript();
                    this.target.transform.position = new Vector3(this.target.transform.position.x, 1.5f, this.target.transform.position.z);

                    //this.target.transform.localScale = this.dragScale;
                }
            }

            if (!skel.isLeftHandClosed())
            {
                gameObject.GetComponent <SpriteRenderer>().sprite = spritesHands[0];

                this.isDrag = false;

                if (this.target != null)
                {
                    this.target.transform.position = new Vector3(this.target.transform.position.x, 0, this.target.transform.position.z);
                    //this.target.transform.localScale = this.oldScale;
                }
            }

            // Dragging the object
            if (this.isDrag)
            {
                if (this.target == null)
                {
                    Debug.Log("Something strange");
                }
                else
                {
                    this.target.transform.position = new Vector3(tr.position.x, this.target.transform.position.y, tr.position.z);
                }
            }

            // Moving cursor on the game
            // gameObject.transform.position = tr.position;
        }
    }