//ClimbingStrafeState = Animator.StringToHash ("Climbing.ClimbingStrafe"); // protected void ClimbingStrafe(float elapsedTime) // { // if(ActiveHangTarget == null) { // DropHangTarget(); // MecanimAnimator.SetBool(MecanimHashes.Fall, true); // return; // } // // ApplyClimbingStrafing(CharInput.Horizontal); // // if(HorizontalSpeed != 0) // ApplyClimbingVertical(vertical); // else // VerticalSpeed = 0.0f; // // if(ActiveHangTarget.DoesFaceZAxis()) // Direction = Vector3.zero; // // MecanimAnimator.SetBool(MecanimHashes.Jump, CharInput.JumpPressed); // // } // WallgrabbingState = Animator.StringToHash("Wall.Wallgrabbing"); protected void Wallgrabbing(float elapsedTime) { // We don't move horizontally HorizontalSpeed = 0; SetMecanimAnimatorHorizontalSpeedFloat(); // But we do want to start moving down the wall if (_wallJumpCount > 0 || TimeInCurrentState > Settings.WallgrabDuration) { VerticalSpeed = Settings.WallSlideSpeed * elapsedTime; } else { VerticalSpeed = 0; } VerticalSpeed = 0; MecanimAnimator.SetFloat(MecanimHashes.VerticalSpeed, VerticalSpeed); // You can let go of the wall if (CharInput.PickupPressed) { MecanimAnimator.SetBool(MecanimHashes.Fall, true); MecanimAnimator.SetBool(MecanimHashes.GrabWall, false); DropHangTarget(); // But the expectation is that you will jump off } else if (CharInput.JumpPressed) { MecanimAnimator.SetBool(MecanimHashes.JumpWall, true); MecanimAnimator.SetBool(MecanimHashes.GrabWall, false); DropHangTarget(); } }
// RollingState = Animator.StringToHash("Ground.Rolling"); protected void Rolling(float elapsedTime) { // We only need to set motion settings at the beginning of the animation if (!MecanimAnimator.GetBool(MecanimHashes.ClimbLedge)) { return; } // We need to make sure we know what we're going to roll over. if (ActiveHangTarget == null) { Debug.LogWarning("Failed to have hang target while doing rolling!"); return; } // Meta-data about the motion we need to do MecanimAnimator.SetBool(MecanimHashes.ClimbLedge, false); Bounds ledgeBounds = ActiveHangTarget.GetComponent <Collider>().bounds; float animationTime = MecanimAnimator.GetCurrentAnimatorStateInfo(0).length; // Horizontal motion float distanceToMove = Direction.x > 0 ? ledgeBounds.max.x - Controller.bounds.center.x : ledgeBounds.min.x - Controller.bounds.center.x; HorizontalSpeed = distanceToMove / animationTime; SetMecanimAnimatorHorizontalSpeedFloat(); // Vertical motion float distanceToClimb = ledgeBounds.max.y - Controller.bounds.min.y; VerticalSpeed = distanceToClimb / animationTime; MecanimAnimator.SetFloat(MecanimHashes.VerticalSpeed, VerticalSpeed); }
// FallingState = Animator.StringToHash("Air.Falling"); protected void Falling(float elapsedTime) { // Maintain horizontal speed by default, but allow 1/2 the normal movement for horizontal input if (CharInput.Right || CharInput.Left) { ApplyMovingHorizontal(elapsedTime * 0.5f); } // Vertical Motion ApplyGravity(elapsedTime); MecanimAnimator.SetBool(MecanimHashes.Fall, false); // You can grab onto the walls while falling MecanimAnimator.SetBool(MecanimHashes.GrabWall, CanGrabWall); // You can regrab the hangable object you last let go of if (!(ActiveHangTarget is Ledge && ((Ledge)ActiveHangTarget).Obstacle) && (CanHangOffObject && ActiveHangTarget.DoesFaceXAxis() && VerticalSpeed < 0) || (CanHangOffObject && ActiveHangTarget.DoesFaceZAxis() && CharInput.Up)) { MecanimAnimator.SetBool(MecanimHashes.Hang, true); VerticalSpeed = 0; HorizontalSpeed = 0; SetMecanimAnimatorHorizontalSpeedFloat(); MecanimAnimator.SetFloat(MecanimHashes.VerticalSpeed, VerticalSpeed); } else { MecanimAnimator.SetBool(MecanimHashes.Hang, false); } }
protected override void UpdateMecanimVariables() { if (IgnoreXYMovement) { return; } if (!MecanimAnimator.GetBool(MecanimHashes.Jump) && IsGrounded && CharInput.JumpPressed) { MecanimAnimator.SetBool(MecanimHashes.Jump, true); } bool facingRightLadder = (ActiveHangTarget && ActiveHangTarget.transform.position.x - transform.position.x > 0.0f); bool facingLeftLadder = (ActiveHangTarget && transform.position.x - ActiveHangTarget.transform.position.x > 0.0f); bool startClimbLadder = CanClimbLadder && ((facingRightLadder && CharInput.Right) || (facingLeftLadder && CharInput.Left)); MecanimAnimator.SetBool(MecanimHashes.ClimbLadder, startClimbLadder); /* * if(startClimbLadder) * _autoClimbDir = AutoClimbDirection.AutoClimb_Up; * // if not in a climb, reset our auto-climb direction for use next climb. * if( (CurrentState.fullPathHash != ClimbingLadderState || CurrentState.fullPathHash != ClimbingPipeState) ) * _autoClimbDir = AutoClimbDirection.AutoClimb_None; */ MecanimAnimator.SetBool(MecanimHashes.ClimbRope, CanClimbRope); MecanimAnimator.SetBool(MecanimHashes.IsGrounded, IsGrounded); MecanimAnimator.SetBool(MecanimHashes.AttackHorizontal, CharInput.Attack > 0); MecanimAnimator.SetBool(MecanimHashes.AttackVertical, CharInput.Attack < 0); if (!IsGrounded) { MecanimAnimator.SetBool(MecanimHashes.AcquiringTarget, false); } // Give Olympus some perfectly hard stops on land if (IsLanding) { HorizontalSpeed = 0; } // Knowing direction is useful for the turnaround animation MecanimAnimator.SetFloat(MecanimHashes.XDirection, Direction.x); // Olympus needs to turn off the screens when moving // TODO: THINK OF A MORE EFFICIENT WAY INSTEAD OF DOING THIS EVERY FRAME if (CharInput.Left || CharInput.Right) { foreach (Fader screen in IdleScreens) { screen.FadeOut(); } } }
public override void MakeDamaged(Vector3 knockForce) { MecanimAnimator.SetBool(MecanimHashes.Damaged, true); HorizontalSpeed = knockForce.x; VerticalSpeed = knockForce.y; SetMecanimAnimatorHorizontalSpeedFloat(); MecanimAnimator.SetFloat(MecanimHashes.VerticalSpeed, VerticalSpeed); }
// JumpingState = Animator.StringToHash("Jumping.Jumping"); // FrontflipState = Animator.StringToHash("Jumping.Frontflip"); // FrontflipLoopState = Animator.StringToHash("Jumping.FrontflipLoop"); protected void Jumping(float elapsedTime) { // We only determine vertical speed (Horizontal Speed is maintained throughout the jump) if (MecanimAnimator.GetBool(MecanimHashes.Jump)) { float jumpHeight = Settings.JumpHeight; if (CurrentState.fullPathHash == FrontflipState) { jumpHeight *= 1.5f; } VerticalSpeed = Mathf.Sqrt(2 * jumpHeight * Settings.Gravity); MecanimAnimator.SetFloat(MecanimHashes.VerticalSpeed, VerticalSpeed); MecanimAnimator.SetBool(MecanimHashes.Jump, false); } else { ApplyGravity(elapsedTime); } // You can increase horizontal speed midair ONLY if doing a sneak jump and you weren't already at max speed if (CurrentState.fullPathHash == JumpingState && (CharInput.Left || CharInput.Right)) { float prevSpeed = HorizontalSpeed; ApplyMovingHorizontal(elapsedTime * 0.5f); if (Mathf.Abs(HorizontalSpeed) < Mathf.Abs(prevSpeed)) { HorizontalSpeed = prevSpeed; } else if (Direction.x > 0 && HorizontalSpeed > 0.79f * Settings.MaxHorizontalSpeed) { HorizontalSpeed = 0.79f * Settings.MaxHorizontalSpeed; } else if (Direction.x < 0 && HorizontalSpeed < -0.79f * Settings.MaxHorizontalSpeed) { HorizontalSpeed = -0.79f * Settings.MaxHorizontalSpeed; } SetMecanimAnimatorHorizontalSpeedFloat(); } // You can grab onto walls while jumping MecanimAnimator.SetBool(MecanimHashes.GrabWall, CanGrabWall); // You can hang off most objects while jumping bool shouldHang = (CanHangOffObject && ActiveHangTarget.DoesFaceXAxis() && VerticalSpeed < 0) || (CanHangOffObject && ActiveHangTarget.DoesFaceZAxis() && CharInput.Up); MecanimAnimator.SetBool(MecanimHashes.Hang, shouldHang); // You can re-grab ropes you just let go of bool shouldRegrabRope = CharInput.Up && PreviousHangTarget != null && PreviousHangTarget.GetComponent <Collider>().bounds.Contains(transform.position); if (shouldRegrabRope) { AddHangTarget(PreviousHangTarget); MecanimAnimator.SetBool(MecanimHashes.ClimbRope, true); } }
// StealthKillState = Animator.StringToHash("Combat.Stealth Kill"); protected void StealthKill(float elapsedTime) { MecanimAnimator.SetBool(MecanimHashes.StealthKill, false); // This is a completely stationary action HorizontalSpeed = 0.0f; VerticalSpeed = 0.0f; SetMecanimAnimatorHorizontalSpeedFloat(); MecanimAnimator.SetFloat(MecanimHashes.VerticalSpeed, VerticalSpeed); }
// LandingState = Animator.StringToHash("Landing.Landing"); // LandSneakState = Animator.StringToHash("Landing.SneakLanding"); // LandHighState = Animator.StringToHash("Landing.HighLanding"); // LandRollState = Animator.StringToHash("Landing.Rolling"); protected void Landing(float elapsedTime) { // We do hard stops on land unless we're rolling if (TimeInCurrentState == 0) { if (CurrentState.fullPathHash == LandHighState || (CurrentState.fullPathHash != LandRollState && !(CharInput.Left || CharInput.Right))) { HorizontalSpeed = 0; } else if (CurrentState.fullPathHash != LandRollState) { HorizontalSpeed *= 0.5f; } else { ApplyFriction(elapsedTime); } SetMecanimAnimatorHorizontalSpeedFloat(); } // Horizontal Motion mainly wants us to slow down if (CurrentState.fullPathHash != LandHighState && InputMoveForward) { ApplyMovingHorizontal(elapsedTime * 0.5f); } else { if (CurrentState.fullPathHash == LandRollState) { elapsedTime *= 1.5f; } ApplyFriction(elapsedTime); } // Vertical Motion depends on whether we're on the ground if (!IsGrounded) { if (CurrentState.fullPathHash != LandRollState || CurrentState.normalizedTime > 0.99f) { MecanimAnimator.SetBool(MecanimHashes.Fall, true); } else { ApplyGravity(elapsedTime); } } else { VerticalSpeed = GroundVerticalSpeed; MecanimAnimator.SetFloat(MecanimHashes.VerticalSpeed, GroundVerticalSpeed); } // You can jump again even before you finish landing AllowGroundJump(); }
// DeathState = Animator.StringToHash("Combat.Death"); // DeadState = Animator.StringToHash("Combat.Waiting For Respawn"); protected void Die(float elapsedTime) { if (IsGrounded) { ApplyFriction(elapsedTime); VerticalSpeed = GroundVerticalSpeed; MecanimAnimator.SetFloat(MecanimHashes.VerticalSpeed, VerticalSpeed); } else { ApplyGravity(elapsedTime); } MecanimAnimator.SetBool(MecanimHashes.Jump, false); MecanimAnimator.SetBool(MecanimHashes.Fall, false); MecanimAnimator.SetBool(MecanimHashes.Die, false); }
// WalljumpingState = Animator.StringToHash("Wall.Walljumping"); protected void Walljumping(float elapsedTime) { // Determine motion on the first frame if (MecanimAnimator.GetBool(MecanimHashes.JumpWall)) { Direction = -Direction; HorizontalSpeed = Settings.MaxHorizontalSpeed * Direction.x * 0.79f; SetMecanimAnimatorHorizontalSpeedFloat(); VerticalSpeed = Mathf.Sqrt(2 * Settings.JumpHeight * Settings.Gravity); MecanimAnimator.SetFloat(MecanimHashes.VerticalSpeed, VerticalSpeed); _wallJumpCount++; MecanimAnimator.SetBool(MecanimHashes.JumpWall, false); } else { ApplyGravity(elapsedTime); } // You eventually start falling down if (transform.position.y >= LastGroundHeight - 1) { MecanimAnimator.SetBool(MecanimHashes.Fall, false); } // You can do consecutive wall grabs/jumps if (CanGrabWall) { MecanimAnimator.SetBool(MecanimHashes.GrabWall, true); } // You can grab onto ledges if (!(ActiveHangTarget is Ledge && ((Ledge)ActiveHangTarget).Obstacle) && (CanHangOffObject && ActiveHangTarget.DoesFaceXAxis() && VerticalSpeed < 0) || (CanHangOffObject && ActiveHangTarget.DoesFaceZAxis() && CharInput.Up)) { MecanimAnimator.SetBool(MecanimHashes.Hang, true); VerticalSpeed = 0; MecanimAnimator.SetFloat(MecanimHashes.VerticalSpeed, VerticalSpeed); HorizontalSpeed = 0; } else { MecanimAnimator.SetBool(MecanimHashes.Hang, false); } }
// PickupState = Animator.StringToHash("Kneeling.Pickup"); protected void Pickup(float elapsedTime) { // Everything relevant happens on the first frame if (MecanimAnimator.GetBool(MecanimHashes.Pickup)) { MecanimAnimator.SetBool(MecanimHashes.Pickup, false); // Horizontal Motion HorizontalSpeed = 0; SetMecanimAnimatorHorizontalSpeedFloat(); // Vertical Motion VerticalSpeed = GroundVerticalSpeed; MecanimAnimator.SetFloat(MecanimHashes.VerticalSpeed, VerticalSpeed); // Pickup a weapon if (_itemPickedup.WeaponPrefab != null) { int pickupCount = _itemPickedup.Quantity; Weapon pickedUpWeapon = _itemPickedup.WeaponPrefab.GetComponent <Weapon>(); if (!GameManager.Inventory.TryAddAmmo(pickedUpWeapon, pickupCount)) { // NOTE: DON'T USE THE OBJECT POOL BECAUSE IT DOESN'T REALLY HAPPEN THAT OFTEN Transform instantiatedWeapon = (Transform)Instantiate(_itemPickedup.WeaponPrefab); Weapon newWeapon = instantiatedWeapon.GetComponent <Weapon>(); newWeapon.Quantity = pickupCount; GameManager.Inventory.Weapons.Add(newWeapon); GameManager.UI.CycleToNextWeapon(); } GameManager.UI.RefreshWeaponWheel(); // Pickup an inventory item } else { InventoryItem newInvItem = InventoryItemFactory.CreateFromType(_itemPickedup.Type, _itemPickedup.Quantity); GameManager.Inventory.AddItem(newInvItem); GameManager.UI.CraftingMenu.RefreshItemWheel(); } // Get rid of the picked up item Destroy(_itemPickedup.gameObject, 0.5f); } }
// IdleState = Animator.StringToHash("Base Layer.Idle"); protected virtual void Idle(float elapsedTime) { // Switch between crouching and standing idles based off enemies that could hear float idleNum = MecanimAnimator.GetFloat(MecanimHashes.IdleNum); float targetIdle = GameManager.AI.EnemiesCouldHear > 0 ? 1 : 0; idleNum = Mathf.Lerp(idleNum, targetIdle, elapsedTime * IdleChangeSpeed); MecanimAnimator.SetFloat(MecanimHashes.IdleNum, idleNum); // You can start moving left or right at any point ApplyMovingHorizontal(elapsedTime); ApplyBiDirection(); // You stick to the ground VerticalSpeed = GroundVerticalSpeed; MecanimAnimator.SetFloat(MecanimHashes.VerticalSpeed, VerticalSpeed); // You could potentially fall down if the ground disappears beneath you MecanimAnimator.SetBool(MecanimHashes.Fall, !IsGrounded); // You can only pickup items while in idle if (CharInput.Pickup) { GameObject itemObj = null; bool canPickup = CanPickupItem(out itemObj); if (canPickup && itemObj != null) { _itemPickedup = itemObj.GetComponent <Item>(); } MecanimAnimator.SetBool(MecanimHashes.Pickup, canPickup && _itemPickedup != null); } // You can re-grab ropes you just let go of bool shouldRegrabRope = CharInput.Up && PreviousHangTarget != null && PreviousHangTarget.GetComponent <Collider>().bounds.Contains(transform.position); if (shouldRegrabRope) { AddHangTarget(PreviousHangTarget); MecanimAnimator.SetBool(MecanimHashes.ClimbRope, true); } // You can jump AllowGroundJump(); }
// BackflipState = Animator.StringToHash("Air.Backflip"); protected void Backflip(float elapsedTime) { // We determine our target speed on the first frame of the action if (MecanimAnimator.GetBool(MecanimHashes.Backflip)) { MecanimAnimator.SetBool(MecanimHashes.Backflip, false); _desiredDirectionX = -Direction.x; _desiredSpeed = -HorizontalSpeed; VerticalSpeed = Mathf.Sqrt(2 * Settings.JumpHeight * 1.5f * Settings.Gravity); MecanimAnimator.SetFloat(MecanimHashes.VerticalSpeed, VerticalSpeed); } else { ApplyGravity(elapsedTime); } // Adjust horizontal speed frame by frame float accelerationSmoothing = Settings.HorizontalAcceleration * elapsedTime; if (TimeInCurrentState > 0.15f) { Vector3 newDir = new Vector3(Mathf.Lerp(Direction.x, _desiredDirectionX, accelerationSmoothing), 0, 0); if (newDir.x * Direction.x < 0) { HorizontalSpeed = -HorizontalSpeed; } Direction = newDir; } accelerationSmoothing = Settings.HorizontalAcceleration * elapsedTime; HorizontalSpeed = Mathf.Lerp(HorizontalSpeed, _desiredSpeed, accelerationSmoothing); SetMecanimAnimatorHorizontalSpeedFloat(); // You can grab onto objects even in the middle of a backflip bool shouldHang = (CanHangOffObject && ActiveHangTarget.DoesFaceXAxis() && VerticalSpeed < 0) || (CanHangOffObject && ActiveHangTarget.DoesFaceZAxis() && CharInput.Up); MecanimAnimator.SetBool(MecanimHashes.Hang, shouldHang); // Make sure we don't enter the other Air states MecanimAnimator.SetBool(MecanimHashes.Jump, false); MecanimAnimator.SetBool(MecanimHashes.Fall, false); }
// RunningState = Animator.StringToHash("Ground.Running"); protected void Locomotion(float elapsedTime) { // You run left or right ApplyMovingHorizontal(elapsedTime); ApplyBiDirection(); // You stick to the ground VerticalSpeed = GroundVerticalSpeed; MecanimAnimator.SetFloat(MecanimHashes.VerticalSpeed, VerticalSpeed); // You could potentially fall down by running off a ledge MecanimAnimator.SetBool(MecanimHashes.Fall, !IsGrounded); // You could start rolling over small obstacles in your way MecanimAnimator.SetBool(MecanimHashes.ClimbLedge, ActiveHangTarget != null && ActiveHangTarget is Ledge && ((Ledge)ActiveHangTarget).Obstacle && ((Direction.x > 0 && ((Ledge)ActiveHangTarget).Left) || (Direction.x < 0 && !((Ledge)ActiveHangTarget).Left))); // You can re-grab ropes you just let go of bool shouldRegrabRope = CharInput.Up && PreviousHangTarget != null && PreviousHangTarget.GetComponent <Collider>().bounds.Contains(transform.position); if (shouldRegrabRope) { AddHangTarget(PreviousHangTarget); MecanimAnimator.SetBool(MecanimHashes.ClimbRope, true); } // You can only do a backflip if you're running if (!IsSneaking && ((Direction.x > 0 && CharInput.JumpLeft) || (Direction.x < 0 && CharInput.JumpRight))) { MecanimAnimator.SetBool(MecanimHashes.Backflip, true); MecanimAnimator.SetBool(MecanimHashes.Jump, false); // You can do a jump } else { AllowGroundJump(); MecanimAnimator.SetBool(MecanimHashes.Backflip, false); } }
protected void ClimbingVertical(float elapsedTime) { if (ActiveHangTarget == null) { DropHangTarget(); MecanimAnimator.SetBool(MecanimHashes.Fall, true); return; } HorizontalSpeed = 0; float vertical = CharInput.Vertical; ApplyClimbingVertical(vertical); if (ActiveHangTarget.DoesFaceZAxis()) { Direction = Vector3.zero; } MecanimAnimator.SetFloat(MecanimHashes.HorizontalSpeed, HorizontalSpeed); MecanimAnimator.SetFloat(MecanimHashes.VerticalSpeed, VerticalSpeed); if (CharInput.InteractionPressed) { MecanimAnimator.SetBool(MecanimHashes.Fall, true); DropHangTarget(); return; } else { MecanimAnimator.SetBool(MecanimHashes.Fall, false); } if (CharInput.JumpActive) { MecanimAnimator.SetBool(MecanimHashes.Jump, true); DropHangTarget(); } }
// ClimbingLedgeState = Animator.StringToHash("Climbing.ClimbingLedge"); protected void ClimbingLedge(float elapsedTime) { // Make sure we actually have a ledge to climb up if (_ledge == null) { Debug.LogWarning("Player Character's Ledge Not Found!"); MecanimAnimator.SetBool(MecanimHashes.Fall, true); return; } // The motion for climbing ledges is somewhat complicated... if ((Direction.x > 0 && transform.position.x > _ledge.transform.position.x + _ledge.GetComponent <Collider>().bounds.extents.x) || (Direction.x < 0 && transform.position.x < _ledge.transform.position.x - _ledge.GetComponent <Collider>().bounds.extents.x) || CurrentState.normalizedTime > 0.9) { MecanimAnimator.SetBool(MecanimHashes.ClimbLedge, false); VerticalSpeed = GroundVerticalSpeed; } else if (transform.position.y > _ledge.transform.position.y + _ledge.GetComponent <Collider>().bounds.extents.y + Height / 2) { VerticalSpeed = 0; } else { if (_ledge.DoesFaceZAxis()) { HorizontalSpeed = 0.0f; VerticalSpeed = Settings.LedgeClimbingSpeed; } else if (_ledge.DoesFaceXAxis()) { HorizontalSpeed = Direction.x * Settings.LedgeClimbingSpeed; VerticalSpeed = Settings.LedgeClimbingSpeed; } } SetMecanimAnimatorHorizontalSpeedFloat(); MecanimAnimator.SetFloat(MecanimHashes.VerticalSpeed, VerticalSpeed); MecanimAnimator.SetBool(MecanimHashes.Fall, false); }
// HangingState = Animator.StringToHash("Climbing.Hanging"); protected void Hanging(float elapsedTime) { // Make sure we actually have something to hang on if (ActiveHangTarget == null) { DropHangTarget(); MecanimAnimator.SetBool(MecanimHashes.Fall, true); Debug.LogWarning("Player lost track of hang target and fell!"); return; } // We determine all our motion on the first frame if (MecanimAnimator.GetBool(MecanimHashes.Hang)) { if (ActiveHangTarget.DoesFaceZAxis()) { HorizontalSpeed = 0.0f; Direction = Vector3.zero; } else { HorizontalSpeed = Direction.x * Settings.LedgeClimbingSpeed; if (IsHangTargetToRight) { Direction = Vector3.right; } else { Direction = Vector3.left; } } SetMecanimAnimatorHorizontalSpeedFloat(); VerticalSpeed = 0; MecanimAnimator.SetFloat(MecanimHashes.VerticalSpeed, VerticalSpeed); MecanimAnimator.SetBool(MecanimHashes.Hang, false); } // Stay on whatever we're hanging on, even if it's moving ActivePlatform = ActiveHangTarget.transform; MecanimAnimator.SetBool(MecanimHashes.Fall, false); // You can press up/forward on ledges to climb up if (ActiveHangTarget is Ledge && (CharInput.Up || InputMoveForward)) { _ledge = ActiveHangTarget as Ledge; MecanimAnimator.SetBool(MecanimHashes.ClimbLedge, true); // You can jump off whatever you're hanging } else if (CharInput.JumpPressed) { AllowAirJump(); // You can also just let go } else if (CharInput.PickupPressed) { DropHangTarget(); MecanimAnimator.SetBool(MecanimHashes.Fall, true); } }
protected override void ApplyMovingHorizontal(float elapsedTime) { base.ApplyMovingHorizontal(elapsedTime); MecanimAnimator.SetFloat(MecanimHashes.HorizontalSpeed, Direction.x * HorizontalSpeed / Settings.MaxHorizontalSpeed); }
protected override void ApplyClimbingVertical(float vertical) { base.ApplyClimbingVertical(vertical); MecanimAnimator.SetFloat(MecanimHashes.VerticalSpeed, VerticalSpeed); }
protected override void ApplyGravity(float elapsedTime) { base.ApplyGravity(elapsedTime); MecanimAnimator.SetFloat(MecanimHashes.VerticalSpeed, VerticalSpeed); }
public override void StepDown() { MecanimAnimator.SetFloat(MecanimHashes.XDirection, Direction.x); MecanimAnimator.SetBool(MecanimHashes.SteppingDown, true); }
// ClimbingLadderState = Animator.StringToHash("Climbing.ClimbingLadder"); // ClimbingRopeState = Animator.StringToHash("Climbing.ClimbingRope"); protected void ClimbingVertical(float elapsedTime) { // Make sure we have something to climb on if (ActiveHangTarget == null) { DropHangTarget(); MecanimAnimator.SetBool(MecanimHashes.Fall, true); return; } // We let go when we touch the floor if (IsGrounded && TimeInCurrentState > 0) { DropHangTarget(); return; } // Horizontal motion //if(VerticalSpeed != 0 && ActiveHangTarget.DoesFaceZAxis()) // ApplyClimbingStrafing( CharInput.Horizontal ); //else HorizontalSpeed = 0; SetMecanimAnimatorHorizontalSpeedFloat(); // Make sure we're facing the correct direction if (ActiveHangTarget.DoesFaceZAxis()) { Direction = Vector3.zero; } else { bool ladderToRight = ActiveHangTarget.transform.position.x - transform.position.x > 0.0f; if (ladderToRight) { Direction = Vector3.right; } else { Direction = Vector3.left; } } // The vertical motion is the most important when climbing ApplyClimbingVertical(CharInput.Vertical); if (VerticalSpeed == 0) { if (InputMoveForward) { VerticalSpeed = Settings.LadderClimbingSpeed; } else if (InputMoveBackward) { VerticalSpeed = -Settings.LadderClimbingSpeed; } MecanimAnimator.SetFloat(MecanimHashes.VerticalSpeed, VerticalSpeed); MecanimAnimator.SetBool(MecanimHashes.Fall, false); } // You can press up/forward on ledges to climb up if (ActiveHangTarget is Ledge && (CharInput.Up || InputMoveForward)) { _ledge = ActiveHangTarget as Ledge; MecanimAnimator.SetBool(MecanimHashes.ClimbLedge, true); // You can let go of what you're climbing with the pickup button } else if (CharInput.PickupPressed) { MecanimAnimator.SetBool(MecanimHashes.Fall, true); MecanimAnimator.SetBool(MecanimHashes.ClimbRope, false); DropHangTarget(); return; } // You can jump off ropes and ladders AllowAirJump(); }
private void SetMecanimAnimatorHorizontalSpeedFloat() { MecanimAnimator.SetFloat(MecanimHashes.HorizontalSpeed, Direction.x * HorizontalSpeed / Settings.MaxHorizontalSpeed); }