Movement and Motion Systems

# CHAPTER 3

Movement and Motion Systems #

1. Introduction #

2. Learning Objectives #

• Implement basic linear motion (Kinematics) in code.

• Combine Input Axes to generate a movement vector.

• Prevent diagonal speed exploits using Vector Normalization.

• Understand the critical role of DeltaTime in frame-rate independent motion.

• Program smooth, interpolated movement transitions.

3. Linear Movement (Kinematics) #

• The formula is always: Position = Position + (Direction * Speed * Time)

4. Constructing the Movement Vector #

• Input X (A/D keys) gives a value between -1 and 1.

• Input Z (W/S keys) gives a value between -1 and 1.

float x = Input.GetAxisRaw("Horizontal");
float z = Input.GetAxisRaw("Vertical");

// The Y axis is 0 because we are sliding along the floor, not flying!
Vector3 moveDirection = new Vector3(x, 0, z);

5. The Diagonal Exploit (Normalization) #

• The Bug: This means the player runs 41% faster when running diagonally! This was a famous exploit in early 90s games (like *GoldenEye 007*).

• The Fix: You must always call moveDirection.Normalize(). This forces the maximum length of the vector to be exactly 1.0, capping diagonal speed.

6. Frame-Rate Independence (Delta Time) #

• At 60 FPS, it runs 60 times.

• At 144 FPS, it runs 144 times. The player moves more than twice as fast!

// Perfect, frame-rate independent movement
transform.position += moveDirection.normalized * speed * Time.deltaTime;

7. Visual Learning: The Motion Formula #

  [ Direction ]   *   [ Speed ]   *   [ Delta Time ]  =  [ Actual Movement ]
    (0, 0, 1)     *     5 m/s     *      0.016s       =    Move 0.08 meters
    Forward             Speed           Frame Time         This Frame

8. Best Practices #

• Use GetAxisRaw for Snappy Input: If you use standard GetAxis(), engines usually apply a slight "smoothing" filter to make the input feel like an analog stick, causing a slight delay before reaching top speed. For tight, responsive platformers (like *Celeste*), use GetAxisRaw(), which snaps instantly to 1 or 0.

9. Common Mistakes #

• Multiplying DeltaTime Twice: Beginners sometimes multiply their acceleration by DeltaTime, and then multiply the resulting velocity by DeltaTime again. This creates a quadratic time curve, making the physics simulation behave wildly unpredictably when framerates fluctuate. Only multiply velocity by DeltaTime when adding it to the position!

10. Mini Project: Build a Smooth Kinematic Controller #

class PlayerMovement
{
    public float walkSpeed = 8.0f; // 8 meters per second

    void Update()
    {
        // 1. Get raw input (-1, 0, or 1)
        float h = Input.GetAxisRaw("Horizontal");
        float v = Input.GetAxisRaw("Vertical");

        // 2. Construct the vector
        Vector3 direction = new Vector3(h, 0, v);

        // 3. Prevent diagonal speed boosting!
        if (direction.magnitude > 1f)
        {
            direction.Normalize();
        }

        // 4. Apply frame-rate independent motion
        transform.position += direction * walkSpeed * Time.deltaTime;
    }
}

11. Practice Exercises #

1. 1. Write the core formula for calculating Kinematic movement over time.

1. 2. Why is it critical to multiply movement speed by the engine's DeltaTime variable?

12. MCQs with Answers #

13. Interview Questions #

• Q: Explain the mathematical "Diagonal Exploit" found in early 3D games. How do modern engines prevent this issue using Vector Normalization?

• Q: Walk me through the concept of frame-rate independence. Why does multiplying velocity by DeltaTime guarantee that a character moves at the exact same speed on both a 30 FPS console and a 144 FPS PC?

• Q: What is the difference between Kinematic motion (updating transform.position via script) and Dynamic motion (using a physics engine's Rigidbody)? When is it appropriate to use Kinematic motion?

14. FAQs #

15. Summary #

16. Next Chapter Recommendation #