Walk, Run, Idle Animations and Flip Direction - 2D Platformer Crash Course in Unity 2022 (Part 8)

Summary

This video script outlines how to implement player movement and animation logic in Unity, including walk, run, and idle states. The player’s speed adjusts based on movement (idle, walking, or running), and the facing direction of the player sprite is dynamically flipped depending on movement input. The script employs a method to adjust the player’s local scale for flipping, ensuring that any child game objects like hitboxes stay properly oriented. Additionally, the video explores how to set up animations within Unity's Animator system to reflect these actions, with a focus on smooth transitions and correct handling of character direction.

Takeaways

• 😀 The movement speed of the character is dynamically determined by whether the character is idle, walking, or running.
• 😀 A getter function is used to calculate the correct movement speed based on the character's current state (walking, running, or idle).
• 😀 The character's velocity is updated in the script by assigning the correct movement speed to the X component, depending on the current movement state.
• 😀 The script checks for movement input and adjusts the character's facing direction (left or right) based on the input values (positive or negative).
• 😀 A helper function, `setFacingDirection`, is used to adjust the character’s facing direction based on movement input.
• 😀 To prevent unnecessary flipping, the character’s facing direction is only updated when the new movement direction differs from the current direction.
• 😀 Flipping the character's scale (rather than the sprite) ensures that child game objects, such as a hitbox, automatically flip along with the character.
• 😀 The `isFacingRight` boolean property is used to track the character's current facing direction, and the scale is flipped if the direction changes.
• 😀 Flipping the local scale (X-axis) on the parent object ensures that all child components, including any attached hitboxes or other game objects, follow the direction change.
• 😀 The script includes an animator setup to handle different animation states (idle, walk, run) based on the current movement speed and input.
• 😀 Flipping the local scale provides a cleaner solution for directional adjustments, particularly when child objects must also adapt to the character’s orientation.

Q & A

Why does the script use a getter function instead of directly accessing variables for movement speed?

The getter function is used to calculate the movement speed dynamically based on conditions such as whether the player is walking, running, or idling. This allows for more flexible and maintainable code since the speed is not hardcoded, and it can easily be adjusted by simply changing conditions or adding new states in the future.

What is the purpose of the 'isMoving' and 'isRunning' conditions in the script?

The 'isMoving' condition checks if there is any player input for movement, while the 'isRunning' condition checks if the player is holding the shift key to run. These conditions help to determine whether the character should walk, run, or be idle by modifying the speed accordingly.

What does the script return when neither 'isRunning' nor 'isMoving' is true?

When neither 'isRunning' nor 'isMoving' is true, the script returns a speed of 0, which represents the player's idle state. This ensures that the character does not move when no input is provided.

How does the script determine the direction the player should face based on movement input?

The direction is determined by the player's horizontal input (moveInput.x). If the input is positive, the player faces right, and if the input is negative, the player faces left. This is achieved through the `SetFacingDirection` function.

Why does the script check if the player is already facing the correct direction before flipping the scale?

The script checks whether the player is already facing the correct direction to avoid unnecessary flipping of the player's scale. This optimization prevents redundant operations and ensures smoother transitions between directions.

What is the role of the 'isFacingRight' boolean in the script?

The 'isFacingRight' boolean tracks whether the player is facing right or left. It is used to determine when to flip the player's scale and ensure that the character's direction matches the input. If the direction is changed, the 'isFacingRight' boolean is updated accordingly.

Why is the local scale of the player object flipped instead of just flipping the Sprite renderer?

Flipping the local scale instead of just the Sprite renderer ensures that not only the sprite but also all child components (such as hitboxes or weapons) are flipped in the correct direction. This approach makes it easier to handle directional-based child components because they inherit the direction from the parent object’s scale.

What happens if you flip only the Sprite renderer instead of the local scale?

If you flip only the Sprite renderer, child objects like hitboxes or weapons will not flip with the character. This can cause issues where the character's visual direction does not match the functionality of its child components, leading to misaligned interactions in the game.

How does the script handle the player's scale when switching between left and right directions?

The script handles direction switching by flipping the player's local scale on the X-axis. This is done by multiplying the current scale by a Vector2 where the X value is reversed (1 becomes -1 or vice versa), while the Y-axis scale remains unchanged. This flipping affects both the sprite and any child components attached to the player.

Why is the 'isFacingRight' boolean initialized as 'true' by default?

The 'isFacingRight' boolean is initialized as 'true' because, by default, the player faces right at the start of the game. This ensures that the player starts facing the right direction, and the first movement input will correctly flip the player’s direction if necessary.