public void Move(float movement, bool crouch, bool jump)
{
if (!crouch)
{
if (Physics2D.OverlapCircle(_playerHead.position, CeilingOverlapRadius, _groundLayerMask))
{
// Can't stand up due to obstacle on head, even though the player has stopped crouching
crouch = true;
}
}
if (_grounded || _canSteerWhileAirborne)
{
if (crouch)
{
if (_colliderToDisableOnCrouch != null)
{
_colliderToDisableOnCrouch.enabled = false;
}
if (!_wasCrouching)
{
_wasCrouching = true;
OnCrouchEvent?.Invoke(true);
}
movement *= _speedFractionWhenCrouched;
}
else
{
if (_colliderToDisableOnCrouch != null)
{
_colliderToDisableOnCrouch.enabled = true;
}
if (_wasCrouching)
{
_wasCrouching = false;
OnCrouchEvent?.Invoke(false);
}
}
Vector3 targetVelocity = new Vector2(movement * 10.0f, _rigidbody.velocity.y);
_rigidbody.velocity = Vector3.SmoothDamp(_rigidbody.velocity, targetVelocity, ref _velocity, _movementSmoothing);
int movementSign = Math.Sign(movement);
if (movementSign != 0 && movementSign != _playerDirection)
{
Flip();
}
}
if (_grounded && jump)
{
_grounded = false;
_rigidbody.AddForce(new Vector2(0.0f, _jumpForce));
}
}
public void ResendEvents()
{
musicMutedEvent?.Invoke(!musicEnabled);
musicVolumeEvent?.Invoke(save.musicVolume);
fxVolumeEvent?.Invoke(save.fxVolume);
fxMutedEvent?.Invoke(!fxEnabled);
}
private void Move()
{
if (direction.magnitude >= 0.1f)
{
controller.Move(direction * movementSpeed * Time.deltaTime);
onMovement?.Invoke(true);
return;
}
onMovement?.Invoke(false);
}
public static void SwitchGameState(bool isPlaying)
{
if (!isPlaying)
{
pausedTime = Time.time;
}
onGameStateChanged?.Invoke(isPlaying);
Debug.Log("is playing = " + isPlaying);
}
protected override bool AttackTarget(Collider[] colliders)
{
if (isPlayer)
{
Vector3 direction = playerController.GetLookingPosition() - firePoint.position;
direction.y = 0;
LaunchProjectile(direction.normalized);
return(true);
}
if (colliders.Length == 0)
{
return(false);
}
foreach (var target in colliders)
{
if (target.gameObject == gameObject)
{
continue;
}
if ((targetRb == null) || targetRb.gameObject != target.gameObject)
{
targetRb = target.GetComponent <Rigidbody>();
}
Vector3 shootingDirection = GetInterceptCourseDirection(target.transform.position, targetRb.velocity, firePoint.position, projectileSpeed);
if (shootingDirection == Vector3.zero)
{
continue;
}
RaycastHit hit;
int visibilityMask = ~(1 << gameObject.layer | 1 << (int)Layer.Interactable);
if (Physics.Raycast(firePoint.position - firePoint.forward, shootingDirection, out hit, attackRange + 1f, visibilityMask))
{
bool oldVisibilty = targetIsVisible;
targetIsVisible = hit.collider.gameObject.layer.IsInLayerMask(targetLayers);
if (targetIsVisible != oldVisibilty)
{
OnTargetVisibilityChange?.Invoke(targetIsVisible);
}
}
if (!targetIsVisible)
{
continue;
}
LaunchProjectile(shootingDirection.normalized);
return(true);
}
return(false);
}
/// <summary> Swaps the state of the pause menu. </summary>
/// <param name="isActive"> Should the pause menu be active. </param>
public void SwitchPauseState(bool isActive)
{
IsPaused = isActive;
canvases.PauseCanvas.enabled = IsPaused;
canvases.HowToPlayCanvas.enabled = false;
canvases.SettingsCanvas.enabled = false;
Time.timeScale = IsPaused ? 0f : 1f;
PauseMenuStateChanged?.Invoke(IsPaused);
}
void Update()
{
if (Input.GetButton("Fire2") != usesShield)
{
if (usesShield || Time.time >= wm.GetLastWeaponUsageTime() + shieldUsageBlockTime)
{
usesShield = !usesShield;
OnShieldingStateChanged?.Invoke(usesShield);
wm.SetCanAttack(!usesShield);
playerController.AddMovementSpeed(usesShield ? -shieldingMovementSpeedDecrease : shieldingMovementSpeedDecrease);
}
}
}
private void Invoke(bool isVisible)
{
_isVisible = isVisible;
if (_isVisible)
{
eventsOnlyActive?.Invoke();
}
else
{
eventsOnlyDisactive?.Invoke();
}
events?.Invoke(_isVisible);
}
private void Update()
{
if (_changeSkillCheckPos)
{
_changeSkillCheckPos = false;
RandomizePositionAndWidth();
}
if (Input.GetMouseButtonDown(0))
{
_canMove = false;
var colls = _pointerToCheck.CheckIfFailed();
if (colls == null || colls.Length == 0)
{
Debug.Log("Niente hai fallito");
}
bool giusto = colls.ToList().Exists(col => col.gameObject == _skillChecker.gameObject);
OnSkillCheckDone?.Invoke(giusto);
if (giusto)
{
tentativi++;
}
if (gameObject.activeInHierarchy == false)
{
return;
}
if (!_restartAfterInput)
{
return;
}
StopAllCoroutines();
StartCoroutine(WaitAfterInput());
}
}
public void Move(float movePercentage, bool crouch, bool jump)
{
//Debug.Log("added force to move the player0");
if (GravitySystem.instance.isReverseGravity)
{
movePercentage *= -1;
}
if (m_Grounded && Mathf.Abs(movePercentage) > 0.2)
{
AudioManager.instance.play("playerRun");
}
// If crouching, check to see if the character can stand up
if (!crouch)
{
// If the character has a ceiling preventing them from standing up, keep them crouching
if (Physics2D.OverlapCircle(m_CeilingCheck.position, k_CeilingRadius, m_WhatIsGround))
{
crouch = true;
}
}
//Debug.Log("added force to move the player1");
//only control the player if grounded or airControl is turned on
if (m_Grounded || m_AirControl)
{
// If crouching
if (crouch)
{
if (!m_wasCrouching)
{
m_wasCrouching = true;
OnCrouchEvent.Invoke(true);
}
// Reduce the speed by the crouchSpeed multiplier
movePercentage *= m_CrouchSpeed;
// Disable one of the colliders when crouching
if (m_CrouchDisableCollider != null)
{
m_CrouchDisableCollider.enabled = false;
}
}
else
{
// Enable the collider when not crouching
if (m_CrouchDisableCollider != null)
{
m_CrouchDisableCollider.enabled = true;
}
if (m_wasCrouching)
{
m_wasCrouching = false;
OnCrouchEvent.Invoke(false);
}
}
//Debug.Log("added force to move the player1.1");
// Vector3 gravityUp = (transform.position - center.position).normalized * gravity;
// Quaternion targetRotatoion = Quaternion.FromToRotation(transform.up, gravityUp) * transform.rotation;
// transform.rotation = Quaternion.Slerp(transform.rotation, targetRotatoion, 50 * Time.deltaTime);
// Move the character by finding the target velocity
//Vector3 targetVelocity = (transform.right.normalized * movePercentage * 10f) +Vector3.Project(m_Rigidbody2D.velocity,transform.up);
//new Vector2(move * 10f, m_Rigidbody2D.velocity.y);
// targetVelocity = Quaternion.Euler(0, 0, transform.rotation.z/Mathf.PI*360) * targetVelocity;
//Debug.Log(transform.rotation.z / Mathf.PI * 360);
//Debug.Log("added force to move the player2");
float horizontalSpeed = Vector3.Dot(m_Rigidbody2D.velocity, transform.right);
//Debug.Log("added force to move the player3");
//Debug.Log("right:" +transform.right+"vel: "+ m_Rigidbody2D.velocity+"dor: " + horizontalSpeed);
// m_Rigidbody2D.velocity = Vector3.SmoothDamp(m_Rigidbody2D.velocity, targetVelocity, ref m_Velocity, m_MovementSmoothing);
// Debug.Log(horizontalSpeed);
moveForce = GravitySystem.instance.runningSpeed;
//Debug.Log("speed reached: " + horizontalSpeed.x);
if (movePercentage > 0 && horizontalSpeed < maxMoveSpeed)
{
if (horizontalSpeed > maxMoveSpeed)
{
Debug.Log("error maximum speed reached: " + horizontalSpeed);
}
if (Mathf.Abs(horizontalSpeed) > 0.1)
{
// Debug.Log("player is trying to move sideways");
}
if (horizontalSpeed > 0)
{
m_Rigidbody2D.AddForce(transform.right.normalized * movePercentage * moveForce);
}
else
{
m_Rigidbody2D.AddForce(transform.right.normalized * movePercentage * moveForce * 3);
}
}
else if (movePercentage < 0 && horizontalSpeed > -maxMoveSpeed)
{
if (horizontalSpeed < -maxMoveSpeed)
{
Debug.Log("error maximum speed reached: " + horizontalSpeed);
}
if (horizontalSpeed < 0)
{
m_Rigidbody2D.AddForce(transform.right.normalized * movePercentage * moveForce);
}
else
{
m_Rigidbody2D.AddForce(transform.right.normalized * movePercentage * moveForce * 3);
}
}
else //add drag
{
m_Rigidbody2D.AddForce(transform.right.normalized * horizontalSpeed * -1f);
}
//Debug.Log("added force to move the player4");
// If the input is moving the player right and the player is facing left...
if (movePercentage > 0 && !m_FacingRight)
{
Flip();
}
else if (movePercentage < 0 && m_FacingRight)
{
Flip();
}
}
// If the player should jump...
if (m_Grounded && jump)
{
// Add a vertical force to the player.
m_Grounded = false;
float gravitySqrt = Mathf.Sqrt(GravitySystem.instance.gravityForce);
float jumpHeight = Mathf.Sqrt(GravitySystem.instance.jumpHeight);
float jumpForce = m_JumpForce * jumpHeight * gravitySqrt;
m_Rigidbody2D.AddForce(transform.up.normalized * jumpForce);
AudioManager.instance.play("playerJump");
if (PC)
{
if (PC.PCO)
{
PlayerData PD = PC.PCO.GetComponent <PlayerData>();
if (PD)
{
PD.CmdplayerJumped();
}
}
}
}
}
//Input
public void Invoke(AudioSystem.AudioConfig data)
{
loopOutput?.Invoke(data.loop);
pitchOutput?.Invoke(data.pitch);
volumeOutput?.Invoke(data.volume);
}
public void Move(float move, bool crouch, bool jump)
{
// If crouching, check to see if the character can stand up
if (!crouch)
{
// If the character has a ceiling preventing them from standing up, keep them crouching
if (Physics2D.OverlapCircle(m_CeilingCheck.position, k_CeilingRadius, m_WhatIsGround))
{
crouch = true;
}
}
//only control the player if grounded or airControl is turned on
if (m_Grounded || m_AirControl)
{
// If crouching
if (crouch)
{
if (!m_wasCrouching)
{
m_wasCrouching = true;
OnCrouchEvent?.Invoke(true);
}
// Reduce the speed by the crouchSpeed multiplier
move *= m_CrouchSpeed;
// Disable one of the colliders when crouching
if (m_CrouchDisableCollider != null)
{
m_CrouchDisableCollider.enabled = false;
}
}
else
{
// Enable the collider when not crouching
if (m_CrouchDisableCollider != null)
{
m_CrouchDisableCollider.enabled = true;
}
if (m_wasCrouching)
{
m_wasCrouching = false;
OnCrouchEvent?.Invoke(false);
}
}
// Move the character by finding the target velocity
Vector3 targetVelocity = new Vector2(move * 10f, m_Rigidbody2D.velocity.y);
// And then smoothing it out and applying it to the character
m_Rigidbody2D.velocity = Vector3.SmoothDamp(m_Rigidbody2D.velocity, targetVelocity, ref m_Velocity, m_MovementSmoothing);
// If the input is moving the player right and the player is facing left...
if (move > 0 && !m_FacingRight)
{
// ... flip the player.
Flip();
}
// Otherwise if the input is moving the player left and the player is facing right...
else if (move < 0 && m_FacingRight)
{
// ... flip the player.
Flip();
}
}
// If the player should jump...
if (m_Grounded && jump)
{
// Add a vertical force to the player.
m_Grounded = false;
m_Rigidbody2D.AddForce(new Vector2(0f, m_JumpForce));
}
}
private void FixedUpdate() //Движение игрока
{
if (Character.velocity.y < 0f && !Grounded)
{
Animator.SetBool("IsFall", true);
}
HorizontalMove = Input.GetAxisRaw("HorizontalPlayer1") * Speed;
bool WasGrounded = Grounded;
Grounded = false;
Collider2D[] colliders = Physics2D.OverlapCircleAll(GroundCheck.position, GroundRadius, WhatIsGround);
for (int i = 0; i < colliders.Length; i++)
{
if (colliders[i].gameObject != gameObject)
{
Animator.SetBool("IsFall", false);
Grounded = true;
if (!WasGrounded)
{
OnLandEvent.Invoke();
}
}
}
if (!Crouch)
{
if (Physics2D.OverlapCircle(CrouchCheck.position, CrouchRadius, WhatIsGround))
{
Crouch = true;
}
}
if (Crouch)
{
if (!WasCrouching)
{
WasCrouching = true;
OnCrouchEvent.Invoke(true);
}
HorizontalMove *= CrouchSpeed;
if (CrouchDisableCollider != null)
{
BasicCollider.enabled = false;
CrouchDisableCollider.enabled = true;
}
}
else
{
if (CrouchDisableCollider != null)
{
BasicCollider.enabled = true;
CrouchDisableCollider.enabled = false;
}
if (WasCrouching)
{
WasCrouching = false;
OnCrouchEvent.Invoke(false);
}
}
Animator.SetFloat("Speed", Mathf.Abs(HorizontalMove));
if (!Climb)
{
Character.gravityScale = 3f;
TargetVelocity = new Vector2(HorizontalMove * Time.fixedDeltaTime * 10f, Character.velocity.y);
Character.velocity = Vector3.SmoothDamp(Character.velocity, TargetVelocity, ref Velocity, MovementSmoothing);
}
else if (Climb)
{
VerticalMove = Input.GetAxisRaw("Vertical") * Speed * Time.fixedDeltaTime;
Character.gravityScale = 0f;
TargetVelocity = new Vector2(HorizontalMove * Time.fixedDeltaTime * 10f, VerticalMove * 10f);
Character.velocity = Vector3.SmoothDamp(Character.velocity, TargetVelocity, ref Velocity, MovementSmoothing);
}
}
public void Raise()
{
BoolEvent?.Invoke(BoolReference);
}
void OpenLevelDoor()
{
// if (currentProgress.Level == currentLevel) currentProgress.Level++;
onDoorOpened?.Invoke(currentProgress.Level >= SceneManager.sceneCountInBuildSettings);
}
void OnBecameVisible()
{
visibility.Invoke(true);
}
protected override void OnEventRaised()
{
_gameEventBool._condition = !_gameEventBool._condition;
_eventResponse?.Invoke(_gameEventBool._condition);
}
public override void ExecuteServer(ConnectedPlayer subject)
{
ServerMethod?.Invoke(Element.isOn);
ServerMethodWithSubject?.Invoke(Element.isOn, subject);
}
public virtual void OnEventRaised(bool argument)
{
Response?.Invoke(argument);
}
public void Move(float move, bool crouch, float vertical_move)
{
//only control the player if grounded or airControl is turned on
if (m_Grounded || m_AirControl)
{
// If crouching
if (crouch)
{
if (!m_wasCrouching)
{
m_wasCrouching = true;
OnCrouchEvent.Invoke(true);
}
// Reduce the speed by the crouchSpeed multiplier
move *= m_CrouchSpeed;
// Disable one of the colliders when crouching
if (m_CrouchDisableCollider != null)
{
m_CrouchDisableCollider.enabled = false;
}
}
else
{
// Enable the collider when not crouching
if (m_CrouchDisableCollider != null)
{
m_CrouchDisableCollider.enabled = true;
}
if (m_wasCrouching)
{
m_wasCrouching = false;
OnCrouchEvent.Invoke(false);
}
}
// Move the character by finding the target velocity
Vector3 targetVelocity = new Vector2(move * 10f, m_Rigidbody2D.velocity.y);
// And then smoothing it out and applying it to the character
m_Rigidbody2D.velocity = Vector3.SmoothDamp(
m_Rigidbody2D.velocity,
targetVelocity,
ref m_Velocity,
m_MovementSmoothing
);
// If the input is moving the player right and the player is facing left...
if (move > 0 && !m_FacingRight)
{
// ... flip the player.
Flip();
}
// Otherwise if the input is moving the player left and the player is facing right...
else if (move < 0 && m_FacingRight)
{
// ... flip the player.
Flip();
}
}
// If the player should jump...
if (m_Grounded && vertical_move > 0)
{
// Add a vertical force to the player.
m_Grounded = false;
m_Rigidbody2D.AddForce(new Vector2(0f, m_JumpForce));
}
//Stump down while in the air
if (!m_Grounded && vertical_move < 0)
{
m_Rigidbody2D.AddForce(new Vector2(0f, -m_stumpForce));
}
//Faster Fall
if (m_Rigidbody2D.velocity.y < 0)
{
m_Rigidbody2D.velocity += Vector2.up * Physics2D.gravity.y * (m_fallMultiplier - 1) * Time.deltaTime;
}
else if (m_Rigidbody2D.velocity.y > 0)
{
}
}
public void Move(float move, bool crouch, bool jump)
{
if (!crouch)
{
if (Physics2D.OverlapCircle(ceilingPosition.position, ceilingRadius, groundLayers))
{
// the player cannot currently stand up
crouch = true;
}
}
// only control the player if grounded or canAirControl is turned on
if (isGrounded || canAirControl)
{
if (crouch)
{
if (!wasCrouching)
{
// if we weren't crouching before, but now are, generate the crouch event
wasCrouching = true;
OnCrouchEvent.Invoke(true);
}
// move more slowly when crouched
move *= crouchSpeedMultiplier;
// when crouching, disable the upper collider
if (colliderToDisableOnCrouch != null)
{
colliderToDisableOnCrouch.enabled = false;
}
}
else
{
// enable the collider when not crouching
if (colliderToDisableOnCrouch != null)
{
colliderToDisableOnCrouch.enabled = true;
}
if (wasCrouching)
{
// if previously crouching, but are no longer, generate the (un)crouch event
wasCrouching = false;
OnCrouchEvent.Invoke(false);
}
}
// what speed do we want to travel?
Vector3 targetVelocity = new Vector2(move * movementSpeed, GetComponent <Rigidbody2D>().velocity.y);
// apply smoothing to the speed
rigidBody.velocity = Vector3.SmoothDamp(rigidBody.velocity, targetVelocity, ref velocity, movementSmoothing);
// export the speed
speed = rigidBody.velocity.magnitude;
if (move > 0 && !isFacingRight)
{
// flip the sprite horizontally when travelling left
Flip();
}
else if (move < 0 && isFacingRight)
{
// flip the sprite horizontally when travelling left
Flip();
}
}
if (isGrounded && jump)
{
// add a vertical force to the player
isGrounded = false;
rigidBody.AddForce(new Vector2(0f, jumpForce));
}
}
public void Move(Vector2 move, bool crouch, bool jump)
{
Debug.Log(m_Grounded);
// If crouching, check to see if the character can stand up
if (!crouch)
{
// If the character has a ceiling preventing them from standing up, keep them crouching
if (Physics2D.OverlapCircle(m_CeilingCheck.position, k_GroundedRadius, m_WhatIsGround))
{
crouch = true;
}
}
//only control the player if grounded or airControl is turned on
if (m_Grounded || m_AirControl)
{
// If crouching
if (crouch)
{
if (!m_wasCrouching)
{
m_wasCrouching = true;
OnCrouchEvent.Invoke(true);
}
// Reduce the speed by the crouchSpeed multiplier
move *= m_CrouchSpeed;
// Disable one of the colliders when crouching
if (m_CrouchDisableCollider != null)
{
m_CrouchDisableCollider.enabled = false;
}
}
else
{
// Enable the collider when not crouching
if (m_CrouchDisableCollider != null)
{
m_CrouchDisableCollider.enabled = true;
}
if (m_wasCrouching)
{
m_wasCrouching = false;
OnCrouchEvent.Invoke(false);
}
}
// Move the character by finding the target velocity
Vector2 targetVelocity = move;
// And then smoothing it out and applying it to the character
m_Rigidbody.velocity = Vector2.SmoothDamp(m_Rigidbody.velocity, targetVelocity, ref m_Velocity, m_MovementSmoothing);
// If the input is moving the player right and the player is facing left...
if (move.x > 0 && !m_FacingRight)
{
}
// Otherwise if the input is moving the player left and the player is facing right...
else if (move.x < 0 && m_FacingRight)
{
}
}
// If the player should jump, then turn off jump
if (m_Grounded && jump)
{
//m_Animator.SetBool("Jump", true);
Debug.Log("triggered");
m_Rigidbody.velocity += Vector2.up * m_JumpSpeed;
m_Grounded = false;
}
}
public void OnToggleClick()
{
toggleClick?.Invoke(flag);
flag = !flag;
}
public void Move(float move, bool ducka, bool hoppa)
{
// Om spelaren duckar så kollar denna om spelaren kan stå upp
if (!ducka)
{
// Spelaren kommer fortsätta ducka om det finns något ovanför
if (Physics2D.OverlapCircle(CeilingCheck.position, CeilingRadius, WhatIsGround))
{
ducka = true;
}
}
if (Grounded || AirControl)
{
// Om man duckar
if (ducka)
{
if (!wasduckaing)
{
wasduckaing = true;
OnduckaEvent.Invoke(true);
}
// Gör spelaren långsammare när han duckar
move *= duckaSpeed;
// Tar bort den översta collidern när han duckar
if (duckaDisableCollider != null)
{
duckaDisableCollider.enabled = false;
}
}
else
{
// Sätter tillbaks collidern när han slutar duckar.
if (duckaDisableCollider != null)
{
duckaDisableCollider.enabled = true;
}
if (wasduckaing)
{
wasduckaing = false;
OnduckaEvent.Invoke(false);
}
}
// Flyttar spelaren
Vector3 targetVelocity = new Vector2(move * 10f, Rigidbody2D.velocity.y);
// Gör det smoooooth!
Rigidbody2D.velocity = Vector3.SmoothDamp(Rigidbody2D.velocity, targetVelocity, ref Velocity, MovementSmoothing);
// Om spelaren är åt höger men spelaren byter håll, då ska spelaren byta håll
if (move > 0 && !FacingRight)
{
//Byter håll på spelaren
Flip();
}
// Motsatsen till ovan
else if (move < 0 && FacingRight)
{
Flip();
}
}
//Om spelaren kan hoppa
if (Grounded && hoppa)
{
// Lägger en kraft uppåt på spelaren
Grounded = false;
Rigidbody2D.AddForce(new Vector2(0f, hoppaForce));
}
}
private void Start()
{
// Project is closed by default, so raising the Closed events upon Start.
onProjectClosed?.Invoke();
onProjectOpeningChanged?.Invoke(false);
}
public void SetValue(bool v)
{
this.value = v;
OnValueChanged?.Invoke(v);
}
void HandleSwitchToggled(bool on)
{
On = on;
Animator.SetBool(AnimatorStateParameterName, On);
OnToggled?.Invoke(on);
}
public void Move(float dT, float move, bool crouch, int jump)
{
move *= 10 * dT;
// If crouching, check to see if the character can stand up
if (!crouch)
{
// If the character has a ceiling preventing them from standing up, keep them crouching
if (Physics2D.OverlapCircle(m_CeilingCheck.position, k_CeilingRadius, m_WhatIsGround))
{
crouch = true;
}
}
// Only control the player if grounded or airControl is turned on
if (m_Grounded || m_AirControl)
{
// If crouching
if (crouch)
{
if (!m_wasCrouching)
{
m_wasCrouching = true;
OnCrouchEvent.Invoke(true);
}
// Reduce the speed by the crouchSpeed multiplier
move *= m_CrouchSpeed;
// Disable one of the colliders when crouching
if (m_CrouchDisableCollider != null)
{
m_CrouchDisableCollider.enabled = false;
}
}
else
{
// Enable the collider when not crouching
if (m_CrouchDisableCollider != null)
{
m_CrouchDisableCollider.enabled = true;
}
// Got up
if (m_wasCrouching)
{
m_wasCrouching = false;
OnCrouchEvent.Invoke(false);
}
}
// Move the character by finding the target velocity
Vector3 targetVelocity = new Vector2(move, m_Rigidbody2D.velocity.y);
// And then smoothing it out and applying it to the character
m_Rigidbody2D.velocity = Vector3.SmoothDamp(m_Rigidbody2D.velocity, targetVelocity, ref m_Velocity, m_MovementSmoothing);
// Instead of using regular gravity we gradually reduce the vertical velocity
// dynamically, based on user input
if (m_Rigidbody2D.velocity.y < 0)
{
m_Rigidbody2D.velocity += Vector2.up * Physics2D.gravity.y * m_DownGravityMultiplier * dT;
}
else if ((m_Rigidbody2D.velocity.y > 0) && (jump == 0))
{
m_Rigidbody2D.velocity += Vector2.up * Physics2D.gravity.y * m_LowJumpMultiplier * dT;
}
// Take off
if (m_Grounded && (jump == 1))
{
m_Rigidbody2D.velocity = Vector2.up * m_JumpForce;
}
// If the input is moving the player right and the player is facing left
// or vice versa, flip the sprite.
if ((move > 0 && !m_FacingRight) || (move < 0 && m_FacingRight))
{
Flip();
}
}
}
private void Start()
{
currentlyOn = isOn;
onValueChanged?.Invoke(currentlyOn);
}
public void Move(float move, bool crouch, bool jump)
{
// If crouching, check to see if the character can stand up
if (!crouch)
{
// If the character has a ceiling preventing them from standing up, keep them crouching
if (Physics2D.OverlapCircle(m_CeilingCheck.position, k_CeilingRadius, m_WhatIsGround))
{
crouch = true;
}
}
//only control the player if grounded or airControl is turned on
if (m_Grounded || m_AirControl)
{
// If crouching
if (crouch)
{
if (!m_wasCrouching)
{
m_wasCrouching = true;
OnCrouchEvent.Invoke(true);
}
// Reduce the speed by the crouchSpeed multiplier
move *= m_CrouchSpeed;
// Disable one of the colliders when crouching
if (m_CrouchDisableCollider != null)
{
m_CrouchDisableCollider.enabled = false;
}
}
else
{
// Enable the collider when not crouching
if (m_CrouchDisableCollider != null)
{
m_CrouchDisableCollider.enabled = true;
}
if (m_wasCrouching)
{
m_wasCrouching = false;
OnCrouchEvent.Invoke(false);
}
}
// Move the character by finding the target velocity
Vector3 targetVelocity = new Vector2(move * 10f, m_Rigidbody2D.velocity.y);
// And then smoothing it out and applying it to the character
m_Rigidbody2D.velocity = Vector3.SmoothDamp(m_Rigidbody2D.velocity, targetVelocity, ref m_Velocity, m_MovementSmoothing);
}
// If the player should jump...
if (jumps > 0 && jump)
{
// Add a vertical force to the player.
jumps--;
jumpParticle.Play();
OnJumpEvent.Invoke();
sfx.PlaySound(transform.position, SoundType.Jump);
controller.setJumps(jumps);
m_Rigidbody2D.velocity *= Vector2.right;
m_Rigidbody2D.AddForce(new Vector2(0f, m_JumpForce));
}
}
