public static LedgeInfo DetectLedgeOnWall(Direction.Horizontal _direction, Direction.Vertical _verticalDirection, BoxCollider2D _collider, float velocityToCheck, float offset = 0.25f)
{
RaycastHit2D raycastHits = new RaycastHit2D();
int collisionLayerMask = 1 << LayerMask.NameToLayer("Terrain");
float rayLength = _collider.size.y + Mathf.Abs(velocityToCheck) + offset;
Vector2 rayDirection = (_verticalDirection == Direction.Vertical.Up) ? Vector2.up : Vector2.down;
bool isConnected = false;
Vector2 rayOrigin = new Vector2(_collider.transform.position.x + (_collider.size.x * 0.5f) * (int)_direction, _collider.transform.position.y - (_collider.size.y * 0.5f * (int)_verticalDirection));
rayOrigin.y = (rayDirection == Vector2.up) ? _collider.bounds.min.y - offset : _collider.bounds.max.y + offset;
float raycastSpacing = _collider.size.x * 0.5f;
rayOrigin.x = (_direction == Direction.Horizontal.Left) ? rayOrigin.x - raycastSpacing : rayOrigin.x + raycastSpacing;
raycastHits = Physics2D.Raycast(rayOrigin, rayDirection, rayLength, collisionLayerMask);
if (raycastHits.fraction > 0)
{
isConnected = true;
}
#if UNITY_EDITOR
//Debug.DrawRay(rayOrigin, new Vector2(0.25f * (int)_direction, (int)rayDirection.y * rayLength), Color.red);
#endif
float hitY = (isConnected) ? raycastHits.point.y : 0.0f;
LedgeInfo ledgeInfo = new LedgeInfo();
ledgeInfo.didHit = isConnected;
ledgeInfo.hitY = hitY;
return(ledgeInfo);
}
public override void OnBegin()
{
currentJumpFrame = 0;
isJumpActive = true;
hasReleasedButtonSinceJump = false;
controller.slots.physicsObject.properties.isFalling = false;
isGroundedWithJumpButtonUp = false;
if(controller.slots.actor.currentAttack != null && controller.slots.actor.currentAttack.canceledBy.onJump)
{
controller.slots.actor.currentAttack.Cancel();
}
if(freezeHorizontalMovement)
{
direction = (Direction.Horizontal)controller.slots.input.horizontalAxis;
}
/*float velocity = speed;
controller.slots.physicsObject.AddVelocityForSingleFrame(new Vector2(0.0f, velocity * controller.GravityScaleMultiplier()));*/
StartCoroutine("JumpCoroutine");
controller.slots.actor.NotifyOfControllerJumping(currentJump);
}
public static bool IsNextToLedge(Direction.Horizontal _direction, Direction.Vertical _verticalDirection, BoxCollider2D _collider, float gravityScaleMultiplier = 1.0f)
{
RaycastHit2D raycastHits = new RaycastHit2D();
int collisionLayerMask = 1 << LayerMask.NameToLayer("Terrain") | 1 << LayerMask.NameToLayer("PassThroughBottom");
float rayLength = _collider.size.y * 0.5f + 0.1f;
Vector2 rayDirection = (_verticalDirection == Direction.Vertical.Up) ? Vector2.up : Vector2.down;
bool isConnected = false;
Vector2 rayOrigin = new Vector2(_collider.transform.position.x, _collider.transform.position.y + (_collider.offset.y * gravityScaleMultiplier));
float raycastSpacing = _collider.size.x * 0.5f;
rayOrigin.x = (_direction == Direction.Horizontal.Left) ? rayOrigin.x - raycastSpacing : rayOrigin.x + raycastSpacing;
raycastHits = Physics2D.Raycast(rayOrigin, rayDirection, rayLength, collisionLayerMask);
if (raycastHits.fraction > 0)
{
isConnected = true;
}
#if UNITY_EDITOR
//Debug.DrawRay(rayOrigin, new Vector2(0.0f, (int)_verticalDirection) * rayLength, Color.red);
#endif
return(!isConnected);
}
protected void MoveHorizontal()
{
bool willTurn = false;
if ((physicsObject.DidHitEitherWallThisFrame() && willTurnOnWallContact))
{
willTurn = true;
}
else if (willTurnOnDistance && ((transform.position.x >= maxMovePositionVector.x && directionX == Direction.Horizontal.Right) || (transform.position.x <= minMovePositionVector.x && directionX == Direction.Horizontal.Left)))
{
willTurn = true;
float snappingPosition;
if (transform.position.x >= maxMovePositionVector.x && directionX == Direction.Horizontal.Right)
{
snappingPosition = maxMovePositionVector.x;
}
else
{
snappingPosition = minMovePositionVector.x;
}
physicsObject.previousFrameProperties.position = new Vector3(snappingPosition, transform.position.y, transform.position.z);
physicsObject.properties.position = new Vector3(snappingPosition, transform.position.y, transform.position.z);
}
if (willTurn)
{
directionX = (directionX == Direction.Horizontal.Left) ? Direction.Horizontal.Right : Direction.Horizontal.Left;
}
physicsObject.SetVelocityX(moveSpeed.x * (int)directionX);
}
//If a projectile is slotted, this spawns it
public void CreateProjectile()
{
Direction.Horizontal direction = (slots.actor.slots.controller) ? slots.actor.slots.controller.direction.horizontal : Direction.Horizontal.Right;
if (attackDirection == AttackDirection.Behind)
{
direction = (Direction.Horizontal)((int)direction * -1.0f);
}
Projectile newProjectile = projectile.rexPool.Spawn().GetComponent <Projectile>();
Direction.Horizontal startingHorizontalDirection = direction;
Direction.Vertical startingVerticalDirection = Direction.Vertical.Up;
if (projectile.isAimable)
{
if (Mathf.Abs(slots.actor.slots.input.verticalAxis) == 1.0f && slots.actor.slots.input.horizontalAxis == 0.0f)
{
startingHorizontalDirection = Direction.Horizontal.Neutral;
}
startingVerticalDirection = (Direction.Vertical)(slots.actor.slots.input.verticalAxis * PhysicsManager.Instance.gravityScale);
}
newProjectile.isAimable = projectile.isAimable;
newProjectile.Fire(new Vector2(slots.actor.transform.position.x + transform.localPosition.x * (int)direction, transform.position.y), startingHorizontalDirection, startingVerticalDirection, slots.actor, projectile.rexPool);
}
public void NotifyOfWallJump(int framesToFreeze, Direction.Horizontal kickbackDirection)
{
direction = kickbackDirection;
framesFrozenForWallJump = framesToFreeze;
ForceBegin();
currentJump = 0;
isWallJumpKickbackActive = true;
}
void Start()
{
directionX = startingDirectionX;
directionY = startingDirectionY;
if (!willStartWhenPlayerIsOnTop && isMovementEnabled)
{
StartMoving();
}
}
public void Knockback(Direction.Horizontal _direction) //Called directly to apply knockback if a KnockbackState component is attached
{
KnockbackState knockback = GetComponent <KnockbackState>();
if (knockback)
{
knockback.knockbackDirection = _direction;
knockback.Begin();
}
}
//Immediately snaps this object to the nearest wall
public void SnapToNearestWall(Direction.Horizontal _direction)
{
properties.isAgainstLeftWall = false;
properties.isAgainstRightWall = false;
float buffer = 0.25f;
Vector2 startPoint = new Vector2(box.center.x, box.yMin - buffer);
Vector2 endPoint = new Vector2(box.center.x, box.yMax + buffer);
RaycastHit2D[] raycastHits = new RaycastHit2D[raycastAmounts.horizontal];
int numberOfCollisions = 0;
float fraction = 0;
float rayVelocity = (_direction == Direction.Horizontal.Left) ? -1.0f : 1.0f;
float sideRayLength = box.width / 2 + Mathf.Abs(rayVelocity * PhysicsManager.Instance.fixedDeltaTime);
Vector2 direction = rayVelocity > 0 ? Vector3.right : -Vector3.right;
bool didCollide = false;
for (int i = 0; i < raycastAmounts.horizontal; i++)
{
float raycastSpacing = (float)i / (float)(raycastAmounts.horizontal - 1);
Vector2 rayOrigin = Vector2.Lerp(startPoint, endPoint, raycastSpacing);
raycastHits[i] = Physics2D.Raycast(rayOrigin, direction, sideRayLength, collisionLayerMask);
if (raycastHits[i].fraction > 0)
{
didCollide = true;
if (fraction > 0)
{
float slopeAngle = Vector2.Angle(raycastHits[i].point - raycastHits[i - 1].point, Vector2.right);
if (Mathf.Abs(slopeAngle - 90) < slopeAngleBuffer)
{
if (direction == Vector2.right)
{
properties.isAgainstRightWall = true;
}
else
{
properties.isAgainstLeftWall = true;
}
properties.position += (direction * (raycastHits[i].fraction * sideRayLength - box.width / 2.0f));
properties.velocity = new Vector2(0.0f, properties.velocity.y);
break;
}
}
numberOfCollisions++;
fraction = raycastHits[i].fraction;
}
}
}
public void FaceDirection(Direction.Horizontal _direction) //Called when the Controller is moved left or right, and thus might change direction; calls Turn() if we did change
{
//We changed directions
if (_direction != direction.horizontal)
{
if (CanChangeDirection())
{
Turn();
}
}
}
protected void SetHorizontalDirection(Direction.Horizontal _direction)
{
direction.horizontal = _direction;
if (direction.horizontal == Direction.Horizontal.Left)
{
transform.localScale = new Vector3(-1.0f, 1.0f, 1.0f);
}
else if (direction.horizontal == Direction.Horizontal.Right)
{
transform.localScale = new Vector3(1.0f, 1.0f, 1.0f);
}
}
//Checks in a direction to see if we hit a wall
private bool CheckForWallContact(Direction.Horizontal _direction, bool willDetectWithMargin = false)
{
Vector2 startPoint = new Vector2(box.center.x, box.yMin);
Vector2 endPoint = new Vector2(box.center.x, box.yMax);
RaycastHit2D[] raycastHits = new RaycastHit2D[raycastAmounts.horizontal];
int numberOfCollisions = 0;
float fraction = 0;
float margin = (willDetectWithMargin) ? 0.25f : 0.001f;
float sideRayLength = box.width / 2 + margin;
Vector2 direction = new Vector2((int)_direction, 0.0f);
bool didCollide = false;
for (int i = 0; i < raycastAmounts.horizontal; i++)
{
float raycastSpacing = (float)i / (float)(raycastAmounts.horizontal - 1);
Vector2 rayOrigin = Vector2.Lerp(startPoint, endPoint, raycastSpacing);
raycastHits[i] = Physics2D.Raycast(rayOrigin, direction, sideRayLength, collisionLayerMask);
if (raycastHits[i].fraction > 0)
{
didCollide = true;
if (fraction > 0)
{
float slopeAngle = Vector2.Angle(raycastHits[i].point - raycastHits[i - 1].point, Vector2.right);
if (Mathf.Abs(slopeAngle - 90) < slopeAngleBuffer) //If the slope is too steep, treat it as a wall
{
if (direction == Vector2.right)
{
properties.isAgainstRightWall = true;
}
else
{
properties.isAgainstLeftWall = true;
}
return(true);
}
}
numberOfCollisions++;
fraction = raycastHits[i].fraction;
}
}
return(false);
}
public virtual void Turn() //The visual component of a Turn; scales the X axis to positive or negative, and plays our slotted Turn AnimationClip
{
Direction.Horizontal _direction = (direction.horizontal == Direction.Horizontal.Left) ? Direction.Horizontal.Right : Direction.Horizontal.Left;
float scaleMultiplier = (_direction == Direction.Horizontal.Left) ? -1.0f : 1.0f;
slots.actor.transform.localScale = new Vector3(scaleMultiplier, slots.actor.transform.localScale.y, slots.actor.transform.localScale.z);
direction.horizontal = _direction;
if (slots.actor.currentAttack != null && slots.actor.currentAttack.canceledBy.onTurn)
{
slots.actor.currentAttack.Cancel();
}
StopCoroutine("TurnCoroutine");
StartCoroutine("TurnCoroutine");
}
public void Fire(Vector2 _startingPosition, Direction.Horizontal _horizontal, Direction.Vertical _vertical, RexActor _spawningActor, RexPool _parentSpawnPool = null)
{
if (!willDestroyWhenSceneChanges)
{
DontDestroyOnLoad(gameObject);
}
isFiring = true;
isBeingReflected = false;
movementSpeed = originalMovementSpeed;
spawningActor = _spawningActor;
if (sounds.fireSound)
{
GetComponent <AudioSource>().PlayOneShot(sounds.fireSound);
}
if (_parentSpawnPool != null)
{
parentSpawnPool = _parentSpawnPool;
}
SetPosition(_startingPosition);
SetHorizontalDirection(_horizontal);
SetVerticalDirection((Direction.Vertical)((int)startingVerticalDirection * (int)_vertical * PhysicsManager.Instance.gravityScale));
firingDirection = _horizontal;
slots.physicsObject.properties.acceleration = Vector2.zero;
float startingXSpeed = (acceleration == 0.0f) ? movementSpeed.x * (int)direction.horizontal : 0.0f;
slots.physicsObject.SetVelocityX(startingXSpeed);
slots.physicsObject.SetAccelerationCapX(movementSpeed.x * (int)direction.horizontal);
float startingYSpeed = (acceleration == 0.0f) ? movementSpeed.y * (int)direction.vertical : 0.0f;
slots.physicsObject.SetVelocityY(startingYSpeed);
slots.physicsObject.SetAccelerationCapY(movementSpeed.y * (int)direction.vertical);
}
public void MoveTo(Vector2 position, bool setFacingDirection = true, bool ignorePhysics = false)
{
if (Math.Abs(X - position.X) > 0.01 && setFacingDirection)
{
var horizontalDifference = position.X - X;
if (Math.Abs(horizontalDifference) > .1)
{
FacingDirection = horizontalDifference < 0 ? Direction.Horizontal.Left : Direction.Horizontal.Right;
}
}
Position = position;
if (physicsComponent == null || ignorePhysics)
{
Position = position;
}
else
{
physicsComponent.MoveTo(position);
}
}
protected void ContinueDash(float _inputDirection)
{
if ((controller.slots.input && controller.slots.input.isDashButtonDown) || controller.isDashing)
{
if (controller.isDashing) //Continue dash
{
//Debug.Log("Dash continue");
currentFrame++;
bool willCancelDash = false;
Direction.Horizontal actorDirection = (_inputDirection > 0.0f) ? Direction.Horizontal.Right : Direction.Horizontal.Left;
bool didChangeDirection = (actorDirection != controller.direction.horizontal && _inputDirection != 0.0f) ? true : false;
if (currentFrame >= minFrames && ((controller.slots.input && !controller.slots.input.isDashButtonDown) || !controller.slots.input))
{
willCancelDash = true;
}
if (controller.slots.actor.currentAttack != null && controller.slots.actor.currentAttack.cancels.dash)
{
willCancelDash = true;
}
if (currentFrame >= maxFrames)
{
willCancelDash = true;
}
if (canChangeDirection && _inputDirection != 0.0f)
{
if (didChangeDirection)
{
controller.FaceDirection(actorDirection);
if (isCanceledByDirectionChange)
{
willCancelDash = true;
}
}
}
if (isMomentumRetainedOnJump && !controller.slots.physicsObject.IsOnSurface())
{
if (requireDirectionalHoldToRetainMomentumOnJump && _inputDirection == 0.0f)
{
willCancelDash = true;
}
else if (didChangeDirection && isCanceledByDirectionChange)
{
willCancelDash = true;
}
else if (!didCurrentDashStartInAir)
{
willCancelDash = false;
}
}
if (willStopDashUponLanding && controller.slots.physicsObject.DidLandThisFrame())
{
willCancelDash = true;
}
if (controller.slots.actor.currentAttack != null && controller.slots.actor.currentAttack.cancels.dash)
{
willCancelDash = true;
}
if (isCanceledByWallContact && controller.slots.physicsObject.IsAgainstEitherWall())
{
willCancelDash = true;
}
if (willCancelDash) //Dash is canceled
{
if (!hasEnded && controller.StateID() == id)
{
controller.SetStateToDefault();
}
End();
controller.isDashing = false;
controller.slots.physicsObject.SetVelocityX(0);
}
else //Dash continues
{
controller.slots.physicsObject.SetVelocityX(speed * (int)controller.direction.horizontal);
controller.slots.physicsObject.SetAccelerationCapX(speed * (int)controller.direction.horizontal);
if (freezeVerticalMovementOnAirDash)
{
if (controller.isDashing && didCurrentDashStartInAir && !controller.slots.physicsObject.IsOnSurface() && controller.StateID() == idString)
{
controller.slots.physicsObject.FreezeYMovementForSingleFrame();
}
}
}
}
}
else
{
hasReleasedButtonSinceDash = true;
}
if (currentAirDash != 0 && controller.slots.physicsObject.IsOnSurface())
{
currentAirDash = 0;
}
}
public void Run(Direction.Horizontal direction)
{
animatedSprite.Change("Running");
Transform.MoveAndSlide(new Vector2(
direction == Direction.Horizontal.Left ? -speed : speed, 0));
}
//If an HP Energy component is attached, this lowers its value by the amount damaged. Also does processing to ensure the player CAN be damaged first (i.e. that it isn't currently invincible) and determines if knockback should be applied.
public int Damage(int amount, bool willCauseKnockback = true, BattleEnums.DamageType damageType = BattleEnums.DamageType.Regular, Collider2D col = null)
{
int damageTaken = 0;
if (!WillProcessDamageFromObject(col) || DetermineIfInvincible() || isDead)
{
return(0);
}
if (hp != null)
{
hp.Decrement(amount);
damageTaken = hp.previous - hp.current;
}
if (damagedProperties.willShowDamagedNumber)
{
float yPosition = (slots.collider != null) ? slots.collider.bounds.max.y : transform.position.y;
DamageNumberManager.Instance.ShowNumber(amount, new Vector2(transform.position.x, yPosition));
}
Direction.Horizontal knockbackDirection = Direction.Horizontal.Right;
if (damageType != BattleEnums.DamageType.Poison)
{
if (damagedProperties.willFlash)
{
Flash();
}
}
if (hp == null)
{
return(0);
}
if (hp.current <= 0)
{
SetDeathParameters();
}
else
{
if (damageType != BattleEnums.DamageType.Poison)
{
if (damagedProperties.willShakeScreen)
{
ScreenShake.Instance.Shake();
}
if (willCauseKnockback)
{
if (col != null)
{
knockbackDirection = (col.transform.position.x < transform.position.x) ? Direction.Horizontal.Right : Direction.Horizontal.Left;
}
else
{
knockbackDirection = (slots.controller && slots.controller.direction.horizontal == Direction.Horizontal.Left) ? Direction.Horizontal.Right : Direction.Horizontal.Left;
}
if (currentAttack != null)
{
if (currentAttack.canceledBy.onKnockback)
{
currentAttack.Cancel();
}
else
{
willCauseKnockback = false;
}
}
}
bool didChangeController = false;
if (damagedProperties.damagedControllers.damagedController && hp.current <= damagedProperties.damagedControllers.hpThreshold)
{
SetController(damagedProperties.damagedControllers.damagedController);
didChangeController = true;
}
StartDamageInvincibility();
if (!(currentAttack != null && !currentAttack.canceledBy.onKnockback) && willCauseKnockback)
{
if (slots.controller && !didChangeController)
{
slots.controller.Knockback(knockbackDirection);
}
}
}
}
if (col != null && damageType != BattleEnums.DamageType.Poison)
{
HitSparkManager.Instance.CreateHitSpark(GetComponent <BoxCollider2D>(), col.GetComponent <BoxCollider2D>(), (damageTaken > 0), hp.current);
OnHit(damageTaken, col);
if (col.GetComponent <RexActor>() != null)
{
//col.GetComponent<RexActor>().StartContactDelay();
}
if (GetComponent <Jitter>())
{
GetComponent <Jitter>().Play();
}
}
return(damageTaken);
}
protected void CheckForWallCling()
{
if(controller.StateID() == KnockbackState.idString || controller.isStunned)
{
isClingingToWall = false;
return;
}
if(controller.slots.physicsObject.properties.isAgainstRightWall)
{
mostRecentWallJumpDirection = Direction.Horizontal.Left;
}
else if(controller.slots.physicsObject.properties.isAgainstLeftWall)
{
mostRecentWallJumpDirection = Direction.Horizontal.Right;
}
isClingingToWall = false;
if(!controller.slots.physicsObject.IsOnSurface())
{
if(IsPressingIntoWall() && IsClingAllowed() && !(controller.StateID() == JumpState.idString && !enableClingWhileJumping))
{
isClingingToWall = true;
currentWallJumpGraceFrame = wallJump.wallJumpGraceFrames;
}
}
if(controller.slots.input.isJumpButtonDownThisFrame)
{
bool canJump = false;
if((((controller.slots.physicsObject.properties.isAgainstRightWall || controller.slots.physicsObject.properties.isAgainstLeftWall)) || currentWallJumpGraceFrame > 0) && wallJump.enableWallJump && (!IsJumpActive() || enableClingWhileJumping) && !controller.slots.physicsObject.IsOnSurface() && substate != Substate.LedgeHanging && IsCooldownComplete())
{
canJump = true;
}
else if(substate == Substate.LedgeHanging && ledgeGrab.canLedgeJump && !controller.slots.physicsObject.IsOnSurface())
{
canJump = true;
}
if(canJump)
{
if(jumpState == null)
{
jumpState = controller.GetComponent<JumpState>();
}
if(jumpState)
{
jumpState.NotifyOfWallJump(wallJump.wallJumpKickbackFrames, mostRecentWallJumpDirection);
isClingingToWall = false;
}
}
else if(!(wallJump.enableWallJump && substate != Substate.LedgeHanging) || (substate == Substate.LedgeHanging && !ledgeGrab.canLedgeJump) && (wallClimb.enableClimbing || substate == Substate.LedgeHanging))
{
currentCooldownFrame = cooldownFrames;
isClingingToWall = false;
if(substate != Substate.None)
{
isDropping = true;
}
controller.SetStateToDefault();
}
}
if(canDisengageWithDirectionalPress && ((controller.slots.physicsObject.properties.isAgainstRightWall && controller.axis.x == -1.0f) || (controller.slots.physicsObject.properties.isAgainstLeftWall && controller.axis.x == 1.0f)))
{
isClingingToWall = false;
controller.SetStateToDefault();
}
if(isClingingToWall)
{
isDropping = false;
}
}
protected void ApplyMovement(float _inputDirection, MovementAxis movementAxis)
{
bool isLockedForAttack = (controller.slots.physicsObject.IsOnSurface()) ? IsLockedForAttack(Attack.ActionType.GroundMoving) : IsLockedForAttack(Attack.ActionType.AirMoving);
bool isOverriddenByDash = controller.isDashing;
bool isRunning = false;
if (runSettings.canRun && controller.slots.input && controller.slots.input.isRunButtonDown)
{
if ((controller.slots.physicsObject.IsOnSurface() || runSettings.canInitiateInAir) || currentMoveType == MoveType.Running)
{
isRunning = true;
isSlowingDownFromRun = false;
if (runSettings.runAnimation && currentMoveType != MoveType.Running && Mathf.Abs(_inputDirection) != 0.0f && controller.slots.physicsObject.IsOnSurface() && controller.StateID() == idString)
{
PlaySecondaryAnimation(runSettings.runAnimation);
}
currentMoveType = MoveType.Running;
}
else
{
if (currentMoveType == MoveType.Running && Mathf.Abs(controller.slots.physicsObject.properties.velocity.x) > movementProperties.speed)
{
isSlowingDownFromRun = true;
PlayAnimation();
}
currentMoveType = MoveType.Walking;
}
}
else
{
if (currentMoveType == MoveType.Running && Mathf.Abs(controller.slots.physicsObject.properties.velocity.x) > movementProperties.speed)
{
isSlowingDownFromRun = true;
PlayAnimation();
}
currentMoveType = MoveType.Walking;
}
if (Mathf.Abs(controller.slots.physicsObject.properties.velocity.x) <= movementProperties.speed)
{
isSlowingDownFromRun = false;
}
if (isOverriddenByDash || controller.isKnockbackActive || controller.isStunned || controller.StateID() == WallClingState.idString)
{
return;
}
bool isLockedIntoJump = (jumpState && !controller.slots.physicsObject.IsOnSurface() && jumpState.IsHorizontalMovementFrozen());
if (isLockedIntoJump)
{
ApplyHorizontalJump(jumpState);
return;
}
if (movementProperties == null)
{
return;
}
float baseSpeed = (isRunning) ? runProperties.speed : movementProperties.speed;
float baseAcceleration = (isRunning) ? runProperties.acceleration : movementProperties.acceleration;
float baseDeceleration = (isRunning || isSlowingDownFromRun) ? runProperties.deceleration : movementProperties.deceleration;
//If we're moving diagonally and willMaintainSpeedOnDiagonal is true, cut our speed in each direction in half to compensate
float diagonalMultiplier = 0.707f; //Moving in two directions at once is 1.4x faster than just one; therefore, we multiply speed in each direction by 0.707
bool isMovingDiagonally = (canMoveVertically && willMaintainSpeedOnDiagonal && Mathf.Abs(controller.axis.x) > 0.0f && Mathf.Abs(controller.axis.y) > 0.0f);
float speed = (isMovingDiagonally) ? baseSpeed * diagonalMultiplier : baseSpeed;
float acceleration = (isMovingDiagonally) ? baseAcceleration * diagonalMultiplier : baseAcceleration;
float deceleration = baseDeceleration;
if (controller.currentState.id == CrouchState.idString)
{
CrouchState crouchState = controller.GetComponent <CrouchState>();
if (crouchState)
{
if (crouchState.isSkidComplete && !crouchState.allowAccelerationOnMove)
{
acceleration = 0.0f;
deceleration = 0.0f;
}
if (crouchState.isSkidComplete)
{
speed = crouchState.moveSpeed;
}
}
}
if (_inputDirection != 0.0f && !controller.isKnockbackActive && !isLockedForAttack && !controller.IsOveriddenByCrouch() && !isSlowingDownFromRun)
{
if (movementAxis == MovementAxis.Horizontal) //Let the controller know that we turned around horizontally
{
Direction.Horizontal actorDirection = controller.direction.horizontal;
actorDirection = (_inputDirection > 0.0f) ? Direction.Horizontal.Right : Direction.Horizontal.Left;
controller.FaceDirection(actorDirection);
}
hasEnded = false; //We animate the sprite moving, but only if it's moving horizontally
if (CanPlayAnimation(movementAxis))
{
Begin();
}
if (controller.slots.actor.currentAttack != null && controller.slots.actor.currentAttack.canceledBy.onMove)
{
controller.slots.actor.currentAttack.Cancel();
}
if (acceleration != 0.0f) //Accelerate to the top speed
{
if (movementAxis == MovementAxis.Horizontal)
{
controller.slots.physicsObject.properties.velocityCap.x = speed * _inputDirection;
controller.slots.physicsObject.properties.acceleration.x = acceleration * _inputDirection;
controller.slots.physicsObject.properties.deceleration.x = 0;
}
else
{
controller.slots.physicsObject.properties.velocityCap.y = speed * _inputDirection;
controller.slots.physicsObject.properties.acceleration.y = acceleration * _inputDirection;
controller.slots.physicsObject.properties.deceleration.y = 0;
}
}
else //Immediately go at top speed
{
if (movementAxis == MovementAxis.Horizontal)
{
controller.slots.physicsObject.properties.velocityCap.x = speed * _inputDirection;
controller.slots.physicsObject.SetVelocityX(speed * _inputDirection);
controller.slots.physicsObject.properties.acceleration.x = 0.0f;
controller.slots.physicsObject.properties.deceleration.x = 0.0f;
}
else
{
controller.slots.physicsObject.properties.velocityCap.y = speed * _inputDirection;
controller.slots.physicsObject.SetVelocityY(speed * _inputDirection);
controller.slots.physicsObject.properties.acceleration.y = 0.0f;
controller.slots.physicsObject.properties.deceleration.y = 0.0f;
}
}
}
else //We can't move directly, but we can apply residual deceleration
{
if (deceleration != 0.0f) //Decelerate gradually to a stop
{
if (movementAxis == MovementAxis.Horizontal)
{
controller.slots.physicsObject.properties.acceleration.x = 0.0f;
controller.slots.physicsObject.properties.deceleration.x = deceleration;
if (Mathf.Abs(controller.slots.physicsObject.properties.velocity.x) <= 0.0f && (controller.slots.physicsObject.IsOnSurface() || canMoveVertically))
{
if (!hasEnded)
{
if (!controller.isKnockbackActive && controller.StateID() != LadderState.idString)
{
controller.SetStateToDefault();
}
}
End();
}
}
else
{
controller.slots.physicsObject.properties.acceleration.y = 0.0f;
controller.slots.physicsObject.properties.deceleration.y = deceleration;
}
}
else //Stop immediately
{
if (movementAxis == MovementAxis.Horizontal)
{
controller.slots.physicsObject.properties.acceleration.x = 0.0f;
controller.slots.physicsObject.properties.deceleration.x = 0.0f;
controller.slots.physicsObject.SetVelocityX(0.0f);
if (!hasEnded)
{
if (!controller.isKnockbackActive && controller.StateID() != LadderState.idString && (controller.slots.physicsObject.IsOnSurface() || canMoveVertically) && controller.StateID() != CrouchState.idString)
{
//Default if:
//You are on the ground, AND !canMoveVertically
//Or, you are in the air
controller.SetStateToDefault();
}
}
//Debug.Log("Ending");
End();
}
else
{
controller.slots.physicsObject.properties.acceleration.y = 0.0f;
controller.slots.physicsObject.properties.deceleration.y = 0.0f;
controller.slots.physicsObject.SetVelocityY(0.0f);
}
}
}
}
