void Update() { // jump switch (jumpState) { case JumpState.Jump: // 上へ collider.transform.Translate(jumpSpeed * Vector2.up * Time.deltaTime); if (transform.position.y > jumpHeight) { jumpState = JumpState.Fall; } break; case JumpState.Fall: // 下へ collider.transform.Translate(fallSpeed * Vector2.down * Time.deltaTime); if (transform.position.y < 0.01F) { // 地面へ collider.transform.transform.position = new Vector3(transform.position.x, 0.0F, transform.position.z); jumpState = JumpState.OnGround; animator.SetBool("IsRunning", true); } break; default: // Do Nothing break; } }
/// <summary> /// 模拟Jump控制跳跃 /// 当前方没有路时,模拟跳跃 /// </summary> private void SimulateControlJump() { if (m_JumpState == JumpState.Grounded && !IsForwardGrounded) { m_JumpState = JumpState.PrepareToJump; } }
private void MakeFSM() { IdleState idle = new IdleState(); idle.AddTransition(Transition.Walk, StateID.Walk); idle.AddTransition(Transition.Jump, StateID.Jump); idle.AddTransition(Transition.Die, StateID.Die); WalkState walk = new WalkState(path); walk.AddTransition(Transition.Idle, StateID.Idle); walk.AddTransition(Transition.Jump, StateID.Jump); walk.AddTransition(Transition.Die, StateID.Die); JumpState jump = new JumpState(); jump.AddTransition(Transition.Idle, StateID.Idle); jump.AddTransition(Transition.Die, StateID.Die); DeadState die = new DeadState(); fsm = new FSMSystem(); fsm.AddState(idle); fsm.AddState(walk); fsm.AddState(jump); fsm.AddState(die); }
void UpdateJumpState() { jump = false; switch (jumpState) { case JumpState.PrepareToJump: jumpState = JumpState.Jumping; jump = true; stopJump = false; break; case JumpState.Jumping: if (!IsGrounded) { jumpState = JumpState.InFlight; } break; case JumpState.InFlight: if (IsGrounded) { jumpState = JumpState.Landed; } break; case JumpState.Landed: jumpState = JumpState.Grounded; break; } }
// Use this for initialization void Start() { Move_parameter_x = 0; Move_parameter_x = 0; playerController = this; AttackTrigger = 0; PlayerAnimation_parameter = 0; GhostShadow.ghostShadow.gameObject.GetComponent <GhostShadow>().enabled = false; debounce = true; CanMove = true; AttackCollider_Small.SetActive(false); AttackCollider_Big.SetActive(false); AttackCollider_BigSkill.SetActive(false); CanAttack = true; CancelAttackCoroutine = null; ResetStateCoroutine = null; DoubleClickCoroutine = null; FastRunCoroutine = null; GetUpCoroutine = null; AvoidDistance = AvoidMaxDistance; FixBulletPos = Bullet_pos.transform.position - transform.position; Weapons.transform.parent = WeaponsBone;//-- LightAccessoriesUp.transform.parent = LightAccessoriesUpBone; LightAccessoriesDown.transform.parent = LightAccessoriesDownBone; attackState = AttackState.Default; moveState = MoveState.Idle; playerAnimatorState = PlayerAnimatorState.Movement; avoidState = AvoidState.Default; jumpState = JumpState.Jump; }
protected override void Update() { Debug.Log(Input.acceleration.x + ", " + Input.acceleration.y + ", " + Input.acceleration.z); var jumpControlDown = Input.GetMouseButtonDown(0); //Input.GetButtonDown("Jump"); var jumpControlUp = Input.GetMouseButtonUp(0); //Input.GetButtonUp("Jump"); if (controlEnabled) { //var accValue = Mathf.Clamp(Input.acceleration.x, -maxAccelometerValue, maxAccelometerValue); var accValue = Input.acceleration.x; accValue = accValue >= minAccelometerValue || accValue <= -minAccelometerValue?Mathf.Sign(accValue) : 0; move.x = accValue; //Input.GetAxis("Horizontal"); if (jumpState == JumpState.Grounded && jumpControlDown) { jumpState = JumpState.PrepareToJump; } else if (jumpControlUp) { stopJump = true; Schedule <PlayerStopJump>().player = this; } } else { move.x = 0; } UpdateJumpState(); base.Update(); }
private void UpdateLocalPlayerPosition() { RotateView(); // the jump state needs to read here to make sure it is not missed if (m_JumpState == JumpState.None) { if (InputManager.ActiveDevice.Action1.IsPressed || Input.GetKeyDown(KeyCode.Space)) { Debug.Log("Jump Pressed"); m_JumpState = JumpState.JumpPending; } } if (!m_PreviouslyGrounded && m_CharacterController.isGrounded) { PlayLandingSound(); m_MoveDir.y = 0f; m_JumpState = JumpState.None; } if (!m_CharacterController.isGrounded && m_JumpState == JumpState.None && m_PreviouslyGrounded) { m_MoveDir.y = 0f; } m_PreviouslyGrounded = m_CharacterController.isGrounded; }
public PlayerState(IEventManager playerEvent) { #region Player State Initialization _StateIdle = new IdleState(this); _StateWalk = new WalkState(this); _StateSprint = new SprintState(this); _StateFall = new FallState(this); _StateCrouch = new CrouchState(this); _StateJump = new JumpState(this); _StateCrouchWalk = new CrouchWalkState(this); _StateSlide = new SlideState(this); _StateCrouchJump = new CrouchJumpState(this); _StateCrouchFall = new CrouchFallState(this); _StateAirMoveCrouchFall = new AirMoveCrouchFallState(this); _StateAirMoveCrouchJump = new AirMoveCrouchJumpState(this); _StateAirMoveFall = new AirMoveFallState(this); _StateAirMoveJump = new AirMoveJumpState(this); #endregion _ActiveProxies = new HashSet <IDynamicProxy>(); _EventPlayer = playerEvent; _CurrentPlayerState = _StateIdle; #region State Proxy Initialization _MediatorToggleProxy = new ToggleProxyMediator(); _ProxySprint = new SprintProxy(this, _MediatorToggleProxy); _ProxyCrouch = new CrouchProxy(this, _MediatorToggleProxy); _MediatorToggleProxy.ProxyCrouch = _ProxyCrouch; _MediatorToggleProxy.ProxySprint = _ProxySprint; _ProxyWalk = new WalkProxy(this, _MediatorToggleProxy); _ProxyFall = new FallProxy(this); _ProxyJump = new JumpProxy(this, _MediatorToggleProxy); #endregion }
void OnCollisionEnter(Collision collision) { if ((1 << collision.gameObject.layer) == wallLayer) { jumpState = JumpState.Grounded; } }
protected override void Update() { if (controlEnabled) { move.x = Input.GetAxis("Horizontal"); if (jumpState == JumpState.Grounded && Input.GetButtonDown("Jump")) { jumpState = JumpState.PrepareToJump; //Sending the event PlayerJumped() deltaDNAManager.PlayerJumped(); } else if (Input.GetButtonUp("Jump")) { stopJump = true; Schedule <PlayerStopJump>().player = this; } } else { move.x = 0; } UpdateJumpState(); base.Update(); }
protected override void Update() { if (controlEnabled) { move.x = Input.GetAxis("Horizontal"); if (input_reverse) { move.x = -move.x; } if (jumpState == JumpState.Grounded && Input.GetButtonDown("Jump")) { jumpState = JumpState.PrepareToJump; } else if (Input.GetButtonUp("Jump")) { stopJump = true; Schedule <PlayerStopJump>().player = this; } } else { move.x = 0; } UpdateJumpState(); base.Update(); }
void UpdateJumpState() { jump = false; switch (jumpState) { case JumpState.PrepareToJump: jumpState = JumpState.Jumping; jump = true; stopJump = false; break; case JumpState.Jumping: if (!IsGrounded) { Schedule <PlayerJumped>().player = this; jumpState = JumpState.InFlight; } break; case JumpState.InFlight: if (IsGrounded) { Schedule <PlayerLanded>().player = this; jumpState = JumpState.Landed; } break; case JumpState.Landed: jumpState = JumpState.Grounded; break; } }
private void Jump() { float jumpVal = Input.GetKeyDown(KeyCode.Space) ? jumpForce : 0.0f; switch (_jumpState) { case JumpState.Grounded: if (jumpVal > 0.0f) { _jumpState = JumpState.Jumping; Debug.Log("JumpState: " + _jumpState.ToString()); } break; case JumpState.Jumping: if (jumpVal > 0.0f) { _jumpState = JumpState.DoubleJumping; Debug.Log("JumpState: " + _jumpState.ToString()); } break; case JumpState.DoubleJumping: jumpVal = 0.0f; break; } Vector3 jumping = new Vector3(0.0f, jumpVal, 0.0f); rb.AddForce(jumping); }
public static Unit ReadFrom(System.IO.BinaryReader reader) { var result = new Unit(); result.PlayerId = reader.ReadInt32(); result.Id = reader.ReadInt32(); result.Health = reader.ReadInt32(); result.Position = Vec2Double.ReadFrom(reader); result.Size = Vec2Double.ReadFrom(reader); result.JumpState = JumpState.ReadFrom(reader); result.WalkedRight = reader.ReadBoolean(); result.Stand = reader.ReadBoolean(); result.OnGround = reader.ReadBoolean(); result.OnLadder = reader.ReadBoolean(); result.Mines = reader.ReadInt32(); if (reader.ReadBoolean()) { result.Weapon = Model.Weapon.ReadFrom(reader); } else { result.Weapon = null; } return(result); }
private void Jump() { float JumpVal = Input.GetKeyDown(KeyCode.Space) ? jumpForce : 0.0f; switch (_jumpState) { case JumpState.Grounded: if (JumpVal > 0.0f) { _jumpState = JumpState.Jumping; } break; case JumpState.Jumping: if (JumpVal > 0.0f) { _jumpState = JumpState.DoubleJumping; } break; case JumpState.DoubleJumping: JumpVal = 0.0f; break; } Vector3 jump = new Vector3(0.0f, JumpVal, 0.0f); rb.AddForce(jump); }
private void Init() { if (!inited) { inited = true; //初始化 InitDelegate(); InitFormatPrefabRectTransform(); InitCursor(); InitContentTrans(); //注册预制体对象池 RegistObjectPool(); //注册滚动监听 ScrollRect.onValueChanged.AddListener(OnValueChanged); if (scrollDirection == ScrollDirection.Vertical) { onAlignScrollDataAction = AlignScrollDataWhenVertical; onGetDistanceToCenter = GetDistanceToCenterWhenVeritical; jumpState = new JumpState(this, SetNormalizedPosWhenVertical, GetNormalizedPosWhenVertical); } else if (scrollDirection == ScrollDirection.Horizontal) { onAlignScrollDataAction = SetSingleContentDataWhenHorizontal; onGetDistanceToCenter = GetDistanceToCenterWhenHorizontal; jumpState = new JumpState(this, SetNormalizedPosWhenHorizontal, GetNormalizedPosWhenHorizontal); } } }
void Update() { if (!HasGroundCollisionInProgress()) { jumpState = JumpState.InAir; } UpdateInput(); UpdateJump(); float dragSpeed = 0; if (!isMoving && jumpState == JumpState.Grounded && moveSpeed != 0) { dragSpeed = -Mathf.Sign(moveSpeed) * dragAcc * Time.fixedDeltaTime; if (Mathf.Sign(moveSpeed + dragSpeed) != Mathf.Sign(moveSpeed)) { dragSpeed = -moveSpeed; } } float gravityEnabled = jumpState == JumpState.Grounded ? 0 : 1; moveSpeed = Mathf.Clamp(moveSpeed + inputDirection * moveAcc * Time.fixedDeltaTime, -maxSpeed, maxSpeed); moveSpeed = moveSpeed + gravityEnabled * gravityDir.x * gravityAcc * Time.fixedDeltaTime; moveSpeed = moveSpeed + dragSpeed; ySpeed = ySpeed + gravityEnabled * gravityDir.y * gravityAcc * Time.fixedDeltaTime; transform.position = transform.position + new Vector3(moveSpeed, ySpeed, 0) * Time.fixedDeltaTime; }
private void OnCollisionEnter(Collision collision) { if (collision.transform.tag == "Floor") { jumpState = JumpState.Grounded; } }
public override CharacterState UpdataState(Character character, InputOrder input) { CharacterState tempState = this; if (!character.OnGround()) { tempState = new JumpState(); } else { switch (input) { case InputOrder.stand: tempState = new IdleState(); break; case InputOrder.jump: character.DoJump(); tempState = new JumpState(); break; case InputOrder.squat: tempState = new SquatState(); break; } } return(tempState); }
private void OnCollisionEnter(Collision collision) { if (jumpState == JumpState.Jumping && collision.gameObject.CompareTag("Ground")) { jumpState = JumpState.Grounded; } }
private void UpdatePreviousStates() { previousJumpState = currentJumpState; previouslyWasStrafing = currentlyIsStrafing; previousCrouchState = currentCrouchState; previousRunState = currentRunState; }
// Start is called before the first frame update void Start() { jumpState = JumpState.OnGround; speed = 0; gravity = 3; //height should also be zero. }
public void Jump() { if (previousJumpState == JumpState.Grounded) { currentJumpState = JumpState.Inititated; } }
public void OnUpdate(ref GruntState playerState) { if (playerState == GruntState.Standing) { m_body.constraints = RigidbodyConstraints.FreezeRotationX | RigidbodyConstraints.FreezeRotationZ; } m_isJumpDown = false; //= Input.GetButton("Jump"); //if (Application.platform == RuntimePlatform.Android) // m_isJumpDown = Input.touchCount != 0; if (m_isJumpDown && m_jumpState == JumpState.Landed && CanJump(playerState)) { if ((Time.time * 1000.0f) - m_jumpTimer > JumpDelayMS) { m_jumpTimer = (Time.time * 1000.0f); m_body.AddForce(new Vector3(0, PlayerJumpHeight, 0), ForceMode.Impulse); m_jumpState = JumpState.Jumping; playerState = GruntState.Jumping; m_collisionState = CollisionState.None; } } if (m_jumpState == JumpState.Jumping && playerState == GruntState.Jumping) { if ((Time.time * 1000.0f) - m_jumpTimer > 2000.0f) { playerState = GruntState.FallJumping; } } }
void Wave() { DOTween.Kill("Wave"); _launchPosition = _mainCamera.ScreenToWorldPoint(new Vector3(Input.mousePosition.x, Input.mousePosition.y, -_mainCamera.transform.position.z)); _rigidbody.velocity = Vector3.zero; LaunchRocket(); Vector3 recoilDirection = transform.position - _launchPosition; recoilDirection.z = 0; recoilDirection.Normalize(); _mainCamera.GetComponent <ScreenShakeCamera> ().CameraShaking(FeedbackType.Jump); _rigidbody.AddForce(recoilDirection * _waveForce, ForceMode.Impulse); _waveForce = 0; WaveForceDebug = 0; JumpState = JumpState.InAir; if (OnJump != null) { OnJump(); } _slowMotion.StopSlowMotion(); WaveState = WaveState.CanWave; }
public void WriteTo(System.IO.BinaryWriter writer) { if (writer == null) throw new System.ArgumentNullException(nameof(writer)); writer.Write(PlayerId); writer.Write(Id); writer.Write(Health); Position.WriteTo(writer); Size.WriteTo(writer); JumpState.WriteTo(writer); writer.Write(WalkedRight); writer.Write(Stand); writer.Write(OnGround); writer.Write(OnLadder); writer.Write(Mines); if (Weapon == null) writer.Write(false); else { writer.Write(true); Weapon.WriteTo(writer); } }
protected override void ComputeVelocity() { if (!(isOnEnemy || IsDead)) { if (jumpState == JumpState.PrepareToJump && IsGrounded) { velocity.y = jumpTakeOffSpeed; jumpState = JumpState.Jumping; } const float moveEpsilon = 0.01f; if (movementVec.x > moveEpsilon && !IsGrabbing && spriteRenderer.flipX) { spriteRenderer.flipX = false; } else if (movementVec.x < -moveEpsilon && !IsGrabbing && !spriteRenderer.flipX) // Don't flip when grabbing { spriteRenderer.flipX = true; } } animator.SetBool("Jumping", jumpState == JumpState.Jumping || jumpState == JumpState.InFlight); animator.SetBool("Grounded", IsGrounded); animator.SetBool("Grabbing", IsGrabbing); animator.SetBool("Dead", isOnEnemy || IsDead); animator.SetFloat("VelocityX", Mathf.Abs(velocity.x) / moveSpeed); if (!(isOnEnemy || IsDead)) { targetVelocity = movementVec * moveSpeed; } }
private void UpdateJumpState() { m_IsJumped = false; switch (m_JumpState) { case JumpState.PrepareToJump: { m_IsJumped = true; m_JumpState = JumpState.Jumping; } break; case JumpState.Jumping: { m_JumpState = JumpState.InFlight; } break; case JumpState.InFlight: { if (IsGrounded) { m_JumpState = JumpState.Landed; } } break; case JumpState.Landed: { m_JumpState = JumpState.Grounded; } break; } }
// Update is called once per frame void Update() { SetScoreText(); if (Input.GetKey(KeyCode.UpArrow) && CanJump) { jumpState = JumpState.Animating; StartCoroutine(Jump(0)); } if (Input.GetKey(KeyCode.RightArrow)) { if ((branch == -1 || branch == 0) && CanJump) { jumpState = JumpState.Animating; StartCoroutine(Jump(1)); } } if (Input.GetKey(KeyCode.LeftArrow)) { if ((branch == 0 || branch == 1) && CanJump) { jumpState = JumpState.Animating; StartCoroutine(Jump(-1)); } } }
private void OnCollisionEnter(Collision collision) { if ((_jumpState == JumpState.Jumping || _jumpState == JumpState.DoubleJumping) && collision.gameObject.CompareTag("Ground")) { _jumpState = JumpState.Grounded; } }
public void StartJump() { if (jumpState == JumpState.NO_JUMP) { currJumpHeight = 0; currFlyingDistance = 0; jumpState = JumpState.GOING_UP; } }
public Skater() : base() { this.spriteName = "boy_skate"; maxJumpHeight = 40; currJumpHeight = 0; maxFlyingDistance = 20; jumpState = JumpState.NO_JUMP; }
// void OnTap (TapGesture gesture) // { // Debug.Log(gesture.Recognizer.name); // if(playerMotorState != PlayerMotorState.disabled) // { // Jump (); // } // } public void Jump() { if(jumpState == JumpState.grounded) { jumpState = JumpState.jumping; m_JumpHeight = GetJumpHeight(); this.GetComponent<Rigidbody2D>().velocity = new Vector2 (walkingSpeed, m_JumpHeight); StartCoroutine(JumpAnimation()); } }
public void TrackUserYPosition(float yPosition, float timestamp) { if (oldYPos != -10) yVelocity = (yPosition - oldYPos)/(timestamp - oldPosTimestamp); float x = Mathf.Pow(0.2f, timestamp - oldPosTimestamp); // TODO: Consider a system of adjusting this based on crouch or jump lowPassY = x*lowPassY + (1-x)*(yPosition); oldYPos = yPosition; oldPosTimestamp = timestamp; jumpState = JumpState.STANDING; if (yVelocity > jumpVelThreshold) jumpState = JumpState.JUMPING; if (yPosition < lowPassY - crouchThreshold) jumpState = JumpState.CROUCHING; }
// Update is called once per frame void Update () { if (combat.turn == TurnState.ENEMYSTART) { jumpState = JumpState.FORWARD; } if (jumpState == JumpState.FORWARD) { JumpForward(); } else if (jumpState == JumpState.KNOCKBACK) { Knockback(); } }
public ParticleSystem explosion; //the particle system that makes the ninja explode // Use this for initialization void Start () { //initialize variables jumpState = JumpState.GROUNDED; jumpPointNumber = jumpPoints.Count; currentJumpPoint = jumpPointNumber - 1; for (int i = 0; i < jumpPointNumber; i += 1) { Vector3 temp = jumpPoints[i].position; temp.z = transform.position.z; jumpPoints[i].position = temp; } turnCounter = GetComponentInChildren<TextMesh>(); turnCounter.text = currentJumpPoint.ToString (); combat = GameObject.Find("CombatController").GetComponent<CombatController>(); }
// Update is called once per frame void Update() { if(!pulling && Input.GetMouseButtonDown(0)) { //ground and air jump logic. //if body must be grounded to jump if(requireGrounded) { //if body is currently not grounded if(!grounded) { //first jump occured or am currently air jumping and havnet performed the max number of air jumps if((jumpState == JumpState.FirstJumpOccured || jumpState == JumpState.AirJumping) && numAirJumpsPreformed < numAirJumps) { jumpState = JumpState.AirJumping; //i am air jumping numAirJumpsPreformed++; //increase the number of air jumps performed } else { //i am unable to jump. exit. jumpState = JumpState.Unable; return; } } else { //i am grounded and performed my first jump jumpState = JumpState.FirstJumpOccured; } } //Process the input! StartCoroutine(ProcessPull()); } }
public void SetLedgeGrabState(CEntityPlayer player, PlayerState state) { if (state == PlayerState.LedgeHang) { m_velocity = 0; player.SetPlayerState(PlayerState.LedgeHang); m_body.constraints = RigidbodyConstraints.FreezeAll; m_jumpState = JumpState.Landed; } }
public void OnUpdate(ref PlayerState playerState) { if (playerState == PlayerState.Standing) m_body.constraints = RigidbodyConstraints.FreezeRotationX | RigidbodyConstraints.FreezeRotationZ; m_isJumpDown = Input.GetButton("Jump"); if (Application.platform == RuntimePlatform.Android) m_isJumpDown = Input.touchCount != 0; if (m_isJumpDown && m_jumpState == JumpState.Landed && CanJump(playerState)) { if ((Time.time * 1000.0f) - m_jumpTimer > JumpDelayMS) { m_jumpTimer = (Time.time * 1000.0f); m_body.AddForce(new Vector3(0, PlayerJumpHeight, 0), ForceMode.Impulse); m_jumpState = JumpState.Jumping; playerState = PlayerState.Jumping; m_collisionState = CollisionState.None; } } if (m_jumpState == JumpState.Jumping && playerState == PlayerState.Jumping) { if ((Time.time * 1000.0f) - m_jumpTimer > 2000.0f) { playerState = PlayerState.FallJumping; } } if (m_ladderClimb.State != LadderState.None) { if (m_ladderClimb.State != LadderState.JumpOff) { playerState = PlayerState.UpALadder; m_collisionState = CollisionState.None; m_ladderClimb.CallOnUpdate(m_collisionState); } else playerState = PlayerState.Jumping; if (m_ladderClimb.State == LadderState.JumpOff && m_jumpState != JumpState.Jumping) { if (Input.GetAxis("Horizontal") == 0.0f) { m_ladderClimb.State = LadderState.AtMiddle; m_collisionState = CollisionState.None; playerState = PlayerState.UpALadder; return; } m_jumpTimer = (Time.time * 1000.0f); m_body.AddForce(new Vector3(0, PlayerJumpHeight, 0), ForceMode.Impulse); m_jumpState = JumpState.Jumping; playerState = PlayerState.Jumping; m_velocity = Input.GetAxis("Horizontal") * -2.0f; m_body.constraints = RigidbodyConstraints.FreezeRotationX | RigidbodyConstraints.FreezeRotationZ; m_velocityLockTimer = (Time.time * 1000.0f); } } }
public void MakeJump() { m_fakeJump = true; m_jumpTimer = ((Time.time) * 1000.0f); m_jumpState = JumpState.Jumping; CEntityPlayer.GetInstance().SetPlayerState(PlayerState.Jumping); m_collisionState = CollisionState.None; }
/* * \brief Called on player update */ public void OnFixedUpdate(ref PlayerState playerState) { if (playerState == PlayerState.FallingFromTower) return; //////////////////////// bool wasJump = m_isJumpDown; m_isJumpDown = Input.GetButtonDown("Jump"); if (Application.platform == RuntimePlatform.Android) m_isJumpDown = Input.touchCount != 0; if (m_isJumpDown && !wasJump) { m_canJumpFromLedge = true; } else { m_canJumpFromLedge = false; } if (m_isJumpDown && m_jumpState == JumpState.Landed && CanJump(playerState)) { if ((Time.time * 1000.0f) - m_jumpTimer > JumpDelayMS) { m_jumpTimer = (Time.time * 1000.0f); m_body.AddForce(new Vector3(0, PlayerJumpHeight, 0), ForceMode.Impulse); m_jumpState = JumpState.Jumping; playerState = PlayerState.Jumping; m_collisionState = CollisionState.None; } } if (m_jumpState == JumpState.Jumping && playerState == PlayerState.Jumping) { if ((Time.time * 1000.0f) - m_jumpTimer > 2000.0f) { playerState = PlayerState.FallJumping; if (!m_fakeJump && ((Time.time * 1000.0f) - m_jumpTimer > 3000.0f)) { m_player.PushPlayerFromTower(); } } } if (m_isJumpDown == true && (GetLadder.state == LadderState.OnMiddle || GetLadder.state == LadderState.OnTop)) { GetLadder.state = LadderState.JumpingOff; m_jumpTimer = (Time.time * 1000.0f); m_body.velocity = Vector3.zero; m_body.AddForce(new Vector3(0, PlayerJumpHeight, 0), ForceMode.Impulse); m_jumpState = JumpState.Jumping; playerState = PlayerState.Jumping; m_collisionState = CollisionState.None; rigidbody.constraints = RigidbodyConstraints.FreezeRotationX | RigidbodyConstraints.FreezeRotationZ; } //////////////////////// float velocity = (Input.GetAxis("Horizontal") * MaxSpeed) * m_invert; if (Application.platform == RuntimePlatform.Android) velocity = Input.acceleration.y; if (playerState == PlayerState.OnLadder || playerState == PlayerState.LedgeClimb || playerState == PlayerState.LedgeClimbComplete) velocity = 0.0f; if (m_player.PullingLever(false)) velocity = 0.0f; if ((Time.time * 1000.0f) - m_velocityLockTimer < 350) { velocity = m_velocity; } if (velocity != 0.0f && (m_ladder.state != LadderState.AtBase && m_ladder.state != LadderState.JumpingOff)) { m_ladder.state = LadderState.None; } int direction = isNearly(velocity, 0.0f, 0.1f) ? 0 : velocity > 0 ? 1 : -1; //platform update if (m_platform && m_collisionState == CollisionState.OnFloor) { m_platformVelocity += m_platform.DeltaA; m_platform.resetDeltaA(); } // Ledge hanging code start if (playerState == PlayerState.LedgeHang || playerState == PlayerState.LedgeClimb || playerState == PlayerState.LedgeClimbComplete) { m_velocity = 0.0f; // If we are trying to move in the opposite way of the wall, fall off the wall if (direction != 0 && direction != m_movingDirection) { m_velocity = velocity * 4.0f; playerState = PlayerState.Walking; m_jumpState = JumpState.Landed; m_body.constraints = RigidbodyConstraints.FreezeRotationX | RigidbodyConstraints.FreezeRotationZ; m_movingDirection *= -1; m_direction *= -1; m_collisionState = CollisionState.None; Transform t = m_ledgeGrabBox.transform; t.localPosition = new Vector3(m_direction > 0 ? -0.18f : 0.18f, t.localPosition.y, t.localPosition.z); return; } // if the player is not already climbing the wall, check keys if (playerState != PlayerState.LedgeClimb) { // if the user pressed up, climb the wall if (Input.GetAxis("Vertical") > 0 && playerState != PlayerState.LedgeClimbComplete) { playerState = PlayerState.LedgeClimb; m_jumpState = JumpState.Landed; } // if the user pressed space, jump off the wall else if (m_isJumpDown && m_canJumpFromLedge) { m_body.constraints = RigidbodyConstraints.FreezeRotationX | RigidbodyConstraints.FreezeRotationZ; m_velocity = -(m_movingDirection) * 4.0f; // kick it away from the wall m_body.AddForce(new Vector3(0, PlayerJumpHeight * 0.25f, 0), ForceMode.Impulse); playerState = PlayerState.Jumping; m_collisionState = CollisionState.None; m_movingDirection *= -1; m_direction *= -1; Transform t = m_ledgeGrabBox.transform; t.localPosition = new Vector3(m_direction > 0 ? -0.18f : 0.18f, t.localPosition.y, t.localPosition.z); } return; } return; } // Ledge hanging code end if (playerState == PlayerState.WallJumpStart) { if (Time.time - m_wallJump.StartHangTime > 1.0f) { m_body.constraints = RigidbodyConstraints.FreezeRotationX | RigidbodyConstraints.FreezeRotationZ; m_velocity = -m_wallJump.WallJumpDirection; playerState = PlayerState.Walking; m_jumpState = JumpState.Landed; m_collisionState = CollisionState.None; } else if (Input.GetButton("Jump") && (direction != 0 && direction != m_wallJump.WallJumpDirection)) { m_body.constraints = RigidbodyConstraints.FreezeRotationX | RigidbodyConstraints.FreezeRotationZ; m_velocity = -(m_wallJump.WallJumpDirection * 0.5f); // kick it away from the wall m_velocityLockTimer = (Time.time * 1000.0f) + 50; m_body.AddForce(new Vector3(0, PlayerJumpHeight * 1.1f, 0), ForceMode.Impulse); playerState = PlayerState.Jumping; m_jumpState = JumpState.Jumping; m_jumpTimer = (Time.time * 1000.0f); m_collisionState = CollisionState.None; m_movingDirection = m_wallJump.WallJumpDirection; m_direction = m_wallJump.WallJumpDirection; } return; } if (!(m_collisionState == CollisionState.OnWall && m_jumpState == JumpState.Jumping)) m_velocity = velocity; int lastDirection = m_direction; int lastMovingDirection = m_movingDirection; if (playerState != PlayerState.Turning) { m_direction = direction; if (m_direction != 0) m_movingDirection = m_direction; } if (m_collisionState != CollisionState.None && m_jumpState != JumpState.Jumping) { if (m_direction == 0 && playerState != PlayerState.Turning) { if (playerState != PlayerState.OnLadder && !m_player.PullingLever(false)) { playerState = PlayerState.Standing; } } else { if (playerState == PlayerState.Turning) { m_velocity = 0.0f; return; } // are we tuning round? if (lastDirection != direction && ((Time.time * 1000.0f) - m_turnLockTimer > 1000.0f)) { playerState = PlayerState.Walking; if (m_velocity != 0.0f && lastMovingDirection != m_direction) { playerState = PlayerState.Turning; m_velocity = 0.0f; m_turnLockTimer = Time.time * 1000.0f; } } else playerState = PlayerState.Walking; } } }
/// <summary> /// Initialize controlling state machine /// </summary> private void InitializeStateMachine() { Debug.Log("Init state machine"); // States IdleState idleState = new IdleState(); idleState.Parent = this; mStateMachine.AddState(idleState); SkiState skiState = new SkiState(); skiState.Parent = this; mStateMachine.AddState(skiState); CrouchState crouchState = new CrouchState(); crouchState.Parent = this; mStateMachine.AddState(crouchState); JumpState jumpState = new JumpState(); jumpState.Parent = this; mStateMachine.AddState(jumpState); InAirState inAirState = new InAirState(); inAirState.Parent = this; mStateMachine.AddState(inAirState); LandingState landState = new LandingState(); landState.Parent = this; mStateMachine.AddState(landState); FallDownState fallDownState = new FallDownState(); fallDownState.Parent = this; mStateMachine.AddState(fallDownState); // Transitions /////////////////// // Grounded states mStateMachine.AddTransition( CharacterEvents.To_Ski, idleState, skiState); mStateMachine.AddTransition( CharacterEvents.To_Idle, skiState, idleState); // Jump / Land states mStateMachine.AddTransition( CharacterEvents.To_Crouch, skiState, crouchState); mStateMachine.AddTransition( CharacterEvents.To_Jump, crouchState, jumpState); mStateMachine.AddTransition( CharacterEvents.To_InAir, jumpState, inAirState); mStateMachine.AddTransition( CharacterEvents.To_Landing, inAirState, landState); mStateMachine.AddTransition( CharacterEvents.To_Ski, landState, skiState); // Ramp states mStateMachine.AddTransition( CharacterEvents.To_InAir, skiState, inAirState); // for initialization mStateMachine.AddTransition( CharacterEvents.To_InAir, idleState, inAirState); // for fall down mStateMachine.AddTransition( CharacterEvents.To_FallDown, idleState, fallDownState); mStateMachine.AddTransition( CharacterEvents.To_FallDown, skiState, fallDownState); mStateMachine.AddTransition( CharacterEvents.To_FallDown, crouchState, fallDownState); // character starts in a spawn in state mStateMachine.StartState = idleState; mStateMachine.Activate(null); DeactivateRagdoll(); }
/// <summary> /// Resets all relevant properties to their "fresh"/initial states. /// Used for when the player enters rooms, spawns/respawns, or starts /// a new game. /// </summary> /// <param name="direction">The direction the player should face.</param> public void ResetActionStates(XDirection direction) { isOnGround = true; isGravityAffected = true; PlayerJumpState = JumpState.NotAllowed; PlayerXFacing = direction; midairJumps = MAX_MIDAIR_JUMPS; dashes = INFINITE_DASHES; if (rightBtnFlag == true && leftBtnFlag == false) LatestXArrow = XDirection.Right; else if (leftBtnFlag == true && rightBtnFlag == false) LatestXArrow = XDirection.Left; else LatestXArrow = XDirection.None; WallSlideDirection = XDirection.None; dashStatus = DASH_NOT_ALLOWED; velocityY = 0; velocityX = 0; accelerationX = 0; accelerationY = 0; drawnLastFrame = true; }
public void OnUpdate(ref GruntState playerState) { if (playerState == GruntState.Standing) m_body.constraints = RigidbodyConstraints.FreezeRotationX | RigidbodyConstraints.FreezeRotationZ; m_isJumpDown = false; //= Input.GetButton("Jump"); //if (Application.platform == RuntimePlatform.Android) // m_isJumpDown = Input.touchCount != 0; if (m_isJumpDown && m_jumpState == JumpState.Landed && CanJump(playerState)) { if ((Time.time * 1000.0f) - m_jumpTimer > JumpDelayMS) { m_jumpTimer = (Time.time * 1000.0f); m_body.AddForce(new Vector3(0, PlayerJumpHeight, 0), ForceMode.Impulse); m_jumpState = JumpState.Jumping; playerState = GruntState.Jumping; m_collisionState = CollisionState.None; } } if (m_jumpState == JumpState.Jumping && playerState == GruntState.Jumping) { if ((Time.time * 1000.0f) - m_jumpTimer > 2000.0f) { playerState = GruntState.FallJumping; } } }
/* * \brief Called whilst a collision is taking place */ public void CallOnCollisionStay(Collision collision, ref GruntState playerState, ref float playerAlpha) { m_collisionState = CollisionState.None; foreach (ContactPoint contact in collision) { Debug.DrawRay(contact.point, contact.normal); // if (contact.otherCollider != null && contact.otherCollider.gameObject != null) { CSceneObjectPlatform platform = contact.otherCollider.gameObject.GetComponent<CSceneObjectPlatform>(); if (platform != null && m_platform == null) { m_platform = platform; m_platform.resetDeltaA(); } } // CSceneObject obj = null; if (contact.otherCollider) { obj = contact.otherCollider.gameObject.GetComponent<CSceneObject>(); if (obj == null && contact.otherCollider.gameObject.transform.parent != null) { GameObject parent = contact.otherCollider.gameObject.transform.parent.gameObject; if (parent != null) { obj = parent.GetComponent<CSceneObject>(); } } } // floor check else if (isNearly(contact.normal.y, 1.0f, 0.8f)) { m_collisionState = CollisionState.OnFloor; if (!isNearly(contact.normal.y, 1.0f, 0.15f) && collision.contacts.Length == 1) { m_velocity = (m_movingDirection * 0.15f); m_velocityLockTimer = (Time.time * 1000.0f); } if(contact.otherCollider) { // are we on a special material? m_footMaterial = FootMaterial.Stone; if (contact.otherCollider.tag == "Wood Object") m_footMaterial = FootMaterial.Wood; else if (contact.otherCollider.tag == "Metal Object") m_footMaterial = FootMaterial.Metal; } } // head check else if (isNearly(contact.normal.y, -1.0f, 0.1f)) { m_collisionState = CollisionState.OnRoof; } // wall check else { if (isFacingCollision(m_movingDirection, m_body.transform.position, contact.point, playerAlpha)) { m_collisionState = CollisionState.OnWall; break; } } } if (m_collisionState == CollisionState.OnWall && m_jumpState == JumpState.Jumping && playerState != GruntState.WallJumpStart) { m_velocity = -(m_movingDirection * 0.15f); } if (m_collisionState == CollisionState.OnFloor && ((Time.time * 1000.0f) - m_jumpTimer > 200.0f)) { m_jumpState = JumpState.Landed; if (m_grunt.GetGruntState() != GruntState.Turning) m_grunt.SetGruntState(GruntState.Standing); } }
/// <summary> /// Changes all of the player's relevant properties to reflect that /// the left or right side of its collision box has just hit a wall /// or a horizontal edge of the map. /// </summary> public override void CollideX() { if (dashStatus >= DASH_HELD) { dashStatus = DASH_LAG_START; isGravityAffected = true; velocityY = 0; if (jumpBtnFlag == true) PlayerJumpState = JumpState.NotAllowed; else PlayerJumpState = JumpState.Allowed; } if (currentHealth < 0) { accelerationX = 0; velocityX *= -0.5f; } else base.CollideX(); }
/// <summary> /// Changes all of the player's relevant properties to reflect that /// the top end of its collision box has just hit a ceiling. /// </summary> public override void HitCeiling() { if (jumpBtnFlag == false) PlayerJumpState = JumpState.Allowed; else PlayerJumpState = JumpState.NotAllowed; base.HitCeiling(); }
/// <summary> /// Changes all of the player's relevant properties to reflect that /// the bottom side of its collision box has just hit a floor. /// </summary> public override void Land() { soundEngine.Play(AudioEngine.SoundEffects.Land); if (jumpBtnFlag == false) PlayerJumpState = JumpState.Allowed; else PlayerJumpState = JumpState.NotAllowed; if (dashStatus >= DASH_HELD) { dashStatus = DASH_NOT_ALLOWED; isGravityAffected = true; } if (dashBtnFlag == false) dashStatus = DASH_ALLOWED; else dashStatus = DASH_NOT_ALLOWED; midairJumps = MAX_MIDAIR_JUMPS; dashes = INFINITE_DASHES; if (currentHealth > 0) base.Land(); else { isOnGround = true; accelerationY = 0; if (DisplacementY <= 2) velocityY = 0; else velocityY *= -0.5f; } }
//move ninja to a previous jump point void Knockback() { transform.position = Vector3.MoveTowards(transform.position, jumpPoints[currentJumpPoint].position, jumpSpeed * 2 * Time.deltaTime); if (transform.position == jumpPoints[currentJumpPoint].position) { jumpState = JumpState.GROUNDED; } }
void Start() { personCtrl = this.GetComponent<HeroCtrl>(); heroStateActVer = new IdleStateActVer(this.gameObject); heroStateMoveVer = new IdleStateMoveVer(this.gameObject); inputArgs = new InputEventArgs("", "", ""); hero_act_state[0] = new IdleStateActVer(this.gameObject); hero_act_state[1] = new ActState(this.gameObject); hero_act_state[2] = new DefenseState(this.gameObject); hero_move_state[0] = new IdleStateMoveVer(this.gameObject); hero_move_state[1] = new MoveState(this.gameObject); hero_move_state[2] = new JumpState(this.gameObject); InputTran += new InputEventHandler(heroStateActVer.handleInput); InputTran += new InputEventHandler(heroStateMoveVer.handleInput); }
public void setJumpState(JumpState state) { this.jumpState = state; }
public void OnUpdate(ref PlayerState playerState) { if (playerState == PlayerState.Standing) { m_body.constraints = RigidbodyConstraints.FreezeRotationX | RigidbodyConstraints.FreezeRotationZ; m_fakeJump = false; if (GetLadder.state != LadderState.AtBase) { // standing, we can't be on a ladder GetLadder.state = LadderState.None; GetLadder.offset = 0.0f; GetLadder.moving = false; GetLadder.direction = 0.0f; } } bool wasJump = m_isJumpDown; m_isJumpDown = Input.GetButtonDown("Jump"); if (Application.platform == RuntimePlatform.Android) m_isJumpDown = Input.touchCount != 0; if (m_isJumpDown && !wasJump) { m_canJumpFromLedge = true; } else { m_canJumpFromLedge = false; } if (m_isJumpDown && m_jumpState == JumpState.Landed && CanJump(playerState)) { if ((Time.time * 1000.0f) - m_jumpTimer > JumpDelayMS) { m_jumpTimer = (Time.time * 1000.0f); m_body.AddForce(new Vector3(0, PlayerJumpHeight, 0), ForceMode.Impulse); m_jumpState = JumpState.Jumping; playerState = PlayerState.Jumping; m_collisionState = CollisionState.None; } } if (m_jumpState == JumpState.Jumping && playerState == PlayerState.Jumping) { if ((Time.time * 1000.0f) - m_jumpTimer > 2000.0f) { playerState = PlayerState.FallJumping; if (!m_fakeJump && ((Time.time * 1000.0f) - m_jumpTimer > 3000.0f)) { m_player.PushPlayerFromTower(); } } } if (m_isJumpDown == true && (GetLadder.state == LadderState.OnMiddle || GetLadder.state == LadderState.OnTop)) { GetLadder.state = LadderState.JumpingOff; m_jumpTimer = (Time.time * 1000.0f); m_body.velocity = Vector3.zero; m_body.AddForce(new Vector3(0, PlayerJumpHeight, 0), ForceMode.Impulse); m_jumpState = JumpState.Jumping; playerState = PlayerState.Jumping; m_collisionState = CollisionState.None; rigidbody.constraints = RigidbodyConstraints.FreezeRotationX | RigidbodyConstraints.FreezeRotationZ; } // LADDER CODE float updown = (Input.GetAxis("Vertical") * 0.001f); if (updown > 0.0f) { if (GetLadder.state == LadderState.AtBase) { if (m_jumpState == JumpState.Jumping) { GetLadder.state = LadderState.OnMiddle; } else { GetLadder.state = LadderState.OnBase; } playerState = PlayerState.OnLadder; m_collisionState = CollisionState.None; m_jumpState = JumpState.Landed; } else if (GetLadder.state == LadderState.OnBase || GetLadder.state == LadderState.OnMiddle) { GetLadder.offset = (updown * 10.0f); GetLadder.moving = true; GetLadder.direction = 1.0f; } else if (GetLadder.state == LadderState.OnTop) { GetLadder.moving = false; GetLadder.direction = 0.0f; GetLadder.offset = 0.0f; } } else if (updown < 0.0f) { if (GetLadder.state == LadderState.OnBase) { GetLadder.state = LadderState.AtBase; playerState = PlayerState.Standing; rigidbody.constraints = RigidbodyConstraints.FreezeRotationX | RigidbodyConstraints.FreezeRotationZ; rigidbody.AddForce(0, 0.1f, 0); } else if (GetLadder.state == LadderState.OnBase || GetLadder.state == LadderState.OnMiddle || GetLadder.state == LadderState.OnTop) { GetLadder.offset = (updown * 10.0f); GetLadder.moving = true; GetLadder.direction = -1.0f; } } if (updown == 0.0f && GetLadder.state != LadderState.None) { GetLadder.moving = false; GetLadder.direction = 0.0f; GetLadder.offset = 0.0f; } }
//when hit by the foot or Tommy (not currently working, which is fine; easy fix) void OnTriggerEnter2D (Collider2D coll) { if (jumpState == JumpState.GROUNDED && coll.gameObject.tag == "Foot" && coll.gameObject.GetComponent<Foot>().attackState == AttackState.SHOOTING) { Foot foot = coll.gameObject.GetComponent<Foot>(); Rigidbody2D footRB = coll.gameObject.GetComponent<Rigidbody2D>(); if (footRB.velocity.magnitude / foot.shotSpeedOriginal <= .3f) { Instantiate(explosion, transform.position, Quaternion.identity); Destroy(this.gameObject); } else { jumpState = JumpState.KNOCKBACK; } } else if (coll.gameObject.tag == "Player") { jumpState = JumpState.KNOCKBACK; } }
private void JumpBehavior() { /* * JUMP * */ if (jumpState == JumpState.grounded) { //On the ground if ((playerControl == true)) //&& (inputRef.jumpDown == true)) { jumpState = JumpState.impulse; impulseTime = 0f; } if (touchingGround == false) { jumpState = JumpState.falling; } } if (jumpState == JumpState.impulse) { //move upward while button is held down, up to max impulse time velocity = new Vector3(velocity.x, jumpSpeed, 0f); impulseTime += Time.deltaTime; if ( /*(inputRef.jumpPressed == false) ||*/ (impulseTime >= impulseLength)) { jumpState = JumpState.cresting; } if (touchingCeiling == true) { //hit ceiling velocity = new Vector3(velocity.x, 0f, 0f); jumpState = JumpState.falling; } } if (jumpState == JumpState.cresting) { //gravity is slowing the player's ascent velocity = new Vector3(velocity.x, velocity.y - gravity * Time.deltaTime, 0f); if (velocity.y < 0f) { jumpState = JumpState.falling; } if (touchingCeiling == true) { //hit ceiling velocity = new Vector3(velocity.x, 0f, 0f); jumpState = JumpState.falling; } } if (jumpState == JumpState.falling) { //gravity is pulling the player downwards velocity = new Vector3(velocity.x, velocity.y - gravity * Time.deltaTime, 0f); if (velocity.y <= -fallSpeed) { jumpState = JumpState.terminal; } if ((touchingGround == true) && (velocity.y < 0f)) { velocity = new Vector3(velocity.x, 0f, 0f); jumpState = JumpState.grounded; } } if (jumpState == JumpState.terminal) { //terminal velocity velocity = new Vector3(velocity.x, -fallSpeed, 0f); if (touchingGround == true) { velocity = new Vector3(velocity.x, 0f, 0f); jumpState = JumpState.grounded; } } }
void Update() { //Raycast in front of the player from three different heights to see if a wall is in front of the player leftWalled = (Physics2D.Raycast (midWallCheck.position, -Vector2.right, .75f, whatIsWall) || Physics2D.Raycast (midTopWallCheck.position, -Vector2.right, .75f, whatIsWall) || Physics2D.Raycast (midBotWallCheck.position, -Vector2.right, .75f, whatIsWall) || Physics2D.Raycast (topWallCheck.position, -Vector2.right, .75f, whatIsWall) || Physics2D.Raycast (botWallCheck.position, -Vector2.right, .75f, whatIsWall)); rightWalled = (Physics2D.Raycast (midWallCheck.position, Vector2.right, .75f, whatIsWall) || Physics2D.Raycast (midTopWallCheck.position, Vector2.right, .75f, whatIsWall) || Physics2D.Raycast (midBotWallCheck.position, Vector2.right, .75f, whatIsWall) || Physics2D.Raycast (topWallCheck.position, Vector2.right, .75f, whatIsWall) || Physics2D.Raycast (botWallCheck.position, Vector2.right, .75f, whatIsWall)); //Debug.Log ("WALLED: " + leftWalled + rightWalled); switch (Jump) { case JumpState.GROUNDED: if((Input.GetKey(KeyCode.Space) || Input.GetAxis ("LTrig") > 0.1) && isGrounded()) { Jump = JumpState.JUMPING; animator.SetBool ("Jump", true); //Switch to jump animation animator.SetBool ("Hit", false); } break; case JumpState.JUMPING: if((Input.GetKey(KeyCode.Space) || Input.GetAxis ("LTrig") > 0.1) && CurrJumpForce < MaxJumpForce) { var timeDiff = Time.deltaTime * 100; var forceToAdd = PlusJumpForce*timeDiff; CurrJumpForce += forceToAdd; r.AddForce(new Vector2(0, forceToAdd)); } else { Jump = JumpState.FALLING; CurrJumpForce = 0; } break; case JumpState.FALLING: if (isGrounded() && r.velocity.y <= 0) { //Debug.Log("Grounded"); Use this to debug jump issues Jump = JumpState.GROUNDED; animator.SetBool ("Jump", false); //End jump animation } break; } }
/* * \brief Works out if a value is almost another value (for floating point accuracy) */ public void CallOnCollisionEnter(Collision collision) { m_collisionState = CollisionState.None; foreach (ContactPoint contact in collision) { m_platform = contact.otherCollider.gameObject.GetComponent<CSceneObjectPlatform>(); if (m_platform != null) { m_platform.resetDeltaA(); } if (isNearly(contact.normal.y, 1.0f, 0.2f)) { m_collisionState = CollisionState.OnFloor; // are we on a special material? m_footMaterial = FootMaterial.Stone; if (contact.otherCollider.tag == "Wood Object") m_footMaterial = FootMaterial.Wood; else if (contact.otherCollider.tag == "Metal Object") m_footMaterial = FootMaterial.Metal; } else if (isNearly(contact.normal.y, -1.0f, 0.2f)) { m_collisionState = CollisionState.OnRoof; } else { m_collisionState = CollisionState.OnWall; m_ladderClimb.State = LadderState.None; } } if (m_collisionState == CollisionState.OnFloor) { if (m_jumpState != JumpState.Landed) m_player.GetPlayerAnimation().PlayFootstepAudio(m_footMaterial); m_jumpState = JumpState.Landed; m_ladderClimb.State = LadderState.None; if (m_player.GetPlayerState() != PlayerState.Turning) m_player.SetPlayerState(PlayerState.Standing); //m_ledgeGrabBox.collider.enabled = true; } }
/* * \brief Called whilst a collision is taking place */ public void CallOnCollisionStay(Collision collision, ref PlayerState playerState, ref float playerAlpha) { m_collisionState = CollisionState.None; foreach (ContactPoint contact in collision) { Debug.DrawRay(contact.point, contact.normal); // if (contact.otherCollider != null && contact.otherCollider.gameObject != null) { CSceneObjectPlatform platform = contact.otherCollider.gameObject.GetComponent<CSceneObjectPlatform>(); if (platform != null && m_platform == null) { m_platform = platform; m_platform.resetDeltaA(); } } // CSceneObject obj = null; if (contact.otherCollider) { obj = contact.otherCollider.gameObject.GetComponent<CSceneObject>(); if (obj == null && contact.otherCollider.gameObject.transform.parent != null) { GameObject parent = contact.otherCollider.gameObject.transform.parent.gameObject; if (parent != null) { obj = parent.GetComponent<CSceneObject>(); } } } if (contact.thisCollider != null && contact.thisCollider.gameObject != null && contact.thisCollider.gameObject.name == "Ledge_Grab_Detection" && (obj == null || obj.CanLedgeGrab)) { if(CSceneObject.CheckLedgeGrab(collision)) continue; } if (contact.otherCollider != null && contact.otherCollider.gameObject != null && contact.otherCollider.gameObject.name == "Ledge_Grab_Detection" && (obj == null || obj.CanLedgeGrab)) { if (CSceneObject.CheckLedgeGrab(collision)) continue; } // wall jumping if (obj != null && obj.CanWallJump == true && m_jumpState != JumpState.Landed && !isNearly(contact.normal.y, 1.0f, 0.2f) && !isNearly(contact.normal.y, -1.0f, 0.1f)) { m_collisionState = CollisionState.OnWall; playerState = PlayerState.WallJumpStart; m_jumpTimer = (Time.time * 1000.0f); m_body.constraints = RigidbodyConstraints.FreezeAll; m_velocity = 0.0f; m_wallJump.StartHangTime = Time.time * 1000.0f; } // floor check else if (isNearly(contact.normal.y, 1.0f, 0.8f)) { m_collisionState = CollisionState.OnFloor; if (!isNearly(contact.normal.y, 1.0f, 0.15f) && collision.contacts.Length == 1) { m_velocity = (m_movingDirection * 0.15f); m_velocityLockTimer = (Time.time * 1000.0f); } // are we on a special material? m_footMaterial = FootMaterial.Stone; if (contact.otherCollider.tag == "Wood Object") m_footMaterial = FootMaterial.Wood; else if (contact.otherCollider.tag == "Metal Object") m_footMaterial = FootMaterial.Metal; } // head check else if (isNearly(contact.normal.y, -1.0f, 0.1f)) { m_collisionState = CollisionState.OnRoof; } // wall check else { if (isFacingCollision(m_movingDirection, m_body.transform.position, contact.point, playerAlpha)) { m_collisionState = CollisionState.OnWall; break; } } } if (m_collisionState == CollisionState.OnWall && m_jumpState == JumpState.Jumping && playerState != PlayerState.WallJumpStart) { m_velocity = -(m_movingDirection * 0.15f); } if (m_collisionState == CollisionState.OnFloor && ((Time.time * 1000.0f) - m_jumpTimer > 200.0f)) { m_jumpState = JumpState.Landed; if (m_ladderClimb.State != LadderState.AtBase) { m_ladderClimb.State = LadderState.None; } else { playerState = PlayerState.UpALadder; } if (m_player.GetPlayerState() != PlayerState.Turning) m_player.SetPlayerState(PlayerState.Standing); //m_ledgeGrabBox.collider.enabled = true; } }
/* * \brief Called on player update */ public void OnFixedUpdate(ref PlayerState playerState) { if (playerState == PlayerState.FallingFromTower) return; float velocity = (Input.GetAxis("Horizontal") * MaxSpeed) * m_invert; if (Application.platform == RuntimePlatform.Android) velocity = Input.acceleration.y; if ((Time.time * 1000.0f) - m_velocityLockTimer < 100) { velocity = m_velocity; } if (m_ladderClimb.State == LadderState.AtMiddle || m_ladderClimb.State == LadderState.AtTop) velocity = 0; int direction = isNearly(velocity, 0.0f, 0.1f) ? 0 : velocity > 0 ? 1 : -1; //platform update if (m_platform && m_collisionState == CollisionState.OnFloor) { m_platformVelocity += m_platform.DeltaA; m_platform.resetDeltaA(); } // Ledge hanging code start if (playerState == PlayerState.LedgeHang || playerState == PlayerState.LedgeClimb || playerState == PlayerState.LedgeClimbComplete) { m_velocity = 0.0f; // If we are trying to move in the opposite way of the wall, fall off the wall if (direction != 0 && direction != m_movingDirection) { m_velocity = velocity * 4.0f; playerState = PlayerState.Walking; m_jumpState = JumpState.Landed; m_body.constraints = RigidbodyConstraints.FreezeRotationX | RigidbodyConstraints.FreezeRotationZ; // m_ledgeGrabBox.collider.enabled = true; m_movingDirection *= -1; m_direction *= -1; m_collisionState = CollisionState.None; // Transform t = m_ledgeGrabBox.transform; // t.localPosition = new Vector3(m_direction > 0 ? -0.18f : 0.18f, t.localPosition.y, t.localPosition.z); return; } // if the player is not already climbing the wall, check keys if (playerState != PlayerState.LedgeClimb) { // if the user pressed up, climb the wall if (Input.GetAxis("Vertical") > 0 && playerState != PlayerState.LedgeClimbComplete) { playerState = PlayerState.LedgeClimb; m_jumpState = JumpState.Landed; // m_ledgeGrabBox.collider.enabled = false; } // if the user pressed space, jump off the wall else if (m_isJumpDown) { m_body.constraints = RigidbodyConstraints.FreezeRotationX | RigidbodyConstraints.FreezeRotationZ; m_velocity = -(m_movingDirection) * 4.0f; // kick it away from the wall m_body.AddForce(new Vector3(0, PlayerJumpHeight * 0.25f, 0), ForceMode.Impulse); playerState = PlayerState.Jumping; m_collisionState = CollisionState.None; m_movingDirection *= -1; m_direction *= -1; // m_ledgeGrabBox.collider.enabled = true; // Transform t = m_ledgeGrabBox.transform; // t.localPosition = new Vector3(m_direction > 0 ? -0.18f : 0.18f, t.localPosition.y, t.localPosition.z); } return; } return; } // Ledge hanging code end if (playerState == PlayerState.WallJumpStart) { if ((Time.time * 1000.0f) - m_wallJump.StartHangTime > m_wallJump.WallHangTime) { m_body.constraints = RigidbodyConstraints.FreezeRotationX | RigidbodyConstraints.FreezeRotationZ; m_velocity = -m_movingDirection; playerState = PlayerState.Walking; m_jumpState = JumpState.Landed; } else if (m_isJumpDown && direction != 0 && direction != m_movingDirection) { m_body.constraints = RigidbodyConstraints.FreezeRotationX | RigidbodyConstraints.FreezeRotationZ; m_velocity = -(m_movingDirection); // kick it away from the wall m_body.AddForce(new Vector3(0, PlayerJumpHeight * 1.1f, 0), ForceMode.Impulse); playerState = PlayerState.Jumping; m_jumpTimer = (Time.time * 1000.0f); m_collisionState = CollisionState.None; m_movingDirection *= -1; m_direction *= -1; } return; } if (!(m_collisionState == CollisionState.OnWall && m_jumpState == JumpState.Jumping)) m_velocity = velocity; int lastDirection = m_direction; int lastMovingDirection = m_movingDirection; if (playerState != PlayerState.Turning) { m_direction = direction; if (m_direction != 0) m_movingDirection = m_direction; } if (m_collisionState != CollisionState.None && m_jumpState != JumpState.Jumping) { if (m_direction == 0 && playerState != PlayerState.Turning) { playerState = PlayerState.Standing; } else { if (playerState == PlayerState.Turning) { m_velocity = 0.0f; return; } // are we tuning round? if (lastDirection != direction && ((Time.time * 1000.0f) - m_turnLockTimer > 1000.0f)) { playerState = PlayerState.Walking; if (m_velocity != 0.0f && lastMovingDirection != m_direction) { playerState = PlayerState.Turning; m_velocity = 0.0f; m_turnLockTimer = Time.time * 1000.0f; } } else playerState = PlayerState.Walking; } } }
/// <summary> /// Determines the player's intended x and y velocities based on the most recent user input, /// while updating other action-related properties. /// </summary> /// <param name="time">The amount of gametime that has elapsed since the last frame.</param> public override void Update(GameTime time) { float totalTime = (float)(time.ElapsedGameTime.TotalSeconds); if (damageStatus >= INVINCIBLE_END) { damageStatus = VULNERABLE; } else if (damageStatus >= STUN_END) { if (rightBtnFlag == true && leftBtnFlag == false) LatestXArrow = XDirection.Right; else if (leftBtnFlag == true && rightBtnFlag == false) LatestXArrow = XDirection.Left; else LatestXArrow = XDirection.None; } if (currentHealth > 0 && (damageStatus < INVINCIBLE_START || damageStatus >= STUN_END)) { if (dashStatus < DASH_HELD) { if (LatestXArrow == XDirection.Left && PlayerXFacing == XDirection.Right) PlayerXFacing = XDirection.Left; else if (LatestXArrow == XDirection.Right && PlayerXFacing == XDirection.Left) PlayerXFacing = XDirection.Right; } if (isOnGround == false && velocityY >= 0) { if (wallOnRight && rightBtnFlag) { if (WallSlideDirection == XDirection.None) { soundEngine.Play(AudioEngine.SoundEffects.WallLand); if (jumpBtnFlag == false) PlayerJumpState = JumpState.Allowed; else PlayerJumpState = JumpState.NotAllowed; if (!dashBtnFlag) dashStatus = DASH_ALLOWED; else dashStatus = DASH_NOT_ALLOWED; } WallSlideDirection = XDirection.Right; } else if (wallOnLeft && leftBtnFlag == true) { if (WallSlideDirection == XDirection.None) { soundEngine.Play(AudioEngine.SoundEffects.WallLand); if (jumpBtnFlag == false) PlayerJumpState = JumpState.Allowed; else PlayerJumpState = JumpState.NotAllowed; if (!dashBtnFlag) dashStatus = DASH_ALLOWED; else dashStatus = DASH_NOT_ALLOWED; } WallSlideDirection = XDirection.Left; } else WallSlideDirection = XDirection.None; } else WallSlideDirection = XDirection.None; if (PlayerJumpState == JumpState.NotAllowed && jumpBtnFlag == false) PlayerJumpState = JumpState.Allowed; if (jumpBtnFlag == true && PlayerJumpState == JumpState.Allowed && (isOnGround || midairJumps > 0 || wallOnLeft || wallOnRight)) { if (isOnGround == false) { if (wallOnRight || wallOnLeft) { velocityY = WALL_JUMP_V_Y; velocityX = WALL_JUMP_V_X; if (wallOnLeft) { velocityX *= -1; PlayerXFacing = XDirection.Right; } else { PlayerXFacing = XDirection.Left; } WallSlideDirection = XDirection.None; soundEngine.Play(AudioEngine.SoundEffects.WallJump); } else { midairJumps = (byte)Math.Max(0, midairJumps - 1); velocityY = JUMP_V; soundEngine.Play(AudioEngine.SoundEffects.WallJump); } } else { LeaveGround(); velocityY = JUMP_V; soundEngine.Play(AudioEngine.SoundEffects.Jump); } if (dashStatus >= DASH_HELD) { dashStatus = DASH_LAG_START; isGravityAffected = true; } PlayerJumpState = JumpState.Holding; accelerationY = 0; } if (!isOnGround) { if (PlayerJumpState == JumpState.Holding) { if (jumpBtnFlag == false) { PlayerJumpState = JumpState.Allowed; if (velocityY <= 0) { accelerationY = JUMP_DECAY; velocityLimitY = 0; } } } else if (WallSlideDirection != XDirection.None) { accelerationY = WALL_FRICTION_DEC; velocityLimitY = MAX_WALL_SLIDE_V; } else if (velocityY >= 0) { accelerationY = 0; } } if (dashStatus == DASH_ALLOWED && dashBtnFlag == true && (dashes != 0 || WallSlideDirection != XDirection.None)) { dashStatus = DASH_HELD; accelerationX = 0; if (WallSlideDirection == XDirection.Right) { velocityX = -DASH_V; PlayerXFacing = XDirection.Left; } else if (WallSlideDirection == XDirection.Left) { velocityX = DASH_V; PlayerXFacing = XDirection.Right; } else { if (dashes > 0) dashes--; if (PlayerXFacing == XDirection.Right) { velocityX = DASH_V; velocityLimitX = DASH_V; } else { velocityX = -DASH_V; velocityLimitX = -DASH_V; } } if (!isOnGround) { isGravityAffected = false; velocityY = 0; accelerationY = 0; } soundEngine.Play(AudioEngine.SoundEffects.Dash); } else if (dashStatus < DASH_NOT_ALLOWED) dashStatus = Math.Min(dashStatus + totalTime, DASH_NOT_ALLOWED); else if (dashStatus == DASH_NOT_ALLOWED && dashBtnFlag == false) dashStatus = DASH_ALLOWED; if (dashStatus >= DASH_HELD) { dashStatus += totalTime; if (dashStatus > MAX_DASH_TIME || dashBtnFlag == false) { if (LatestXArrow == XDirection.Right) velocityX = MAX_RUN_V; else if (LatestXArrow == XDirection.Left) velocityX = -MAX_RUN_V; else velocityX = 0; isGravityAffected = true; dashStatus = DASH_LAG_START; } } else { if (LatestXArrow == XDirection.Right) { if (velocityX < 0) { accelerationX = BRAKE_DEC; velocityLimitX = 0; } else if (velocityX <= MAX_RUN_V) { accelerationX = RUN_ACC; velocityLimitX = MAX_RUN_V; } else { accelerationX = TOO_FAST_DEC; velocityLimitX = MAX_RUN_V; } } else if (LatestXArrow == XDirection.Left) { if (velocityX > 0) { accelerationX = -BRAKE_DEC; velocityLimitX = 0; } else if (velocityX >= -MAX_RUN_V) { accelerationX = -RUN_ACC; velocityLimitX = -MAX_RUN_V; } else { accelerationX = -TOO_FAST_DEC; velocityLimitX = -MAX_RUN_V; } } else if (velocityX != 0) { if (velocityX > MAX_RUN_V) { accelerationX = TOO_FAST_DEC; velocityLimitX = MAX_RUN_V; } else if (velocityX > 0) { accelerationX = STOP_DEC; velocityLimitX = 0; } else if (velocityX < -MAX_RUN_V) { accelerationX = -TOO_FAST_DEC; velocityLimitX = -MAX_RUN_V; } else if (velocityX < 0) { accelerationX = -STOP_DEC; velocityLimitX = 0; } } } } if ((damageStatus >= SWITCH_TO_DEAD_FRAME) && (damageStatus <= deathSequenceEndTime) && (currentFrame == 0)) { SwitchToDeathCollision(); currentFrame++; } if (damageStatus >= INVINCIBLE_START) damageStatus += totalTime; else if (damageStatus < deathSequenceEndTime) damageStatus = Math.Min(deathSequenceEndTime, damageStatus + totalTime); if (PlayerXFacing == XDirection.Right) { if (currentHealth <= 0) currentAnimation = currentAnimation = (int)PlayerAnimations.DyingRight; else if (damageStatus >= INVINCIBLE_START && damageStatus < STUN_END) currentAnimation = (int)PlayerAnimations.DamageRight; else if (dashStatus >= DASH_HELD) currentAnimation = (int)PlayerAnimations.DashRight; else if (WallSlideDirection == XDirection.Right) currentAnimation = (int)PlayerAnimations.WallSlideRight; else if (!isOnGround) currentAnimation = (int)PlayerAnimations.JumpRight; else { currentAnimation = (int)PlayerAnimations.WalkRight; if (damageStatus >= STUN_END) animationSpeed[currentAnimation] = 2 * velocityX / MAX_RUN_V; else animationSpeed[currentAnimation] = velocityX / MAX_RUN_V; } } else { if (currentHealth <= 0) currentAnimation = currentAnimation = (int)PlayerAnimations.DyingLeft; else if (damageStatus >= INVINCIBLE_START && damageStatus < STUN_END) currentAnimation = (int)PlayerAnimations.DamageLeft; else if (dashStatus >= DASH_HELD) currentAnimation = (int)PlayerAnimations.DashLeft; else if (WallSlideDirection == XDirection.Left) currentAnimation = (int)PlayerAnimations.WallSlideLeft; else if (!isOnGround) currentAnimation = (int)PlayerAnimations.JumpLeft; else { currentAnimation = (int)PlayerAnimations.WalkLeft; if (damageStatus >= STUN_END) animationSpeed[currentAnimation] = 2 * -velocityX / MAX_RUN_V; else animationSpeed[currentAnimation] = -velocityX / MAX_RUN_V; } } if (velocityX == 0 && currentHealth > 0) currentFrame = 0; if (currentAnimation == (int)PlayerAnimations.DashLeft || currentAnimation == (int)PlayerAnimations.DashRight || currentAnimation == (int)PlayerAnimations.DyingLeft || currentAnimation == (int)PlayerAnimations.DyingRight) looping = false; else looping = true; base.Update(time); }
/* * \brief Works out if a value is almost another value (for floating point accuracy) */ public void CallOnCollisionEnter(Collision collision) { m_collisionState = CollisionState.None; foreach (ContactPoint contact in collision) { m_platform = contact.otherCollider.gameObject.GetComponent<CSceneObjectPlatform>(); if (m_platform != null) { m_platform.resetDeltaA(); } if (isNearly(contact.normal.y, 1.0f, 0.2f)) { m_collisionState = CollisionState.OnFloor; if (m_player.GetPlayerState() == PlayerState.OnLadder) { GetLadder.state = LadderState.AtBase; m_player.SetPlayerState(PlayerState.Standing); } // are we on a special material? m_footMaterial = FootMaterial.Stone; if (contact.otherCollider.tag == "Wood Object") m_footMaterial = FootMaterial.Wood; else if (contact.otherCollider.tag == "Metal Object") m_footMaterial = FootMaterial.Metal; } else if (isNearly(contact.normal.y, -1.0f, 0.2f)) { m_collisionState = CollisionState.OnRoof; if (contact.otherCollider != null && contact.otherCollider.GetComponent<CSceneObjectPlatform>() != null) { m_player.PushPlayerFromTower(); } } else { if (m_player.GetPlayerState() != PlayerState.OnLadder) m_collisionState = CollisionState.OnWall; } } if (m_collisionState == CollisionState.OnFloor) { if (m_jumpState != JumpState.Landed) m_player.GetPlayerAnimation().PlayFootstepAudio(m_footMaterial); m_jumpState = JumpState.Landed; if (GetLadder.state == LadderState.JumpingOff) GetLadder.state = LadderState.None; if (m_player.GetPlayerState() != PlayerState.Turning && m_player.GetPlayerState() != PlayerState.OnLadder && !m_player.PullingLever(false)) { m_player.SetPlayerState(PlayerState.Standing); } } }