예제 #1
0
    private void CheckForInput()
    {
        inputDirection = Input.GetAxisRaw("Horizontal");

        //If not running and the run button is pressed, start running

        if (currentMovementState == movementState.normal)
        {
            if (Input.GetKeyDown(KeyCode.Space))
            {
                StartDash();
            }
            else if (inputDirection != 0)
            {
                playerRigidbody.velocity = new Vector2(walkSpeed * inputDirection, 0);
            }
        }
        //
        if (currentMovementState == movementState.running)
        {
            if (Input.GetKey(KeyCode.Space))
            {
                playerRigidbody.velocity = new Vector2(runSpeed * inputDirection, 0);
            }
            else
            {
                currentMovementState = movementState.normal;
            }
        }
    }
 void toggleCrawl()
 {
     if (move_state != movementState.CRAWL)
     {
         AudioController.audioPlayer.crouchSound();
         body.transform.position = new Vector3(body.transform.position.x, .25f, body.transform.position.z);
         if (move_state == movementState.AGAINST_WALL)
         {
             // Move off of the wall before lying down to crawl
             body.transform.position += body.transform.forward * (this.transform.localScale.y / 2f);
         }
         body.transform.Rotate(new Vector3(90f, 0f, 0f));
         move_state = movementState.CRAWL;
     }
     else if (!playerIsUnderObstacle())
     {
         AudioController.audioPlayer.crouchSound();
         body.transform.position = new Vector3(body.transform.position.x, 1f, body.transform.position.z);
         body.transform.Rotate(new Vector3(-90f, 0f, 0f));
         move_state = movementState.RUN;
     }
     else
     {
         AudioController.audioPlayer.cantSound();
     }
 }
예제 #3
0
    // Use this for initialization
    protected void Start()
    {
        //Here be dragons
        um = GameObject.FindObjectOfType <UnitManager>();
        em = GameObject.FindObjectOfType <EnemyManager>();

        LADDERINDEX = TileSpecList.getTileSpecInt("Ladder");

        currentMovement = new Vector2(0, 0);

        map = GameObject.FindObjectOfType <Map>();

        currentState = movementState.IDLE;

        //Start the pathing coroutine
        StartCoroutine(getPath());
        StartCoroutine(computeState());
        cc       = GetComponent <CharacterController>();
        position = new Vector2(Mathf.RoundToInt(this.transform.position.x), Mathf.RoundToInt(this.transform.position.y));

        selected = false;
        this.transform.localScale = new Vector3(size, size, size);

        this.right = Random.value > .5f;
    }
예제 #4
0
    // Checks and returns the players state (Walking, Wading, Swimming, Diving)
    protected movementState StateCheck(Transform objectPosition, GameObject water)
    {
        float         objectYPosition = objectPosition.transform.position.y;
        float         waterYPosition  = water.transform.position.y;
        movementState output          = movementState.Walk;

        if (objectYPosition - 1.0f >= waterYPosition)
        {
            output = movementState.Walk;
        }
        else if (objectYPosition > waterYPosition)
        {
            output = movementState.Wade;
        }
        else if (objectYPosition + 1.0 >= waterYPosition)
        {
            output = movementState.Swim;
        }
        else if (objectYPosition + 1.0f < waterYPosition)
        {
            output = movementState.Dive;
        }

        return(output);
    }
예제 #5
0
 private void Awake()
 {
     LockCursor();
     isJump              = false;
     currentPlayerState  = movementState.Walk;
     previousPlayerState = movementState.Walk;
 }
예제 #6
0
		private void rotate() {

			transformObj.rotation = Quaternion.RotateTowards(transformObj.rotation, targetRot, Time.deltaTime * rotateSpeed);

			if (input.horizontalInput == 0 && VectorEqual(targetRot.eulerAngles, transformObj.rotation.eulerAngles)) {
				stateMethod = idle;
			}
		}
    public override void UpdatePlaying()
    {
        if (_movState == movementState.blink)
        {
            if (blinkTimer > 0.2f)
            {
                _movState  = movementState.standing;
                blinkTimer = 0;
            }
            else
            {
                blinkTimer += Time.deltaTime;
            }
        }

        timeSinceGrounded += Time.deltaTime;
        if (timeSinceGrounded > 0.1f)
        {
            grounded      = false;
            surfaceNormal = Vector3.up;
        }
        else if (_movState != movementState.blink)
        {
            grounded = true;
        }

        transform.rotation = Quaternion.Euler(0, newLook.y, 0);

        if (PlayerCore._instance.playerState != PlayerCore.inputState.ragdoll)
        {
            //if (!PlayerCore._instance.peeking) {
            head.position = new Vector3(transform.position.x, transform.position.y + eyeHeight, transform.position.z);
            head.rotation = Quaternion.Euler(newLook);
            //}
        }

        Vector3 flatMag = move.velocity;

        flatMag.y = 0;

        if (_movState == movementState.blink)
        {
            _camera.fieldOfView = Mathf.Lerp(_camera.fieldOfView, 179, 0.5f);
        }
        else
        {
            _camera.fieldOfView = Mathf.Lerp(_camera.fieldOfView, 80, 0.2f);
        }

        if (AudioManager._instance != null && move.velocity.magnitude > 7.7f)
        {
            AudioManager._instance.FastMusic((move.velocity.magnitude - 7.6f) / 12);
        }
        else
        {
            AudioManager._instance.FastMusic(0);
        }
    }
 void Start()
 {
     if (thisRB == null)
     {
         thisRB = GetComponent <Rigidbody>();
     }
     thisMovementState = movementState.FreeMovement;
     startHeight       = thisRB.position.y;
 }
 // Update is called once per frame
 void Update()
 {
     if (this.transform.position.x <= pos1.x && curr == movementState.forward) {
         curr = movementState.back;
         enemyBod.velocity = new Vector3 (speed, 0f , 0f);
     } else if (this.transform.position.x >= camW/2 && curr == movementState.back) {
         Destroy(this.gameObject);
     }
 }
예제 #10
0
 void StartDash()
 {
     inputDirection = Input.GetAxisRaw("Horizontal");
     if (inputDirection == 0)
     {
         inputDirection = 1;
     }
     playerRigidbody.velocity = new Vector2(runSpeed * inputDirection, 0);
     currentMovementState     = movementState.running;
 }
    public void checkIfPushed()
    {
        if(movScript.state == CharacterMovement.states.pushingLeft){
                myState = movementState.pushedLeft;
        }

        else if(movScript.state == CharacterMovement.states.pushingRight){
                myState = movementState.pushedRight;
        }
    }
예제 #12
0
 // Update is called once per frame
 void Update()
 {
     if (this.transform.position.x <= pos1.x && curr == movementState.forward)
     {
         curr = movementState.back;
         enemyBod.velocity = new Vector3(speed, 0f, 0f);
     }
     else if (this.transform.position.x >= camW / 2 && curr == movementState.back)
     {
         Destroy(this.gameObject);
     }
 }
예제 #13
0
    void ladderTile(IVector2 t)
    {
        if (!canLadder)
        {
            return;
        }
        currentState = movementState.CLIMBING;
        TileSpec ts = map.getForeground(t);

        if (!ts.solid && ts != TileSpecList.getTileSpec(LADDERINDEX))
        {
            map.setTile(t, (byte)LADDERINDEX, (byte)1);
        }
    }
예제 #14
0
		private void idle() {
			if (input.verticalInput != 0) {
				if (!checkCollision(input.verticalInput)) {
					stateMethod = move;
					targetPos = transformObj.position + transformObj.forward * input.verticalInput;
				} else {
					stateMethod = bump; 
					targetPos = transformObj.position;
				}
			} else if (input.horizontalInput != 0) {
				targetRot.eulerAngles = new Vector3 (transformObj.rotation.eulerAngles.x, transformObj.rotation.eulerAngles.y + (90 * input.horizontalInput), transformObj.rotation.eulerAngles.z);
				stateMethod = rotate;
			}
		}
예제 #15
0
 private void Search()
 {
     if (currentState == movementState.FOLLOW)
     {
         if (transform.localScale.x == 0.5f)
         {
             currentState = movementState.RIGHT;
         }
         if (transform.localScale.x == -0.5f)
         {
             currentState = movementState.LEFT;
         }
     }
 }
예제 #16
0
    //****************************************************************************//

    void walkcase(IVector2 currentpos, IVector2 dest, ParentedNode node, Vector2 v)
    {
        if ((v.y > .25f && Mathf.Abs(v.x) < .1f) || (map.getForeground(currentpos) == TileSpecList.getTileSpec(LADDERINDEX) && canLadder))
        {
            laddercase(currentpos, dest, node, v);
            return;
        }
        currentState = movementState.WALKING;
        if (v.y > .25f && (Mathf.Abs(v.x) > .1f && cc.velocity.x == 0))        // || (lastPosition - currentpos).magnitude == 0){
        {
            Debug.Log("Jumping");
            jump();
            currentState = movementState.JUMPING;
        }
    }
예제 #17
0
    // Update is called once per frame
    void Update()
    {
        if (Input.GetKeyDown(KeyCode.P) && state == movementState.moving)
        {
            state = movementState.stopping;
        }

        if (Input.GetKeyDown(KeyCode.S))
        {
            state = movementState.starting;
        }



        switch (state)
        {
        case movementState.moving:
            positionDelta = velocityMoving * direction * Time.deltaTime;
            break;

        case movementState.starting:
            positionDelta += (startingAcceleration * direction * Time.deltaTime);
            if (Mathf.Abs(positionDelta) >= (velocityMoving))
            {
                state = movementState.moving;
            }
            break;

        case movementState.stopping:
            positionDelta -= (stoppingAcceleration * direction * Time.deltaTime);
            if (direction > 0f && positionDelta < 0f)
            {
                state     = movementState.starting;
                direction = direction * -1f;
            }
            if (direction < 0f && positionDelta > 0f)
            {
                state     = movementState.starting;
                direction = direction * -1f;
            }
            break;
        }



        transform.position = new Vector3(transform.position.x + positionDelta, transform.position.y, transform.position.z);
    }
예제 #18
0
    void Update()
    {
        transform.RotateAround(transform.position, Vector3.forward, 400 * Time.deltaTime);
        var cos = Mathf.Cos(Mathf.PI / 4);
        var sin = Mathf.Sin(Mathf.PI / 4);

        if (this.transform.position.x <= -camW / 8 && curr == movementState.forward)
        {
            //if (this.transform.position.x <= shiprigidbody.transform.position.x && curr == movementState.forward) {
            curr = movementState.back;

            //enemyBod.velocity = new Vector3 (speed, 0f , 0f);

            if (startfrom == occurplace.up)
            {
                sin = -sin;
            }
            enemyBod.velocity = new Vector3(speed * cos, speed * sin, 0f);
        }
        else if (curr == movementState.back)
        {
            //if (this.transform.position.y <= shiprigidbody.transform.position.y && startfrom == occurplace.up) {

            if (this.transform.position.y <= 0f && startfrom == occurplace.up)
            {
                curr = movementState.rotate;
                enemyBod.velocity = new Vector3(enemyBod.velocity.x * cos - enemyBod.velocity.y * sin, enemyBod.velocity.x * sin + enemyBod.velocity.y * cos, 0f);
            }
            //else if (this.transform.position.y >= shiprigidbody.transform.position.y && startfrom == occurplace.down) {
            else if (this.transform.position.y >= 0f && startfrom == occurplace.down)
            {
                sin  = -sin;
                curr = movementState.rotate;
                enemyBod.velocity = new Vector3(enemyBod.velocity.x * cos - enemyBod.velocity.y * sin, enemyBod.velocity.x * sin + enemyBod.velocity.y * cos, 0f);
            }
        }
        else if (this.transform.position.x >= camW / 2 && curr != movementState.forward)
        {
            Destroy(this.gameObject);
        }
        else if (this.gameObject.transform.position.y - this.gameObject.transform.lossyScale.y / 2 <= -camH / 2 || this.gameObject.transform.position.y + this.gameObject.transform.lossyScale.y / 2 >= camH / 2)
        {
            Destroy(this.gameObject);
        }
    }
 void updateAlongWall()
 {
     if (movingInLockedDirection())
     {
         if (!movingDiagonal())
         {
             move_state = movementState.AGAINST_WALL;
             body.transform.rotation = Quaternion.LookRotation(locked_direction * -1);
             moveBackAgainstWall();
         }
         zeroMovementInLockedDirection();
     }
     else if (movingOppositeOfLockedDirection())
     {
         locked_direction = Vector3.zero;
         move_state       = movementState.RUN;
     }
 }
 void updateWallMovement()
 {
     if (nextToObstacle() || hit_corner)
     {
         hit_corner = false;
         if (move_state == movementState.ALONG_WALL)
         {
             updateAlongWall();
         }
         else if (move_state == movementState.AGAINST_WALL)
         {
             updateAgainstWall();
         }
     }
     else if (move_state != movementState.CRAWL && move_state != movementState.GRABBING)
     {
         move_state       = movementState.RUN;
         locked_direction = Vector3.zero;
     }
 }
예제 #21
0
    private void Update()
    {
        playerInputs    = ReturnPlayerInputs();
        grounded        = Grounded(transform.position, capsuleCol);
        initialPosition = transform.position;
        isSteep         = IsSteep(SteepCheck(bodyObject), maxSlopeAngle);

        currentPlayerState = StateCheck(bodyObject, water);
        if (previousPlayerState != currentPlayerState)
        {
            Debug.Log(currentPlayerState);
        }
        previousPlayerState = currentPlayerState;

        CameraRotation();
        SimpleMove();
        PlayerPhysics();
        FinalMove();
        PlayerCollision();
    }
    void updateAgainstWall()
    {
        if (movingOppositeOfLockedDirection())
        {
            locked_direction = Vector3.zero;
            move_state       = movementState.RUN;
            return;
        }

        if (!movingInLockedDirection())
        {
            this.transform.position += this.transform.forward * 0.5f;
            locked_direction         = Vector3.zero;
            move_state = movementState.RUN;
        }
        else
        {
            zeroMovementInLockedDirection();
        }
    }
예제 #23
0
 //Handles the character digging.
 public void handleDigging(Vector2 dest, Vector2 v)
 {
     if (digging)
     {
         this.currentState = movementState.DIGGING;
         if (v.y < -.25)
         {
             jump(.75f);
             emitParticles();
         }
         //If it is done digging
         if ((digTimer -= Time.fixedDeltaTime) <= 0)
         {
             mine(dest);
         }
     }
     //Detect if it needs to start digging
     else if (map.isForegroundSolid(dest))
     {
         digTimer = digTime;
         digging  = true;
     }
 }
    void resolveGrab()
    {
        if (move_state == movementState.RUN)
        {
            body.velocity = Vector3.zero;
            RaycastHit hit_info;
            Ray        facing = new Ray(transform.position - transform.forward, transform.forward);
            Debug.DrawRay(transform.position - transform.forward * 2, transform.forward, Color.blue, 2f);
            Debug.DrawRay(transform.position, transform.right, Color.green, 4f);

            if (Physics.SphereCast(facing, 1.1f, out hit_info, 2f, enemy_layer))
            {
                victim = hit_info.rigidbody.gameObject;
                if (victim.GetComponent <Enemy>().current_state != EnemyState.KO &&
                    victim.GetComponent <Enemy>().current_state != EnemyState.BEING_FLIPPED && victim.GetComponent <Enemy>().current_state != EnemyState.DEAD)
                {
                    if (moveInput() && !body.isKinematic && !flip_lock)
                    {
                        throwEnemy();
                    }
                    else
                    {
                        move_state = movementState.GRABBING;
                        victim.GetComponent <Enemy>().getGrabbed();
                    }
                }
            }
        }
        else if (move_state == movementState.GRABBING)
        {
            if (victim.GetComponent <Enemy>().current_state != EnemyState.GRABBED)
            {
                move_state = movementState.RUN;
            }
        }
    }
    void OnCollisionEnter(Collision coll)
    {
        Vector3 pos;

        if (coll.gameObject.tag == "Obstacle" && move_state == movementState.RUN)
        {
            foreach (ContactPoint contact in coll.contacts)
            {
                if (contact.normal.x != 0 || contact.normal.z != 0)
                {
                    locked_direction   = coll.contacts[0].normal * -1;
                    locked_direction.y = 0;
                    break;
                }
            }
            if (locked_direction.x != 0 && locked_direction.z != 0)
            {
                hit_corner         = true;
                locked_direction.z = 0;
                pos    = this.transform.position;
                pos.x += locked_direction.x * -0.5f;
                pos.z += body.velocity.normalized.z * -0.5f;
                this.transform.position = pos;
            }

            if (movingDiagonal())
            {
                move_state = movementState.ALONG_WALL;
            }
            else
            {
                move_state = movementState.AGAINST_WALL;
                body.transform.rotation = Quaternion.LookRotation(coll.contacts[0].normal);
            }
        }
    }
예제 #26
0
	// Use this for initialization
	protected void Start () {
		//Here be dragons
		um = GameObject.FindObjectOfType<UnitManager>();
		em = GameObject.FindObjectOfType<EnemyManager>();

		LADDERINDEX = TileSpecList.getTileSpecInt("Ladder");

		currentMovement = new Vector2(0,0);

		map = GameObject.FindObjectOfType<Map>();

		currentState = movementState.IDLE;

		//Start the pathing coroutine
		StartCoroutine(getPath());
		StartCoroutine(computeState());
		cc = GetComponent<CharacterController>();
		position = new Vector2(Mathf.RoundToInt(this.transform.position.x),Mathf.RoundToInt(this.transform.position.y));

		selected = false;
		this.transform.localScale = new Vector3(size,size,size);

		this.right = Random.value>.5f;
	}
예제 #27
0
    void Update()
    {
        transform.RotateAround(transform.position, Vector3.forward, 400* Time.deltaTime);
        var cos = Mathf.Cos (Mathf.PI /4);
        var sin = Mathf.Sin (Mathf.PI /4);
        if (this.transform.position.x <= - camW /8 && curr == movementState.forward) {

        //if (this.transform.position.x <= shiprigidbody.transform.position.x && curr == movementState.forward) {
            curr = movementState.back;

            //enemyBod.velocity = new Vector3 (speed, 0f , 0f);

            if (startfrom == occurplace.up) {
                sin = -sin;
            }
            enemyBod.velocity = new Vector3 (speed * cos, speed * sin, 0f);

        } else if (curr == movementState.back) {
            //if (this.transform.position.y <= shiprigidbody.transform.position.y && startfrom == occurplace.up) {

            if (this.transform.position.y <= 0f && startfrom == occurplace.up) {
                curr = movementState.rotate;
                enemyBod.velocity = new Vector3 (enemyBod.velocity.x * cos - enemyBod.velocity.y * sin, enemyBod.velocity.x * sin + enemyBod.velocity.y * cos, 0f);

            }
            //else if (this.transform.position.y >= shiprigidbody.transform.position.y && startfrom == occurplace.down) {
            else if (this.transform.position.y >= 0f && startfrom == occurplace.down) {
                sin = -sin;
                curr = movementState.rotate;
                enemyBod.velocity = new Vector3 (enemyBod.velocity.x * cos - enemyBod.velocity.y * sin, enemyBod.velocity.x * sin + enemyBod.velocity.y * cos, 0f);

            }

        } else if (this.transform.position.x >= camW / 2 && curr != movementState.forward) {
            Destroy (this.gameObject);
        } else if (this.gameObject.transform.position.y - this.gameObject.transform.lossyScale.y / 2 <= -camH / 2 || this.gameObject.transform.position.y + this.gameObject.transform.lossyScale.y / 2 >= camH / 2) {
            Destroy (this.gameObject);
        }
    }
예제 #28
0
	protected IEnumerator computeState(){

		int counter = 0;
		while(true){
			if(pPhysics.climbing){
				currentState = movementState.CLIMBING;
			}

			switch(currentState){
			case movementState.IDLE:
				animater.animationID = 0;
				if(moveAmount.x != 0){
					currentState = movementState.WALKING;
				}
				if(!pPhysics.onGround && moveAmount.y != 0){
					currentState = movementState.JUMPING;
				}
				break;
			case movementState.JUMPING:
				animater.animationID = 2;
				if(pPhysics.onGround){
					currentState = movementState.WALKING;
				}
				break;
			case movementState.WALKING:
				animater.animationID = 1;
				if(!pPhysics.onGround && moveAmount.y != 0){
					currentState = movementState.JUMPING;
				}
				else{
					if(moveAmount.x == 0){
						currentState = movementState.IDLE;
					}
				}
				break;
			case movementState.CLIMBING:
				animater.animationID = 3;
				if(!pPhysics.climbing){
					currentState = movementState.WALKING;
				}
				break;
			}
			
			if(moveAmount.x < 0){
				right = false;
			}
			if(moveAmount.x > 0){
				right = true;
			}
			yield return null;
		}
	}
    void Update()
    {
        switch (thisMovementState)
        {
        case movementState.FreeMovement:
            //Do rotation
            float RSInput = Input.GetAxisRaw("RightStickX");
            if (RSInput != 0.0f)
            {
                Vector3    eulerAngleVelocity = new Vector3(0.0f, RSInput * maxRotationSpeed, 0.0f);
                Quaternion deltaRotation      = Quaternion.Euler(eulerAngleVelocity * Time.deltaTime);
                thisRB.MoveRotation(thisRB.rotation * deltaRotation);
            }

            //Do movement
            if (UseTriggerDownMovement)
            {
                float triggerInput          = 0.0f;
                float triggerInputConverted = 0.0f;
                if (UseController)
                {
                    triggerInput          = Input.GetAxisRaw("R2");
                    triggerInputConverted = (triggerInput + 1.0f) / 2.0f;     //ps4 trigger goes from -1.0 -> 1.0    >.<
                }
                else
                {
                    triggerInput = triggerInputConverted = Input.GetAxis("Down");
                }
                bool goingDown = triggerInput - prevTriggerInput >= 0.0f;
                prevTriggerInput = triggerInput;

                RaycastHit hit;
                Vector3    rayStartPoint = new Vector3(thisRB.position.x, startHeight, thisRB.position.z);
                if (Physics.Raycast(rayStartPoint, -Vector3.up, out hit))
                {
                    downMoveGrappleLength = hit.distance - downMoveLengthOffset;
                    if (downMoveGrappleLength > downMoveMaxLength)
                    {
                        downMoveGrappleLength = downMoveMaxLength;
                    }
                }

                float verticalTargetPos = startHeight - (triggerInputConverted * downMoveGrappleLength);
                if (goingDown && verticalTargetPos <= startHeight - downMoveGrappleLength + vertMoveEaseLength ||
                    ((!goingDown || triggerInputConverted == 0.0f) && verticalTargetPos >= startHeight - vertMoveEaseLength))
                {
                    float vertVel = verticalTargetPos - thisRB.position.y;
                    vertVel *= vertMoveEaseMultiplier;
                    float newPosY = thisRB.position.y + vertVel;
                    thisRB.MovePosition(new Vector3(thisRB.position.x, newPosY, thisRB.position.z));
                }
                else
                {
                    thisRB.MovePosition(new Vector3(thisRB.position.x, verticalTargetPos, thisRB.position.z));
                }
            }

            Vector3 movementInput = new Vector3(Input.GetAxis("Horizontal"), 0.0f, Input.GetAxis("Vertical"));
            movementInput.Normalize();
            movementInput *= maxMoveSpeed * Time.deltaTime;
            thisRB.MovePosition(thisRB.position + movementInput);

            //Check grapple button
            if (!UseTriggerDownMovement && Input.GetButtonDown("X"))
            {
                thisMovementState        = movementState.GrapplingDown;
                grappleReturnDestination = thisRB.position;
                grappleTargetDestination = thisRB.position + new Vector3(0.0f, -downMoveGrappleLength);
            }
            break;

        case movementState.GrapplingDown:
            //Do movement
            curVelocity = new Vector3(0.0f, -maxDownMoveSpeed);
            newPosition = thisRB.position + (curVelocity * Time.deltaTime);
            if (newPosition.y <= grappleTargetDestination.y)
            {
                thisRB.MovePosition(grappleTargetDestination);
                thisMovementState = movementState.ReturningUp;
            }
            else
            {
                thisRB.MovePosition(newPosition);
            }
            break;

        case movementState.ReturningUp:
            //Do movement
            curVelocity = new Vector3(0.0f, maxUpMoveSpeed);
            newPosition = thisRB.position + (curVelocity * Time.deltaTime);
            if (newPosition.y >= grappleReturnDestination.y)
            {
                thisRB.MovePosition(grappleReturnDestination);
                thisMovementState = movementState.FreeMovement;
            }
            else
            {
                thisRB.MovePosition(newPosition);
            }
            break;

        default:
            Debug.LogError("Grijper MovementState not set correctly!");
            break;
        }
    }
 void toggleCrawl() {
     if (move_state != movementState.CRAWL) {
         AudioController.audioPlayer.crouchSound();
         body.transform.position = new Vector3(body.transform.position.x, .25f, body.transform.position.z);
         if (move_state == movementState.AGAINST_WALL) {
             // Move off of the wall before lying down to crawl
             body.transform.position += body.transform.forward * (this.transform.localScale.y / 2f);
         }
         body.transform.Rotate(new Vector3(90f, 0f, 0f));
         move_state = movementState.CRAWL;
     } else if (!playerIsUnderObstacle()) {
         AudioController.audioPlayer.crouchSound();
         body.transform.position = new Vector3(body.transform.position.x, 1f, body.transform.position.z);
         body.transform.Rotate(new Vector3(-90f, 0f, 0f));
         move_state = movementState.RUN;
     } else
         AudioController.audioPlayer.cantSound();
 }
예제 #31
0
    private void FixedUpdate()
    {
        switch (movState)
        {
        case movementState.Walking:
            ResetHeight();
            ResetSpeed();
            sliding   = false;
            crouching = false;
            break;

        case movementState.Sprinting:
            Sprint();
            break;

        case movementState.Crouching:
            Crouch();
            sliding = false;
            break;

        case movementState.Slide:
            Slide();
            break;
        }
        #region Controls Inputs
        if (Input.GetButton("Horizontal") || Input.GetButton("Vertical"))
        {
            moveNextUpdate = true;
        }
        if (Input.GetAxis("Mouse X") != 0 || Input.GetAxis("Mouse Y") != 0)
        {
            rotateNextUpdate = true;
        }
        if (Input.GetButton("Jump"))
        {
            JumpNextUpdate = true;
        }
        if (Input.anyKey && isDead)
        {
            Restart();
        }

        if (Input.GetButton("Crouch"))
        {
            if (movState == movementState.Sprinting || sliding)
            {
                movState = movementState.Slide;
            }
            else if (movState == movementState.Walking || crouching)
            {
                movState = movementState.Crouching;
            }
        }
        else if (Input.GetButton("Sprint"))
        {
            movState = movementState.Sprinting;
        }
        else
        {
            movState = movementState.Walking;
        }
        #endregion
        #region Input Bools
        if (moveNextUpdate)
        {
            Move();
            moveNextUpdate = false;
        }
        if (rotateNextUpdate)
        {
            Rotate();
            rotateNextUpdate = false;
        }
        if (JumpNextUpdate)
        {
            Jump();
            JumpNextUpdate = false;
        }
        #endregion

        if (sliding)
        {
            slideSpeed = slideSpeed - 0.2f;
            slideSpeed = Mathf.Clamp(slideSpeed, 0, maxSlideSpeed);
            if (slideSpeed == 0)
            {
                movState = movementState.Crouching;
            }
        }
    }
 void OnTriggerExit(Collider col)
 {
     if(col.gameObject.tag == "Player"){
         myState = movementState.neutral;
     }
 }
예제 #33
0
		public void flipPlayer (float dir) {
			stateMethod = rotate;
			targetRot.eulerAngles = new Vector3 (transformObj.rotation.eulerAngles.x, transformObj.rotation.eulerAngles.y + (90), transformObj.rotation.eulerAngles.z);
		}
    void resolveGrab() {
        if (move_state == movementState.RUN) {
            body.velocity = Vector3.zero;
            RaycastHit hit_info;
            Ray facing = new Ray(transform.position - transform.forward, transform.forward);
            Debug.DrawRay(transform.position - transform.forward * 2, transform.forward, Color.blue, 2f);
            Debug.DrawRay(transform.position, transform.right, Color.green, 4f);

            if (Physics.SphereCast(facing, 1.1f, out hit_info, 2f, enemy_layer)) {
                victim = hit_info.rigidbody.gameObject;
                if (victim.GetComponent<Enemy>().current_state != EnemyState.KO &&
                        victim.GetComponent<Enemy>().current_state != EnemyState.BEING_FLIPPED && victim.GetComponent<Enemy>().current_state != EnemyState.DEAD) {
                    if (moveInput() && !body.isKinematic && !flip_lock)
                        throwEnemy();
                    else {
                        move_state = movementState.GRABBING;
                        victim.GetComponent<Enemy>().getGrabbed();
                    }
                }
            }
        } else if (move_state == movementState.GRABBING) {
            if (victim.GetComponent<Enemy>().current_state != EnemyState.GRABBED) {
                move_state = movementState.RUN;
            }
        }
    }
    void updateAgainstWall() {
        if (movingOppositeOfLockedDirection()) {
            locked_direction = Vector3.zero;
            move_state = movementState.RUN;
            return;
        }

        if (!movingInLockedDirection()) {
            this.transform.position += this.transform.forward * 0.5f;
            locked_direction = Vector3.zero;
            move_state = movementState.RUN;
        } else {
            zeroMovementInLockedDirection();
        }
    }
예제 #36
0
		private void checkGround() {
			RaycastHit hit;
			if (Physics.Raycast (transformObj.position, -transformObj.up, out hit, 1.0f)) {

				hit.collider.gameObject.SendMessage ("OnContact", transformObj.gameObject);
				stateMethod = idle;
			} else {
				stateMethod = idle;
			}
		}
예제 #37
0
	// Update is called once per frame
	void Update () {
        //grab the forwards vector for when the body is facedown (crawl state)
        Vector3 crawlForwardVector = findForwardCrawlVector();
        //Debug.DrawRay(body.transform.position, crawlForwardVector * 5f, Color.green);

        if (Input.GetKeyDown(KeyCode.I))
        {
            if(!bigBossMode)
            {
                bigBossMode = true;
                print("Invincibility Mode ACTIVATED!");
            } else
            {
                bigBossMode = false;
                print("Invincibility Mode DE-ACTIVATED!");
            }
        }

        if(currState == movementState.run || (inCrouchMode && currState == movementState.crawl) || currState == movementState.sneak)
        {
            if (Input.GetKeyDown(KeyCode.W))
            {
                print("Triangle Button: FPV Cam"); 
                FPVModeControl = true;
                CameraController.S.SwitchCameraTo(CameraType.fpv);
            }
            if (Input.GetKeyUp(KeyCode.W))
            {
                FPVModeControl = false;
                CameraController.S.SwitchCameraTo(CameraType.overhead);
            }
        }

        Vector3 vel = Vector3.zero;
		if (Input.GetKey (KeyCode.UpArrow)) {
			vel.z += 1;
		}
		if (Input.GetKey (KeyCode.DownArrow)) {
			vel.z -= 1;
		}
		if (Input.GetKey (KeyCode.LeftArrow)) {
			vel.x -= 1;
		}
		if (Input.GetKey (KeyCode.RightArrow)) {
			vel.x += 1;
		}

        if(HandController.S.isFighting || HandController.S.isFighting || FPVModeControl)
        {
            vel = Vector3.zero;
        }

        // begin of FPV mode control
        GameObject fpvcamera = CameraController.S.cameras[(int)CameraType.fpv];
        if (FPVModeControl)
        {
            //controls for FPV mode
            if(Input.GetKey(KeyCode.UpArrow))
            {
                Quaternion rot = Quaternion.Euler(-45f, 0f, 0f);
                fpvcamera.transform.localRotation = Quaternion.Slerp(fpvcamera.transform.localRotation, rot, .05f);
            }
            if (Input.GetKey(KeyCode.DownArrow))
            {
                Quaternion rot = Quaternion.Euler(45f, 0f, 0f);
                fpvcamera.transform.localRotation = Quaternion.Slerp(fpvcamera.transform.localRotation, rot, .05f);
            }

            if (Input.GetKey(KeyCode.LeftArrow))
            {
                lastFPVForward = (new Vector3(0f, -FPVRotationSpeedDeg, 0f));
            }
            else if (Input.GetKey(KeyCode.RightArrow))
            {
                lastFPVForward = (new Vector3(0f, FPVRotationSpeedDeg, 0f));
            }
            else
            {
                if (timeTillTurnUpdate <= 0)
                {
                    lastFPVForward *= FPVRotationDecel;
                }
            }

            if (timeTillTurnUpdate > 0)
            {
                timeTillTurnUpdate -= Time.deltaTime;
            }
            else
            {
                timeTillTurnUpdate = 1f / 60f;
                body.transform.Rotate(lastFPVForward);
            }
        }
        if (fpvcamera.transform.localRotation != defaultFPVCameraAngle && !Input.GetKey(KeyCode.UpArrow) && !Input.GetKey(KeyCode.UpArrow))
        {
            fpvcamera.transform.localRotation = Quaternion.Slerp(fpvcamera.transform.localRotation, defaultFPVCameraAngle, .05f);
        }

        //perform wall stick sneak movements
        if (currState == movementState.sneak) {
			if (Vector3.Dot (vel, gameObject.transform.forward) > 0 && Vector3.Angle (vel, gameObject.transform.forward) < 90) {
				if (inCrouchMode) {
					currState = movementState.crawl;
					gameObject.transform.position += vel.normalized * sneakCrouchWallBuffer;
				} else {
					currState = movementState.run;
				}
				collided = collideToStick;
                collided2 = collideToStick * 2;
            } else if (!doubleRaycast (gameObject.transform.position, -body.transform.forward, (gameObject.transform.lossyScale.z / 2) + .2f)) {
				if (inCrouchMode) {
					currState = movementState.crawl;
					gameObject.transform.position += vel.normalized * sneakCrouchWallBuffer;
				} else {
					currState = movementState.run;
				}
				collided = collideToStick;
                collided2 = collideToStick * 2;
            } else if (inCrouchMode) {
				vel = Vector3.zero;
			} else if (moveLock == movementLock.LR) {
				vel.x = 0;
			} else if (moveLock == movementLock.FB) {
				vel.z = 0;
			} 

			// SNEAK CAM CODE START

			// If sneaking, then check to see if you're at an edge
			Vector3 leftPosition, rightPosition;
			bool leftEdge, rightEdge;
			RaycastHit leftHit, rightHit;
			rightPosition = body.transform.position + body.transform.right + (body.transform.forward * -1);
			leftPosition = body.transform.position + (-1 * body.transform.right) + (body.transform.forward * -1);
			rightPosition.y += 3f;
			leftPosition.y += 3f;

			// Debug rays
			Debug.DrawRay (rightPosition, new Vector3(0f,-4f,0f));
			Debug.DrawRay (leftPosition, new Vector3(0f,-4f, 0f));

			// 	change camera position to sneak cam position
			// If either of the raycasts don't hit anything, then player is at an edge
			leftEdge = Physics.Raycast (leftPosition, new Vector3(0f,-1f,0f), out leftHit, 4f);
			rightEdge = Physics.Raycast (rightPosition, new Vector3(0f,-1f,0f), out rightHit, 4f);

			if (leftEdge) {
				if (leftHit.collider.tag != "Floor")
					leftEdge = false;
			}
			if (rightEdge) {
				if (rightHit.collider.tag != "Floor")
					rightEdge = false;
			}

			if (leftEdge && rightEdge) {
				CameraController.S.GetComponent<CameraFollow> ().activateSneakCam (3, leftPosition+rightPosition);
			} else if (leftEdge) {
				CameraController.S.GetComponent<CameraFollow> ().activateSneakCam (0, leftPosition);
			} else if (rightEdge) {
				CameraController.S.GetComponent<CameraFollow> ().activateSneakCam (1, rightPosition);
			}
			// Otherwise, you're not at an edge
			else {
				// Change camera position back to normal
				CameraController.S.GetComponent<CameraFollow> ().deactivateSneakCam ();
			}

			// SNEAK CAM CODE END
		} 
		// Also make sure that cam is deactivated to default once you leave sneak
		else {
			CameraController.S.GetComponent<CameraFollow> ().deactivateSneakCam ();
		}

		// Save the last known button press direction
		if (vel != Vector3.zero)
			lastVel = vel;

        //CROUCH logic: transform snake back to normal if he moves
        if(inCrouchMode && vel != Vector3.zero)
        {
            body.transform.localScale = defaultPlayerSize;
            //check for nearby walls so we don't clip inside them
            Ray frontray = new Ray(body.transform.position, body.transform.forward);
            //Ray buttray = new Ray(body.transform.position, -body.transform.forward);
            if (Physics.Raycast(frontray, body.transform.lossyScale.y / 2f, wallLayerMask))
            {
                Vector3 safePos = gameObject.transform.position;
                safePos += -body.transform.forward.normalized * ((body.transform.lossyScale.y / 2f) + .1f);
                safePos.y = .2f;
                body.transform.position = safePos;
            }
            else
            {
                body.transform.position = new Vector3(body.transform.position.x, 0.2f, body.transform.position.z);
            }

            body.transform.rotation = Quaternion.LookRotation(vel.normalized);
            body.transform.Rotate(new Vector3(90f, 0f, 0f));

            inCrouchMode = false;
        }

        //CRAWL box collider, shrink down the box collider when in crawl mode
        if(currState == movementState.crawl && !inCrouchMode)
        {
            boxcollider.size = new Vector3(boxcollider.size.x, 1f, boxcollider.size.z);
            boxcollider.center = new Vector3(boxcollider.center.x, .3f, boxcollider.center.z);
        } else
        {
            boxcollider.size = defaultBoxColliderSize;
            boxcollider.center = new Vector3(boxcollider.center.x, .15f, boxcollider.center.z);
        }

        //MOVEMENT of the Character
        // Speed and direction of movement depends on movementState
        if (inFPVModeCrawlTransition > 0 && currState == movementState.crawl)
        {
            inFPVModeCrawlTransition -= Time.deltaTime;
            body.velocity = lastForwardCrawlVector;
        } else if(HandController.S.isFighting || HandController.S.isGrabbing)
        {
            //don't set velocity here
        } else if (currState == movementState.run) {
			body.velocity = vel.normalized * speed;
		} else if(!FPVModeCrawlControl) {
			body.velocity = vel.normalized * slowSpeed;
		} else 
        //first person crawl mode uses a different set of controls
        if(FPVModeCrawlControl)
        {
            if (Input.GetKey(KeyCode.UpArrow))
            {
                body.velocity = crawlForwardVector * slowSpeed;
            }
            if (Input.GetKey(KeyCode.DownArrow))
            {
                body.velocity = -crawlForwardVector * slowSpeed;
            }

            if (Input.GetKey(KeyCode.LeftArrow))
            {
                lastCrawlTurnVector = (new Vector3(0f, 0f, FPVRotationSpeedDeg));
            }
            else if (Input.GetKey(KeyCode.RightArrow))
            {
                lastCrawlTurnVector = (new Vector3(0f, 0f, -FPVRotationSpeedDeg));
            }
            else
            {
                if(timeTillTurnUpdate <= 0)
                {
                    lastCrawlTurnVector *= FPVRotationDecel;
                }
            }

            if (timeTillTurnUpdate > 0)
            {
                timeTillTurnUpdate -= Time.deltaTime;
            }
            else
            {
                timeTillTurnUpdate = 1f / 60f;
                body.transform.Rotate(lastCrawlTurnVector);
            }
        }// end of FPV mode crawl control

        //ROTATIONS, face character towards the vector of movement:
        //set our foward direction if in run state (run rotation)
        if (currState == movementState.run && !FPVModeControl)
        {
            if (Vector3.Angle(body.transform.forward, lastVel.normalized) > 45f)
            {
                body.velocity = Vector3.zero;
            }

            // Lerp for smooth rotation
            body.transform.rotation = Quaternion.LookRotation(Vector3.Slerp(body.transform.forward, lastVel.normalized, rotationSpeed));
            //body.transform.rotation = Quaternion.LookRotation(lastVel.normalized);	
        }
        else //set look direction in crawl mode, unless snake is backing up, or in FPV Crawl mode
        if (currState == movementState.crawl && !FPVModeCrawlControl && !FPVModeControl && inFPVModeCrawlTransition <= 0)
        {
            if (vel != Vector3.zero)
            {
                body.transform.Rotate(new Vector3(90f, 0f, 0f));

                float velAngleFromCurrent = Vector3.Angle(body.transform.forward, vel);

                //dont turn snake around if its within 45 degrees
                if (Mathf.Abs(velAngleFromCurrent - 0f) <= 50f)
                {
                    //body.transform.Rotate(new Vector3(-90f, 0f, 0f));
                    body.transform.rotation = Quaternion.LookRotation(vel.normalized);
                    body.transform.Rotate(new Vector3(90f, 180f, 0f));
                }
                else
                {
                    body.transform.rotation = Quaternion.LookRotation(vel.normalized);
                    body.transform.Rotate(new Vector3(90f, 0f, 0f));
                }
            }
        }

        //Crouch toggle behavior
		if(Input.GetKeyDown(KeyCode.A))
		{
            if(inCrouchMode)
            {
                inCrouchMode = false;
                body.transform.localScale = defaultPlayerSize;
                if(currState != movementState.sneak)
                {
                    currState = movementState.run;
                }
            }
			else if (currState == movementState.run || currState == movementState.sneak)
			{
				//body.transform.Rotate(new Vector3(90f, 0f, 0f));

				//				body.transform.Rotate( Vector3.Lerp (Vector3.zero, new Vector3 (90f, 0f, 0f), 0.5f));
				//
				body.transform.position = new Vector3(body.transform.position.x, .25f, body.transform.position.z);

                Vector3 crouchSize = body.transform.localScale;
                crouchSize.y = crouchHeight;
                body.transform.localScale = crouchSize;
                inCrouchMode = true;

                //special case when sneaking against wall
                if(currState == movementState.sneak)
                {
                    currState = movementState.sneak;
                } else
                {
                    currState = movementState.crawl;
                }

			} else if(currState == movementState.crawl && !FPVModeCrawlControl && inFPVModeCrawlTransition <= 0)
			{
				body.transform.Rotate(new Vector3(-90f, 0f, 0f));
				body.transform.position = new Vector3(body.transform.position.x, .5f, body.transform.position.z);
				currState = movementState.run;
			}
		}

        //RAYCAST behaviors:
        //SNEAK Wall Detection
        if (vel != Vector3.zero)
        {
            //check for wall collision to stick to
            if (doubleRaycast(gameObject.transform.position, body.transform.forward, (gameObject.transform.lossyScale.z / 2) + 0.2f) && collided2 > 0)
            {
                collided2 -= Time.deltaTime;
            }
            else if (collided2 < 0 && currState == movementState.run)
            {
                // Flips character
                body.transform.rotation = Quaternion.LookRotation(vel.normalized);
                gameObject.transform.forward *= -1;
                currState = movementState.sneak;

                if (gameObject.transform.forward.x != 0)
                {
                    moveLock = movementLock.LR;
                }
                else if (gameObject.transform.forward.z != 0)
                {
                    moveLock = movementLock.FB;
                }
            }
        }

        //CRAWL modes DETECTION
        if (currState == movementState.crawl && !inCrouchMode)
        {
            //Check FPVModeCrawl State, aka if snake crawls under enclosed space, switch mode and camera
            if (Physics.Raycast(gameObject.transform.position, -body.transform.forward, (gameObject.transform.lossyScale.z / 2) + 1.0f, wallLayerMask))
            {
                if (!FPVModeCrawlControl)
                {
                    // Should only be FPV-Crawl when you cannot stand up aka crawling in a 1 meter tall tunnel
                    CameraController.S.SwitchCameraTo(CameraType.crawl);
                    FPVModeCrawlControl = true;
                    inFPVModeCrawlTransition = ToFPVModeTransitionTime;
                    lastForwardCrawlVector = body.velocity;
                }
            } else {
                if(FPVModeCrawlControl)
                {
                    CameraController.S.SwitchCameraTo(CameraType.overhead);
                    FPVModeCrawlControl = false;
                    inFPVModeCrawlTransition = FromFPVModeTransitionTime;
                    lastForwardCrawlVector = body.velocity;
                }
            }

            if(!FPVModeCrawlControl && !inCrouchMode)
            {
                Ray headray = new Ray(gameObject.transform.position, crawlForwardVector);
                RaycastHit hit;
                //Debug.DrawRay(gameObject.transform.position, crawlForwardVector * ((gameObject.transform.lossyScale.y / 2) + 0.4f), Color.green);
                if (Physics.Raycast(headray, out hit, ((gameObject.transform.lossyScale.y / 2) + 0.4f), wallLayerMask) && collided > 0)
                {
                    collided -= Time.deltaTime;
                }
                else if (collided < 0)
                {
                    // Flips character
                    body.transform.rotation = Quaternion.LookRotation(vel.normalized);
                    gameObject.transform.forward = -crawlForwardVector;
                    currState = movementState.sneak;

                    Vector3 newPos = hit.point;
                    if(hit.point != Vector3.zero)
                    {
                        newPos += -crawlForwardVector.normalized * ((gameObject.transform.lossyScale.y / 4));
                    } else
                    {
                        newPos = gameObject.transform.position;
                    }
                    print(hit.point);
                    
                    gameObject.transform.position = newPos;

                    Vector3 crouchSize = body.transform.localScale;
                    crouchSize.y = crouchHeight;
                    body.transform.localScale = crouchSize;
                    inCrouchMode = true;

                    if (gameObject.transform.forward.x != 0)
                    {
                        moveLock = movementLock.LR;
                    }
                    else if (gameObject.transform.forward.z != 0)
                    {
                        moveLock = movementLock.FB;
                    }

                    body.velocity = Vector3.zero;
                }

                Ray buttray = new Ray(gameObject.transform.position, -crawlForwardVector);
                RaycastHit hit2;
                Debug.DrawRay(gameObject.transform.position, -crawlForwardVector * (gameObject.transform.lossyScale.y / 4), Color.green);
                if (Physics.Raycast(buttray, out hit2, (gameObject.transform.lossyScale.y / 4), wallLayerMask) && collided2 > 0)
                {
                    collided2 -= Time.deltaTime;
                }
                else if (collided2 < 0)
                {
                    // Flips character
                    body.transform.rotation = Quaternion.LookRotation(vel.normalized);
                    gameObject.transform.forward = crawlForwardVector;
                    currState = movementState.sneak;

                    Vector3 newPos = hit2.point;
                    if(newPos != Vector3.zero)
                    {
                        newPos += crawlForwardVector.normalized * ((gameObject.transform.lossyScale.y / 4));
                    } else
                    {
                        newPos = gameObject.transform.position;
                    }
                    gameObject.transform.position = newPos;

                    Vector3 crouchSize = body.transform.localScale;
                    crouchSize.y = crouchHeight;
                    body.transform.localScale = crouchSize;
                    inCrouchMode = true;

                    if (gameObject.transform.forward.x != 0)
                    {
                        moveLock = movementLock.LR;
                    }
                    else if (gameObject.transform.forward.z != 0)
                    {
                        moveLock = movementLock.FB;
                    }
                }
            }
        }
        //CRAWL modes DETECTION END
    }
    // Update is called once per frame
    void Update() {
        if (seen)
            return;
        if (spawning_player) {
            growSpawnSphere();
        }
        if (unspawning_player) {
            shrinkSpawnSphere();
        }
        if (invincible_delay > 0) {
            invincible_delay -= Time.deltaTime;
            if (invincible_delay < 0)
                invincible_delay = 0;
        }
        if (Input.GetKey(GOD_KEY) && invincible_delay == 0) {
            god_mode = !god_mode;
            invincible_delay = 0.5f;
            GameObject head = gameObject.transform.GetChild(0).gameObject;
            if (god_mode) {
                head.GetComponent<Renderer>().material = spawn_sphere_material;
            } else {
                head.GetComponent<Renderer>().material = head_material;
            }
        }
        if (!CameraController.cam_control.playerHasControl() || CameraController.cam_control.game_paused) {
            body.velocity = Vector3.zero;
            return;
        }

        if (move_state == movementState.GRABBING) {
            resolveGrab();
        }
        if (knock_lock || flip_lock) {
            return;
        }

        if (!lockControlsIfNeeded()) {
            if (under_obstacle_last_frame) {
                updateUnderObstacleTransformFromInput();
            } else {
                setVelocityFromInput();
                updateWallMovement();
                updateForwardDirection();
            }
        }

        keepPlayerWithinPositionLimits();

        if (Input.GetKey(KNOCK_KEY)) {
            if (!knock_lock) {
                body.velocity = Vector3.zero;
                if (movementState.AGAINST_WALL == move_state) {
                    knock_lock = true;
                    Knock();
                } else {
                    punchCheck();
                }
                Invoke("unlockKnock", 0.3f); //prevents knock spam
            }
        }

        if (Input.GetKey(GRAB_KEY)) {
            if (choke_timer <= 0) {
                resolveGrab();
                if (move_state == movementState.GRABBING) {
                    choke_count++;
                    AudioController.audioPlayer.chokeSound();
                    body.velocity = Vector3.zero;
                    knock_lock = true;
                    victim.GetComponent<Rigidbody>().AddForceAtPosition(victim.transform.forward * -87, victim.transform.position + victim.transform.up);
                    Invoke("unlockKnock", 0.1f);
                }
                choke_timer = 0.1f;
            } else {
                choke_timer -= Time.deltaTime;
            }
            if (choke_count > 10) {
                victim.GetComponent<Enemy>().die();
                choke_count = 0;
                move_state = movementState.RUN;
            }

        }

        if (Input.GetKeyDown(CRAWL_KEY)) {
            toggleCrawl();
        }

        adjustCamera();
        adjustPlayerCollider();
        velocity_last_frame = body.velocity;
        if (body.velocity.magnitude > 0) {
            if (move_state == movementState.RUN || move_state == movementState.ALONG_WALL) {
                AudioController.audioPlayer.stepSound();
            } else if (move_state == movementState.CRAWL) {
                AudioController.audioPlayer.crawlSound();
            }
        }
    }
예제 #39
0
    //Determines the current movement state and what it should transition to
    protected IEnumerator computeState()
    {
        if (digging)
        {
            currentState = movementState.DIGGING;
        }

        int counter = 0;

        while (true)
        {
            switch (currentState)
            {
            case movementState.IDLE:
                animater.animationID = 2;
                if (currentMovement.x != 0)
                {
                    currentState = movementState.WALKING;
                }
                break;

            case movementState.JUMPING:
                if (cc.isGrounded)
                {
                    currentState = movementState.WALKING;
                    counter      = (int)landingDelay;
                }
                break;

            case movementState.CLIMBING:
                //TODO Set animation
                break;

            case movementState.WALKING:
                animater.animationID = 1;
                if (currentMovement.x == 0)
                {
                    currentState = movementState.IDLE;
                }
                break;

            case movementState.DIGGING:
                animater.animationID = 0;
                emitParticles();
                if (!digging)
                {
                    currentState = movementState.IDLE;
                }
                break;
            }

            if (currentMovement.x < 0)
            {
                right = false;
            }
            if (currentMovement.x > 0)
            {
                right = true;
            }
            yield return(null);
        }
    }
예제 #40
0
    // Update is called once per frame
    void Update()
    {
        timer  += Time.deltaTime;
        uTimer += Time.fixedDeltaTime;
        if (slow)
        {
            if (uTimer > 2)
            {
                slow = false;
                SceneManager.LoadScene("CombatTest");
            }
        }


        RaycastHit2D hit = Physics2D.Raycast(block.transform.position, -Vector2.up, 10);

        distance = (transform.position - player.transform.position).magnitude;

        switch (currentState)
        {
        case movementState.LEFT:
            if (!sleeping)
            {
                if (hit.collider != null)
                {
                    anim.SetInteger("Riding", 1);
                    ride = true;
                    dir  = -1f;
                }
                else if (hit.collider == null)
                {
                    anim.SetInteger("Riding", 0);
                    ride = false;
                    transform.position += Vector3.right * 10 * Time.deltaTime;
                    currentState        = movementState.RIGHT;
                }
                transform.localScale = new Vector3(-0.5f, 0.5f, 1);
            }
            break;

        case movementState.RIGHT:
            if (!sleeping)
            {
                if (hit.collider != null)
                {
                    anim.SetInteger("Riding", 1);
                    ride = true;
                    dir  = 1f;
                }
                else if (hit.collider == null)
                {
                    anim.SetInteger("Riding", 0);
                    ride = false;
                    transform.position += -Vector3.right * 10 * Time.deltaTime;
                    currentState        = movementState.LEFT;
                }
                transform.localScale = new Vector3(0.5f, 0.5f, 1);
            }
            break;

        case movementState.FOLLOW:
            if (!sleeping)
            {
                if (player.transform.position.x > transform.position.x)
                {
                    transform.localScale = new Vector3(0.5f, 0.5f, 1);
                    if (hit.collider != null)
                    {
                        anim.SetInteger("Riding", 1);
                        ride = true;
                        dir  = 1f;
                    }
                    if (hit.collider == null)
                    {
                        anim.SetInteger("Riding", 0);
                        rb.velocity = new Vector2(0, rb.velocity.y);
                        ride        = false;
                    }
                }
                if (player.transform.position.x < transform.position.x)
                {
                    if (hit.collider != null)
                    {
                        anim.SetInteger("Riding", 1);
                        ride = true;
                        dir  = -1f;
                    }
                    transform.localScale = new Vector3(-0.5f, 0.5f, 1);
                    if (hit.collider == null)
                    {
                        anim.SetInteger("Riding", 0);
                        rb.velocity = new Vector2(0, rb.velocity.y);
                        ride        = false;
                    }
                }

                if (player.transform.position.y > transform.position.y + 1)
                {
                    if (grounded)
                    {
                        if (jumpReady)
                        {
                            anim.SetInteger("Riding", 3);
                            anim.SetTrigger("Jumping");
                            jumpReady = false;
                            rb.AddForce(Vector2.up * jumpForce);
                        }
                    }
                }
                else
                {
                    if (grounded)
                    {
                        jumpReady = true;
                    }
                }
                if (shoot && !sleeping)
                {
                    if (timer >= 5)
                    {
                        GameObject projectile = Instantiate(electroBall, spawnPoint.transform.position, spawnPoint.transform.rotation);
                        if (transform.localScale.x == 0.5f)
                        {
                            projectile.GetComponent <Projectile>().travelSpeed = 6;
                        }
                        if (transform.localScale.x == -0.5f)
                        {
                            projectile.GetComponent <Projectile>().travelSpeed = -6;
                        }
                        Destroy(projectile, 5f);
                        timer = 0;
                    }
                }
            }
            break;

        case movementState.SLEEP:
            anim.SetInteger("Riding", 9);
            break;
        }

        if (hit.collider != null)
        {
            if (hit.collider.gameObject.tag == "Ground")
            {
                if (distance < 12)
                {
                    currentState = movementState.FOLLOW;
                }
                else
                {
                    Search();
                }
            }
        }
    }
    // Update is called once per frame
    void Update()
    {
        if (seen)
        {
            return;
        }
        if (spawning_player)
        {
            growSpawnSphere();
        }
        if (unspawning_player)
        {
            shrinkSpawnSphere();
        }
        if (invincible_delay > 0)
        {
            invincible_delay -= Time.deltaTime;
            if (invincible_delay < 0)
            {
                invincible_delay = 0;
            }
        }
        if (Input.GetKey(GOD_KEY) && invincible_delay == 0)
        {
            god_mode         = !god_mode;
            invincible_delay = 0.5f;
            GameObject head = gameObject.transform.GetChild(0).gameObject;
            if (god_mode)
            {
                head.GetComponent <Renderer>().material = spawn_sphere_material;
            }
            else
            {
                head.GetComponent <Renderer>().material = head_material;
            }
        }
        if (!CameraController.cam_control.playerHasControl() || CameraController.cam_control.game_paused)
        {
            body.velocity = Vector3.zero;
            return;
        }

        if (move_state == movementState.GRABBING)
        {
            resolveGrab();
        }
        if (knock_lock || flip_lock)
        {
            return;
        }

        if (!lockControlsIfNeeded())
        {
            if (under_obstacle_last_frame)
            {
                updateUnderObstacleTransformFromInput();
            }
            else
            {
                setVelocityFromInput();
                updateWallMovement();
                updateForwardDirection();
            }
        }

        keepPlayerWithinPositionLimits();

        if (Input.GetKey(KNOCK_KEY))
        {
            if (!knock_lock)
            {
                body.velocity = Vector3.zero;
                if (movementState.AGAINST_WALL == move_state)
                {
                    knock_lock = true;
                    Knock();
                }
                else
                {
                    punchCheck();
                }
                Invoke("unlockKnock", 0.3f); //prevents knock spam
            }
        }

        if (Input.GetKey(GRAB_KEY))
        {
            if (choke_timer <= 0)
            {
                resolveGrab();
                if (move_state == movementState.GRABBING)
                {
                    choke_count++;
                    AudioController.audioPlayer.chokeSound();
                    body.velocity = Vector3.zero;
                    knock_lock    = true;
                    victim.GetComponent <Rigidbody>().AddForceAtPosition(victim.transform.forward * -87, victim.transform.position + victim.transform.up);
                    Invoke("unlockKnock", 0.1f);
                }
                choke_timer = 0.1f;
            }
            else
            {
                choke_timer -= Time.deltaTime;
            }
            if (choke_count > 10)
            {
                victim.GetComponent <Enemy>().die();
                choke_count = 0;
                move_state  = movementState.RUN;
            }
        }

        if (Input.GetKeyDown(CRAWL_KEY))
        {
            toggleCrawl();
        }

        adjustCamera();
        adjustPlayerCollider();
        velocity_last_frame = body.velocity;
        if (body.velocity.magnitude > 0)
        {
            if (move_state == movementState.RUN || move_state == movementState.ALONG_WALL)
            {
                AudioController.audioPlayer.stepSound();
            }
            else if (move_state == movementState.CRAWL)
            {
                AudioController.audioPlayer.crawlSound();
            }
        }
    }
예제 #42
0
	//Determines the current movement state and what it should transition to
	protected IEnumerator computeState(){
		
		if(digging){
			currentState = movementState.DIGGING;
			animater.animationID = 0;
		}
		
		int counter = 0;
		while(true){
			switch(currentState){
			case movementState.IDLE:
				if(currentMovement.x != 0){
					currentState = movementState.WALKING;
					animater.animationID = 1;
				}
				break;
			case movementState.JUMPING:
				if(onGround){
					currentState = movementState.WALKING;
					animater.animationID = 1;
				}
				break;
			case movementState.LANDING:
				counter --;
				if(counter == 0){
					currentState = movementState.WALKING;
					animater.animationID = 1;
				}
				break;
			case movementState.WALKING:
				if(!onGround && currentMovement.y != 0){
					currentState = movementState.JUMPING;
				}
				else{
					if(currentMovement.x == 0){
						currentState = movementState.IDLE;
						animater.animationID = 2;
					}
				}
				break;
			case movementState.DIGGING:
				animater.animationID = 0;
				if(!digging){
					currentState = movementState.IDLE;
					animater.animationID = 1;
				}
				break;
			}
			
			if(currentMovement.x < 0){
				right = false;
			}
			if(currentMovement.x > 0){
				right = true;
			}
			yield return null;
		}
	}
예제 #43
0
    //Determines the current movement state and what it should transition to
    protected IEnumerator computeState()
    {
        if (digging)
        {
            currentState         = movementState.DIGGING;
            animater.animationID = 0;
        }

        int counter = 0;

        while (true)
        {
            switch (currentState)
            {
            case movementState.IDLE:
                if (currentMovement.x != 0)
                {
                    currentState         = movementState.WALKING;
                    animater.animationID = 1;
                }
                break;

            case movementState.JUMPING:
                if (onGround)
                {
                    currentState         = movementState.WALKING;
                    animater.animationID = 1;
                }
                break;

            case movementState.LANDING:
                counter--;
                if (counter == 0)
                {
                    currentState         = movementState.WALKING;
                    animater.animationID = 1;
                }
                break;

            case movementState.WALKING:
                if (!onGround && currentMovement.y != 0)
                {
                    currentState = movementState.JUMPING;
                }
                else
                {
                    if (currentMovement.x == 0)
                    {
                        currentState         = movementState.IDLE;
                        animater.animationID = 2;
                    }
                }
                break;

            case movementState.DIGGING:
                animater.animationID = 0;
                if (!digging)
                {
                    currentState         = movementState.IDLE;
                    animater.animationID = 1;
                }
                break;
            }

            if (currentMovement.x < 0)
            {
                right = false;
            }
            if (currentMovement.x > 0)
            {
                right = true;
            }
            yield return(null);
        }
    }
    void updateAlongWall() {
        if (movingInLockedDirection()) {
            if (!movingDiagonal()) {
                move_state = movementState.AGAINST_WALL;
                body.transform.rotation = Quaternion.LookRotation(locked_direction * -1);
                moveBackAgainstWall();
            }
            zeroMovementInLockedDirection();

        } else if (movingOppositeOfLockedDirection()) {
            locked_direction = Vector3.zero;
            move_state = movementState.RUN;
        }
    }
    void OnCollisionEnter(Collision coll) {
        Vector3 pos;

        if (coll.gameObject.tag == "Obstacle" && move_state == movementState.RUN) {
            foreach (ContactPoint contact in coll.contacts) {
                if (contact.normal.x != 0 || contact.normal.z != 0) {
                    locked_direction = coll.contacts[0].normal * -1;
                    locked_direction.y = 0;
                    break;
                }
            }
            if (locked_direction.x != 0 && locked_direction.z != 0) {
                hit_corner = true;
                locked_direction.z = 0;
                pos = this.transform.position;
                pos.x += locked_direction.x * -0.5f;
                pos.z += body.velocity.normalized.z * -0.5f;
                this.transform.position = pos;
            }

            if (movingDiagonal()) {
                move_state = movementState.ALONG_WALL;
            } else {
                move_state = movementState.AGAINST_WALL;
                body.transform.rotation = Quaternion.LookRotation(coll.contacts[0].normal);
            }
        }
    }
예제 #46
0
		public void Start() {
			targetPos = transformObj.position;
			targetRot = transformObj.localRotation;
			transformObj.position = targetPos;
			stateMethod = idle;
		}
예제 #47
0
	//****************************************************************************//

	void walkcase(IVector2 currentpos,IVector2 dest,ParentedNode node,Vector2 v){
		if((v.y > .25f && Mathf.Abs(v.x) < .1f) || (map.getForeground(currentpos) == TileSpecList.getTileSpec(LADDERINDEX) && canLadder)){
			laddercase(currentpos,dest,node,v);
			return;
		}
		currentState = movementState.WALKING;
		if(v.y > .25f && (Mathf.Abs(v.x) > .1f && cc.velocity.x == 0)){// || (lastPosition - currentpos).magnitude == 0){
			Debug.Log("Jumping");
			jump ();
			currentState = movementState.JUMPING;
		}
	}
 void updateWallMovement() {
     if (nextToObstacle() || hit_corner) {
         hit_corner = false;
         if (move_state == movementState.ALONG_WALL) {
             updateAlongWall();
         } else if (move_state == movementState.AGAINST_WALL) {
             updateAgainstWall();
         }
     } else if (move_state != movementState.CRAWL && move_state != movementState.GRABBING) {
         move_state = movementState.RUN;
         locked_direction = Vector3.zero;
     }
 }
예제 #49
0
	void ladderTile(IVector2 t){
		if(!canLadder)
			return;
		currentState = movementState.CLIMBING;
		TileSpec ts = map.getForeground(t);
		if(!ts.solid && ts != TileSpecList.getTileSpec(LADDERINDEX)){
			map.setTile(t,(byte)LADDERINDEX,(byte)1);
		}
	}
예제 #50
0
		private void bump() {

			if (input.verticalInput == 0) {
				stateMethod = idle;
			}
		}
예제 #51
0
	//Handles the character digging.
	public void handleDigging(Vector2 dest,Vector2 v){
		if(digging){
			this.currentState = movementState.DIGGING;
			if(v.y < -.25){
				jump(.75f);
				emitParticles();
			}
			//If it is done digging
			if((digTimer -= Time.fixedDeltaTime) <= 0){
				mine (dest);
			}
		}
		//Detect if it needs to start digging
		else if(map.isForegroundSolid(dest)){
			digTimer = digTime;
			digging = true;
		}
	}
예제 #52
0
    // Update is called once per frame
    void Update()
    {
        //grab the forwards vector for when the body is facedown (crawl state)
        Vector3 crawlForwardVector = findForwardCrawlVector();

        //Debug.DrawRay(body.transform.position, crawlForwardVector * 5f, Color.green);

        if (Input.GetKeyDown(KeyCode.I))
        {
            if (!bigBossMode)
            {
                bigBossMode = true;
                print("Invincibility Mode ACTIVATED!");
            }
            else
            {
                bigBossMode = false;
                print("Invincibility Mode DE-ACTIVATED!");
            }
        }

        if (currState == movementState.run || (inCrouchMode && currState == movementState.crawl) || currState == movementState.sneak)
        {
            if (Input.GetKeyDown(KeyCode.W))
            {
                print("Triangle Button: FPV Cam");
                FPVModeControl = true;
                CameraController.S.SwitchCameraTo(CameraType.fpv);
            }
            if (Input.GetKeyUp(KeyCode.W))
            {
                FPVModeControl = false;
                CameraController.S.SwitchCameraTo(CameraType.overhead);
            }
        }

        Vector3 vel = Vector3.zero;

        if (Input.GetKey(KeyCode.UpArrow))
        {
            vel.z += 1;
        }
        if (Input.GetKey(KeyCode.DownArrow))
        {
            vel.z -= 1;
        }
        if (Input.GetKey(KeyCode.LeftArrow))
        {
            vel.x -= 1;
        }
        if (Input.GetKey(KeyCode.RightArrow))
        {
            vel.x += 1;
        }

        if (HandController.S.isFighting || HandController.S.isFighting || FPVModeControl)
        {
            vel = Vector3.zero;
        }

        // begin of FPV mode control
        GameObject fpvcamera = CameraController.S.cameras[(int)CameraType.fpv];

        if (FPVModeControl)
        {
            //controls for FPV mode
            if (Input.GetKey(KeyCode.UpArrow))
            {
                Quaternion rot = Quaternion.Euler(-45f, 0f, 0f);
                fpvcamera.transform.localRotation = Quaternion.Slerp(fpvcamera.transform.localRotation, rot, .05f);
            }
            if (Input.GetKey(KeyCode.DownArrow))
            {
                Quaternion rot = Quaternion.Euler(45f, 0f, 0f);
                fpvcamera.transform.localRotation = Quaternion.Slerp(fpvcamera.transform.localRotation, rot, .05f);
            }

            if (Input.GetKey(KeyCode.LeftArrow))
            {
                lastFPVForward = (new Vector3(0f, -FPVRotationSpeedDeg, 0f));
            }
            else if (Input.GetKey(KeyCode.RightArrow))
            {
                lastFPVForward = (new Vector3(0f, FPVRotationSpeedDeg, 0f));
            }
            else
            {
                if (timeTillTurnUpdate <= 0)
                {
                    lastFPVForward *= FPVRotationDecel;
                }
            }

            if (timeTillTurnUpdate > 0)
            {
                timeTillTurnUpdate -= Time.deltaTime;
            }
            else
            {
                timeTillTurnUpdate = 1f / 60f;
                body.transform.Rotate(lastFPVForward);
            }
        }
        if (fpvcamera.transform.localRotation != defaultFPVCameraAngle && !Input.GetKey(KeyCode.UpArrow) && !Input.GetKey(KeyCode.UpArrow))
        {
            fpvcamera.transform.localRotation = Quaternion.Slerp(fpvcamera.transform.localRotation, defaultFPVCameraAngle, .05f);
        }

        //perform wall stick sneak movements
        if (currState == movementState.sneak)
        {
            if (Vector3.Dot(vel, gameObject.transform.forward) > 0 && Vector3.Angle(vel, gameObject.transform.forward) < 90)
            {
                if (inCrouchMode)
                {
                    currState = movementState.crawl;
                    gameObject.transform.position += vel.normalized * sneakCrouchWallBuffer;
                }
                else
                {
                    currState = movementState.run;
                }
                collided  = collideToStick;
                collided2 = collideToStick * 2;
            }
            else if (!doubleRaycast(gameObject.transform.position, -body.transform.forward, (gameObject.transform.lossyScale.z / 2) + .2f))
            {
                if (inCrouchMode)
                {
                    currState = movementState.crawl;
                    gameObject.transform.position += vel.normalized * sneakCrouchWallBuffer;
                }
                else
                {
                    currState = movementState.run;
                }
                collided  = collideToStick;
                collided2 = collideToStick * 2;
            }
            else if (inCrouchMode)
            {
                vel = Vector3.zero;
            }
            else if (moveLock == movementLock.LR)
            {
                vel.x = 0;
            }
            else if (moveLock == movementLock.FB)
            {
                vel.z = 0;
            }

            // SNEAK CAM CODE START

            // If sneaking, then check to see if you're at an edge
            Vector3    leftPosition, rightPosition;
            bool       leftEdge, rightEdge;
            RaycastHit leftHit, rightHit;
            rightPosition    = body.transform.position + body.transform.right + (body.transform.forward * -1);
            leftPosition     = body.transform.position + (-1 * body.transform.right) + (body.transform.forward * -1);
            rightPosition.y += 3f;
            leftPosition.y  += 3f;

            // Debug rays
            Debug.DrawRay(rightPosition, new Vector3(0f, -4f, 0f));
            Debug.DrawRay(leftPosition, new Vector3(0f, -4f, 0f));

            //  change camera position to sneak cam position
            // If either of the raycasts don't hit anything, then player is at an edge
            leftEdge  = Physics.Raycast(leftPosition, new Vector3(0f, -1f, 0f), out leftHit, 4f);
            rightEdge = Physics.Raycast(rightPosition, new Vector3(0f, -1f, 0f), out rightHit, 4f);

            if (leftEdge)
            {
                if (leftHit.collider.tag != "Floor")
                {
                    leftEdge = false;
                }
            }
            if (rightEdge)
            {
                if (rightHit.collider.tag != "Floor")
                {
                    rightEdge = false;
                }
            }

            if (leftEdge && rightEdge)
            {
                CameraController.S.GetComponent <CameraFollow> ().activateSneakCam(3, leftPosition + rightPosition);
            }
            else if (leftEdge)
            {
                CameraController.S.GetComponent <CameraFollow> ().activateSneakCam(0, leftPosition);
            }
            else if (rightEdge)
            {
                CameraController.S.GetComponent <CameraFollow> ().activateSneakCam(1, rightPosition);
            }
            // Otherwise, you're not at an edge
            else
            {
                // Change camera position back to normal
                CameraController.S.GetComponent <CameraFollow> ().deactivateSneakCam();
            }

            // SNEAK CAM CODE END
        }
        // Also make sure that cam is deactivated to default once you leave sneak
        else
        {
            CameraController.S.GetComponent <CameraFollow> ().deactivateSneakCam();
        }

        // Save the last known button press direction
        if (vel != Vector3.zero)
        {
            lastVel = vel;
        }

        //CROUCH logic: transform snake back to normal if he moves
        if (inCrouchMode && vel != Vector3.zero)
        {
            body.transform.localScale = defaultPlayerSize;
            //check for nearby walls so we don't clip inside them
            Ray frontray = new Ray(body.transform.position, body.transform.forward);
            //Ray buttray = new Ray(body.transform.position, -body.transform.forward);
            if (Physics.Raycast(frontray, body.transform.lossyScale.y / 2f, wallLayerMask))
            {
                Vector3 safePos = gameObject.transform.position;
                safePos  += -body.transform.forward.normalized * ((body.transform.lossyScale.y / 2f) + .1f);
                safePos.y = .2f;
                body.transform.position = safePos;
            }
            else
            {
                body.transform.position = new Vector3(body.transform.position.x, 0.2f, body.transform.position.z);
            }

            body.transform.rotation = Quaternion.LookRotation(vel.normalized);
            body.transform.Rotate(new Vector3(90f, 0f, 0f));

            inCrouchMode = false;
        }

        //CRAWL box collider, shrink down the box collider when in crawl mode
        if (currState == movementState.crawl && !inCrouchMode)
        {
            boxcollider.size   = new Vector3(boxcollider.size.x, 1f, boxcollider.size.z);
            boxcollider.center = new Vector3(boxcollider.center.x, .3f, boxcollider.center.z);
        }
        else
        {
            boxcollider.size   = defaultBoxColliderSize;
            boxcollider.center = new Vector3(boxcollider.center.x, .15f, boxcollider.center.z);
        }

        //MOVEMENT of the Character
        // Speed and direction of movement depends on movementState
        if (inFPVModeCrawlTransition > 0 && currState == movementState.crawl)
        {
            inFPVModeCrawlTransition -= Time.deltaTime;
            body.velocity             = lastForwardCrawlVector;
        }
        else if (HandController.S.isFighting || HandController.S.isGrabbing)
        {
            //don't set velocity here
        }
        else if (currState == movementState.run)
        {
            body.velocity = vel.normalized * speed;
        }
        else if (!FPVModeCrawlControl)
        {
            body.velocity = vel.normalized * slowSpeed;
        }
        else
        //first person crawl mode uses a different set of controls
        if (FPVModeCrawlControl)
        {
            if (Input.GetKey(KeyCode.UpArrow))
            {
                body.velocity = crawlForwardVector * slowSpeed;
            }
            if (Input.GetKey(KeyCode.DownArrow))
            {
                body.velocity = -crawlForwardVector * slowSpeed;
            }

            if (Input.GetKey(KeyCode.LeftArrow))
            {
                lastCrawlTurnVector = (new Vector3(0f, 0f, FPVRotationSpeedDeg));
            }
            else if (Input.GetKey(KeyCode.RightArrow))
            {
                lastCrawlTurnVector = (new Vector3(0f, 0f, -FPVRotationSpeedDeg));
            }
            else
            {
                if (timeTillTurnUpdate <= 0)
                {
                    lastCrawlTurnVector *= FPVRotationDecel;
                }
            }

            if (timeTillTurnUpdate > 0)
            {
                timeTillTurnUpdate -= Time.deltaTime;
            }
            else
            {
                timeTillTurnUpdate = 1f / 60f;
                body.transform.Rotate(lastCrawlTurnVector);
            }
        }// end of FPV mode crawl control

        //ROTATIONS, face character towards the vector of movement:
        //set our foward direction if in run state (run rotation)
        if (currState == movementState.run && !FPVModeControl)
        {
            if (Vector3.Angle(body.transform.forward, lastVel.normalized) > 45f)
            {
                body.velocity = Vector3.zero;
            }

            // Lerp for smooth rotation
            body.transform.rotation = Quaternion.LookRotation(Vector3.Slerp(body.transform.forward, lastVel.normalized, rotationSpeed));
            //body.transform.rotation = Quaternion.LookRotation(lastVel.normalized);
        }
        else //set look direction in crawl mode, unless snake is backing up, or in FPV Crawl mode
        if (currState == movementState.crawl && !FPVModeCrawlControl && !FPVModeControl && inFPVModeCrawlTransition <= 0)
        {
            if (vel != Vector3.zero)
            {
                body.transform.Rotate(new Vector3(90f, 0f, 0f));

                float velAngleFromCurrent = Vector3.Angle(body.transform.forward, vel);

                //dont turn snake around if its within 45 degrees
                if (Mathf.Abs(velAngleFromCurrent - 0f) <= 50f)
                {
                    //body.transform.Rotate(new Vector3(-90f, 0f, 0f));
                    body.transform.rotation = Quaternion.LookRotation(vel.normalized);
                    body.transform.Rotate(new Vector3(90f, 180f, 0f));
                }
                else
                {
                    body.transform.rotation = Quaternion.LookRotation(vel.normalized);
                    body.transform.Rotate(new Vector3(90f, 0f, 0f));
                }
            }
        }

        //Crouch toggle behavior
        if (Input.GetKeyDown(KeyCode.A))
        {
            if (inCrouchMode)
            {
                inCrouchMode = false;
                body.transform.localScale = defaultPlayerSize;
                if (currState != movementState.sneak)
                {
                    currState = movementState.run;
                }
            }
            else if (currState == movementState.run || currState == movementState.sneak)
            {
                //body.transform.Rotate(new Vector3(90f, 0f, 0f));

                //				body.transform.Rotate( Vector3.Lerp (Vector3.zero, new Vector3 (90f, 0f, 0f), 0.5f));
                //
                body.transform.position = new Vector3(body.transform.position.x, .25f, body.transform.position.z);

                Vector3 crouchSize = body.transform.localScale;
                crouchSize.y = crouchHeight;
                body.transform.localScale = crouchSize;
                inCrouchMode = true;

                //special case when sneaking against wall
                if (currState == movementState.sneak)
                {
                    currState = movementState.sneak;
                }
                else
                {
                    currState = movementState.crawl;
                }
            }
            else if (currState == movementState.crawl && !FPVModeCrawlControl && inFPVModeCrawlTransition <= 0)
            {
                body.transform.Rotate(new Vector3(-90f, 0f, 0f));
                body.transform.position = new Vector3(body.transform.position.x, .5f, body.transform.position.z);
                currState = movementState.run;
            }
        }

        //RAYCAST behaviors:
        //SNEAK Wall Detection
        if (vel != Vector3.zero)
        {
            //check for wall collision to stick to
            if (doubleRaycast(gameObject.transform.position, body.transform.forward, (gameObject.transform.lossyScale.z / 2) + 0.2f) && collided2 > 0)
            {
                collided2 -= Time.deltaTime;
            }
            else if (collided2 < 0 && currState == movementState.run)
            {
                // Flips character
                body.transform.rotation       = Quaternion.LookRotation(vel.normalized);
                gameObject.transform.forward *= -1;
                currState = movementState.sneak;

                if (gameObject.transform.forward.x != 0)
                {
                    moveLock = movementLock.LR;
                }
                else if (gameObject.transform.forward.z != 0)
                {
                    moveLock = movementLock.FB;
                }
            }
        }

        //CRAWL modes DETECTION
        if (currState == movementState.crawl && !inCrouchMode)
        {
            //Check FPVModeCrawl State, aka if snake crawls under enclosed space, switch mode and camera
            if (Physics.Raycast(gameObject.transform.position, -body.transform.forward, (gameObject.transform.lossyScale.z / 2) + 1.0f, wallLayerMask))
            {
                if (!FPVModeCrawlControl)
                {
                    // Should only be FPV-Crawl when you cannot stand up aka crawling in a 1 meter tall tunnel
                    CameraController.S.SwitchCameraTo(CameraType.crawl);
                    FPVModeCrawlControl      = true;
                    inFPVModeCrawlTransition = ToFPVModeTransitionTime;
                    lastForwardCrawlVector   = body.velocity;
                }
            }
            else
            {
                if (FPVModeCrawlControl)
                {
                    CameraController.S.SwitchCameraTo(CameraType.overhead);
                    FPVModeCrawlControl      = false;
                    inFPVModeCrawlTransition = FromFPVModeTransitionTime;
                    lastForwardCrawlVector   = body.velocity;
                }
            }

            if (!FPVModeCrawlControl && !inCrouchMode)
            {
                Ray        headray = new Ray(gameObject.transform.position, crawlForwardVector);
                RaycastHit hit;
                //Debug.DrawRay(gameObject.transform.position, crawlForwardVector * ((gameObject.transform.lossyScale.y / 2) + 0.4f), Color.green);
                if (Physics.Raycast(headray, out hit, ((gameObject.transform.lossyScale.y / 2) + 0.4f), wallLayerMask) && collided > 0)
                {
                    collided -= Time.deltaTime;
                }
                else if (collided < 0)
                {
                    // Flips character
                    body.transform.rotation      = Quaternion.LookRotation(vel.normalized);
                    gameObject.transform.forward = -crawlForwardVector;
                    currState = movementState.sneak;

                    Vector3 newPos = hit.point;
                    if (hit.point != Vector3.zero)
                    {
                        newPos += -crawlForwardVector.normalized * ((gameObject.transform.lossyScale.y / 4));
                    }
                    else
                    {
                        newPos = gameObject.transform.position;
                    }
                    print(hit.point);

                    gameObject.transform.position = newPos;

                    Vector3 crouchSize = body.transform.localScale;
                    crouchSize.y = crouchHeight;
                    body.transform.localScale = crouchSize;
                    inCrouchMode = true;

                    if (gameObject.transform.forward.x != 0)
                    {
                        moveLock = movementLock.LR;
                    }
                    else if (gameObject.transform.forward.z != 0)
                    {
                        moveLock = movementLock.FB;
                    }

                    body.velocity = Vector3.zero;
                }

                Ray        buttray = new Ray(gameObject.transform.position, -crawlForwardVector);
                RaycastHit hit2;
                Debug.DrawRay(gameObject.transform.position, -crawlForwardVector * (gameObject.transform.lossyScale.y / 4), Color.green);
                if (Physics.Raycast(buttray, out hit2, (gameObject.transform.lossyScale.y / 4), wallLayerMask) && collided2 > 0)
                {
                    collided2 -= Time.deltaTime;
                }
                else if (collided2 < 0)
                {
                    // Flips character
                    body.transform.rotation      = Quaternion.LookRotation(vel.normalized);
                    gameObject.transform.forward = crawlForwardVector;
                    currState = movementState.sneak;

                    Vector3 newPos = hit2.point;
                    if (newPos != Vector3.zero)
                    {
                        newPos += crawlForwardVector.normalized * ((gameObject.transform.lossyScale.y / 4));
                    }
                    else
                    {
                        newPos = gameObject.transform.position;
                    }
                    gameObject.transform.position = newPos;

                    Vector3 crouchSize = body.transform.localScale;
                    crouchSize.y = crouchHeight;
                    body.transform.localScale = crouchSize;
                    inCrouchMode = true;

                    if (gameObject.transform.forward.x != 0)
                    {
                        moveLock = movementLock.LR;
                    }
                    else if (gameObject.transform.forward.z != 0)
                    {
                        moveLock = movementLock.FB;
                    }
                }
            }
        }
        //CRAWL modes DETECTION END
    }
예제 #53
0
	//Determines the current movement state and what it should transition to
	protected IEnumerator computeState(){

		if(digging){
			currentState = movementState.DIGGING;
		}

		int counter = 0;
		while(true){
			switch(currentState){
			case movementState.IDLE:
				animater.animationID = 2;
				if(currentMovement.x != 0){
					currentState = movementState.WALKING;
				}
				break;
			case movementState.JUMPING:
				if(cc.isGrounded){
					currentState = movementState.WALKING;
					counter = (int)landingDelay;
				}
				break;
			case movementState.CLIMBING:
				//TODO Set animation
				break;
			case movementState.WALKING:
				animater.animationID = 1;
				if(currentMovement.x == 0){
					currentState = movementState.IDLE;
				}
				break;
			case movementState.DIGGING:
				animater.animationID = 0;
				emitParticles();
				if(!digging){
					currentState = movementState.IDLE;
				}
				break;
			}

			if(currentMovement.x < 0){
				right = false;
			}
			if(currentMovement.x > 0){
				right = true;
			}
			yield return null;
		}
	}
 // Use this for initialization
 void Start()
 {
     myState = movementState.neutral;
 }
예제 #55
0
    protected IEnumerator computeState()
    {
        int counter = 0;

        while (true)
        {
            if (pPhysics.climbing)
            {
                currentState = movementState.CLIMBING;
            }

            switch (currentState)
            {
            case movementState.IDLE:
                animater.animationID = 0;
                if (moveAmount.x != 0)
                {
                    currentState = movementState.WALKING;
                }
                if (!pPhysics.onGround && moveAmount.y != 0)
                {
                    currentState = movementState.JUMPING;
                }
                break;

            case movementState.JUMPING:
                animater.animationID = 2;
                if (pPhysics.onGround)
                {
                    currentState = movementState.WALKING;
                }
                break;

            case movementState.WALKING:
                animater.animationID = 1;
                if (!pPhysics.onGround && moveAmount.y != 0)
                {
                    currentState = movementState.JUMPING;
                }
                else
                {
                    if (moveAmount.x == 0)
                    {
                        currentState = movementState.IDLE;
                    }
                }
                break;

            case movementState.CLIMBING:
                animater.animationID = 3;
                if (!pPhysics.climbing)
                {
                    currentState = movementState.WALKING;
                }
                break;
            }

            if (moveAmount.x < 0)
            {
                right = false;
            }
            if (moveAmount.x > 0)
            {
                right = true;
            }
            yield return(null);
        }
    }