예제 #1
0
    // 加算実行
    public void OnArmAdd(float addWidthMax, int time)
    {
        if (state == ARM_STATE.ARM_STATE_NONE)
        {
            state = ARM_STATE.ARM_STATE_ADD;

            addWidth = addWidthMax / time; // 一度に加算する量を設定
            subWidth = addWidthMax / 2;
            addTime  = time;               // 加算する時間を設定
            backTime = 2;                  // 戻す時間も設定
        }
    }
예제 #2
0
    private int backTime;          // 戻す時間

    // Use this for initialization
    void Start()
    {
        // Imgを取得
        armImg = GetComponent <Image>();

        // デフォルトの幅を取得
        defSize = armImg.rectTransform.sizeDelta;
        // 現在の幅に設定
        nowSize = defSize;

        state = ARM_STATE.ARM_STATE_NONE;
    }
예제 #3
0
 // 戻す状態の処理
 public void StateBackUpdate()
 {
     if (backTime > 0)
     {
         backTime--;                                 // 時間減算
         nowSize.x -= subWidth;                      // 幅 戻すため減算
         armImg.rectTransform.sizeDelta = nowSize;   // 位置更新
     }
     else
     {
         // 状態なしへ
         state = ARM_STATE.ARM_STATE_NONE;
     }
 }
예제 #4
0
 // 加算状態の処理
 public void StateAddUpdate()
 {
     if (addTime > 0)
     {
         addTime--;                                     // 時間減算
         nowSize.x += addWidth;                         // 幅加算
         armImg.rectTransform.sizeDelta = nowSize;      // 位置更新
     }
     else
     {
         // 戻し状態へ
         state = ARM_STATE.ARM_STATE_BACK;
     }
 }
예제 #5
0
    // Update is called once per frame
    void Update()
    {
        if (!isInitialized)
        {
            return;
        }
        //kin.AddToGrammar("destroy");
        //Debug.Log(kin.GetLastRecoResult());
        // Check for lightning
        Vector3 rightHand     = kin.GetJointPos(KinectWrapper.Joints.HAND_RIGHT);
        Vector3 rightShoulder = kin.GetJointPos(KinectWrapper.Joints.SHOULDER_RIGHT);
        Vector3 rightVec      = rightHand - rightShoulder;

        rightVec.z = -1 * rightVec.z;
        if (rightVec.z / rightVec.magnitude > STATE_THRESHOLD)
        {
            rightArm = ARM_STATE.AS_POS_Z;
        }
        else if (rightVec.z / rightVec.magnitude < -STATE_THRESHOLD)
        {
            rightArm = ARM_STATE.AS_NEG_Z;
        }
        else if (rightVec.x / rightVec.magnitude < -STATE_THRESHOLD)
        {
            rightArm = ARM_STATE.AS_NEG_X;
        }
        else if (rightVec.x / rightVec.magnitude > STATE_THRESHOLD)
        {
            rightArm = ARM_STATE.AS_POS_X;
        }
        else if (rightVec.y / rightVec.magnitude < -STATE_THRESHOLD)
        {
            rightArm = ARM_STATE.AS_NEG_Y;
        }
        else if (rightVec.y / rightVec.magnitude > STATE_THRESHOLD)
        {
            rightArm = ARM_STATE.AS_POS_Y;
        }
        else
        {
            rightArm = ARM_STATE.AS_NONE;
        }



        Vector3 leftHand     = kin.GetJointPos(KinectWrapper.Joints.HAND_LEFT);
        Vector3 leftShoulder = kin.GetJointPos(KinectWrapper.Joints.SHOULDER_LEFT);
        Vector3 leftVec      = leftHand - leftShoulder;

        leftVec.z = -1 * leftVec.z;
        if (leftVec.z / leftVec.magnitude > STATE_THRESHOLD)
        {
            leftArm = ARM_STATE.AS_POS_Z;
        }
        else if (leftVec.z / leftVec.magnitude < -STATE_THRESHOLD)
        {
            leftArm = ARM_STATE.AS_NEG_Z;
        }
        else if (leftVec.x / leftVec.magnitude < -STATE_THRESHOLD)
        {
            leftArm = ARM_STATE.AS_NEG_X;
        }
        else if (leftVec.x / leftVec.magnitude > STATE_THRESHOLD)
        {
            leftArm = ARM_STATE.AS_POS_X;
        }
        else if (leftVec.y / leftVec.magnitude < -STATE_THRESHOLD)
        {
            leftArm = ARM_STATE.AS_NEG_Y;
        }
        else if (leftVec.y / leftVec.magnitude > STATE_THRESHOLD)
        {
            leftArm = ARM_STATE.AS_POS_Y;
        }
        else
        {
            leftArm = ARM_STATE.AS_NONE;
        }


        Vector3 rightfoot       = kin.GetJointPos(KinectWrapper.Joints.FOOT_RIGHT);
        Vector3 leftfoot        = kin.GetJointPos(KinectWrapper.Joints.FOOT_LEFT);
        float   DisBetweenFoots = rightfoot.z - leftfoot.z;
        float   DisToJump       = Mathf.Abs(leftfoot.y) - Mathf.Abs(rightfoot.y);

        if (DisBetweenFoots > LEG_THRESHOLD)
        {
            rightLeg = LEG_STATE.AS_BACKWORD;
        }
        else if (DisBetweenFoots < -LEG_THRESHOLD)
        {
            rightLeg = LEG_STATE.AS_FORWORD;;
        }
        else
        {
            rightLeg = LEG_STATE.AS_NONE;
        }

        if (DisToJump > 90)
        {
            rightLegJump = JUMP_STATE.AS_JUMP;
        }
        else
        {
            rightLegJump = JUMP_STATE.AS_NONE;
        }

        Vector3 headVec = kin.GetJointPos(KinectWrapper.Joints.HEAD);
        Vector3 kneeVec = kin.GetJointPos(KinectWrapper.Joints.KNEE_LEFT);
        float   DisBetweenHeadAndKnee = headVec.y - kneeVec.y;

        if (DisBetweenHeadAndKnee < DUCK_THRESHOLD)
        {
            headKneeLeft = DUCK_STATE.AS_DUCK;
        }
        else
        {
            headKneeLeft = DUCK_STATE.AS_NONE;
        }

        //Debug.Log(headKneeLeft + ": " + DisBetweenHeadAndKnee);
    }
예제 #6
0
    // Update is called once per frame
    void Update()
    {
        if (!isInitialized) return;
		//kin.AddToGrammar("destroy");
		//Debug.Log(kin.GetLastRecoResult());
        // Check for lightning
        Vector3 rightHand = kin.GetJointPos(KinectWrapper.Joints.HAND_RIGHT);
        Vector3 rightShoulder = kin.GetJointPos(KinectWrapper.Joints.SHOULDER_RIGHT);
        Vector3 rightVec = rightHand - rightShoulder;
        rightVec.z = -1 * rightVec.z;
        if (rightVec.z / rightVec.magnitude > STATE_THRESHOLD)
        {
            rightArm = ARM_STATE.AS_POS_Z;
        }
        else if (rightVec.z / rightVec.magnitude < -STATE_THRESHOLD)
        {
            rightArm = ARM_STATE.AS_NEG_Z;
        }
        else if (rightVec.x / rightVec.magnitude < -STATE_THRESHOLD)
        {
            rightArm = ARM_STATE.AS_NEG_X;
        }
        else if (rightVec.x / rightVec.magnitude > STATE_THRESHOLD)
        {
            rightArm = ARM_STATE.AS_POS_X;
        }
        else if (rightVec.y / rightVec.magnitude < -STATE_THRESHOLD)
        {
            rightArm = ARM_STATE.AS_NEG_Y;
        }
        else if (rightVec.y / rightVec.magnitude > STATE_THRESHOLD)
        {
            rightArm = ARM_STATE.AS_POS_Y;
        }
        else
        {
            rightArm = ARM_STATE.AS_NONE;
        }



        Vector3 leftHand = kin.GetJointPos(KinectWrapper.Joints.HAND_LEFT);
        Vector3 leftShoulder = kin.GetJointPos(KinectWrapper.Joints.SHOULDER_LEFT);
        Vector3 leftVec = leftHand - leftShoulder;
        leftVec.z = -1 * leftVec.z;
        if (leftVec.z / leftVec.magnitude > STATE_THRESHOLD)
        {
            leftArm = ARM_STATE.AS_POS_Z;
        }
        else if (leftVec.z / leftVec.magnitude < -STATE_THRESHOLD)
        {
            leftArm = ARM_STATE.AS_NEG_Z;
        }
        else if (leftVec.x / leftVec.magnitude < -STATE_THRESHOLD)
        {
            leftArm = ARM_STATE.AS_NEG_X;
        }
        else if (leftVec.x / leftVec.magnitude > STATE_THRESHOLD)
        {
            leftArm = ARM_STATE.AS_POS_X;
        }
        else if (leftVec.y / leftVec.magnitude < -STATE_THRESHOLD)
        {
            leftArm = ARM_STATE.AS_NEG_Y;
        }
        else if (leftVec.y / leftVec.magnitude > STATE_THRESHOLD)
        {
            leftArm = ARM_STATE.AS_POS_Y;
        }
        else
        {
            leftArm = ARM_STATE.AS_NONE;
        }
		
		
		Vector3 rightfoot = kin.GetJointPos(KinectWrapper.Joints.FOOT_RIGHT);
		Vector3 leftfoot = kin.GetJointPos(KinectWrapper.Joints.FOOT_LEFT);
		float DisBetweenFoots = rightfoot.z - leftfoot.z;
		float DisToJump = Mathf.Abs(leftfoot.y) - Mathf.Abs(rightfoot.y);
		if (DisBetweenFoots > LEG_THRESHOLD)
        {
            rightLeg = LEG_STATE.AS_BACKWORD;
        }
        else if (DisBetweenFoots < -LEG_THRESHOLD)
        {
            rightLeg = LEG_STATE.AS_FORWORD;;
        }
        else
        {
            rightLeg = LEG_STATE.AS_NONE;
        }
		
		if ( DisToJump > 90 )
		{
			rightLegJump = JUMP_STATE.AS_JUMP;
		} else {
			rightLegJump = JUMP_STATE.AS_NONE;
		}
		
		Vector3 headVec = kin.GetJointPos(KinectWrapper.Joints.HEAD);
		Vector3 kneeVec = kin.GetJointPos(KinectWrapper.Joints.KNEE_LEFT);
		float DisBetweenHeadAndKnee = headVec.y - kneeVec.y;
		
        if (DisBetweenHeadAndKnee < DUCK_THRESHOLD){
			headKneeLeft = DUCK_STATE.AS_DUCK;
		} else {
			headKneeLeft = DUCK_STATE.AS_NONE;
		}
		
		//Debug.Log(headKneeLeft + ": " + DisBetweenHeadAndKnee);
    }
예제 #7
0
    // Update is called once per frame
    void Update()
    {
        if (!isInitialized)
        {
            return;
        }

        // Check for lightning
        Vector3 rightHand     = kin.GetJointPos(KinectWrapper.Joints.HAND_RIGHT);
        Vector3 rightShoulder = kin.GetJointPos(KinectWrapper.Joints.SHOULDER_RIGHT);
        Vector3 rightVec      = rightHand - rightShoulder;

        rightVec.z = -1 * rightVec.z;
        if (rightVec.z / rightVec.magnitude > STATE_THRESHOLD)
        {
            rightArm = ARM_STATE.AS_POS_Z;
        }
        else if (rightVec.z / rightVec.magnitude < -STATE_THRESHOLD)
        {
            rightArm = ARM_STATE.AS_NEG_Z;
        }
        else if (rightVec.x / rightVec.magnitude < -STATE_THRESHOLD)
        {
            rightArm = ARM_STATE.AS_NEG_X;
        }
        else if (rightVec.x / rightVec.magnitude > STATE_THRESHOLD)
        {
            rightArm = ARM_STATE.AS_POS_X;
        }
        else if (rightVec.y / rightVec.magnitude < -STATE_THRESHOLD)
        {
            rightArm = ARM_STATE.AS_NEG_Y;
        }
        else if (rightVec.y / rightVec.magnitude > STATE_THRESHOLD)
        {
            rightArm = ARM_STATE.AS_POS_Y;
        }
        else
        {
            rightArm = ARM_STATE.AS_NONE;
        }



        Vector3 leftHand     = kin.GetJointPos(KinectWrapper.Joints.HAND_LEFT);
        Vector3 leftShoulder = kin.GetJointPos(KinectWrapper.Joints.SHOULDER_LEFT);
        Vector3 leftVec      = leftHand - leftShoulder;

        leftVec.z = -1 * leftVec.z;
        if (leftVec.z / leftVec.magnitude > STATE_THRESHOLD)
        {
            leftArm = ARM_STATE.AS_POS_Z;
        }
        else if (leftVec.z / leftVec.magnitude < -STATE_THRESHOLD)
        {
            leftArm = ARM_STATE.AS_NEG_Z;
        }
        else if (leftVec.x / leftVec.magnitude < -STATE_THRESHOLD)
        {
            leftArm = ARM_STATE.AS_NEG_X;
        }
        else if (leftVec.x / leftVec.magnitude > STATE_THRESHOLD)
        {
            leftArm = ARM_STATE.AS_POS_X;
        }
        else if (leftVec.y / leftVec.magnitude < -STATE_THRESHOLD)
        {
            leftArm = ARM_STATE.AS_NEG_Y;
        }
        else if (leftVec.y / leftVec.magnitude > STATE_THRESHOLD)
        {
            leftArm = ARM_STATE.AS_POS_Y;
        }
        else
        {
            leftArm = ARM_STATE.AS_NONE;
        }

        //Debug.Log(leftVec + " " + leftArm + " " + rightArm + " " + rightVec);
    }