Game Developer interview questions

Delta time keeps movement speed stable across frame rates.

• Multiply speed by elapsed seconds before adding displacement.
• Compare travel over one second at 30 and 144 FPS.
• Do not rescale forces already integrated by a fixed physics step.

The cooldown must count seconds rather than rendered frames.

• Start from a duration such as 0.8 seconds.
• Subtract the appropriate clock delta and clamp at zero.
• Verify equal completion time under several frame caps.

A simple loop reads intent, advances simulation, and presents the result.

• Process current input before gameplay decisions.
• Advance physics with its controlled time step.
• Render feedback from the completed world state.

A fixed step suits simulation that needs stable integration.

• Run physics at a constant interval independent of rendering.
• Interpolate visual poses when render frames fall between steps.
• Cap catch-up work so a slow frame cannot cause a spiral.

MonoBehaviour provides component behavior and Unity lifecycle callbacks on a GameObject.

• Keep one focused responsibility such as health or movement.
• Expose scene references through validated serialized fields.
• Use lifecycle methods only for work belonging to that phase.

A required component should be explicit, validated, and cached once.

• Wire a serialized reference when another object may be chosen.
• Use GetComponent during initialization for a same-object dependency.
• Fail clearly when the prefab is assembled without the dependency.

Implicit order can expose a component before its state is ready.

• Use Awake for self-contained setup.
• Use Start or explicit initialization for peer dependencies.
• Retest after scene loads and runtime prefab creation.

Each Unity callback should advance the state matching its timing phase.

• Read ordinary input and non-physics logic in Update.
• Apply Rigidbody changes in FixedUpdate.
• Move a follow camera in LateUpdate after its target.

Focused components make player features reusable and easier to test.

• Reuse Health on players, enemies, and breakable props.
• Test Movement without inventory and audio side effects.
• Connect features through narrow methods or events.

Stable foundations belong in C++, while safe tuning and assembly fit Blueprints.

• Implement shared rules and components in reviewable C++.
• Let designers choose assets and tune exposed defaults in Blueprints.
• Move duplicated complex graphs behind a shared parent or C++ function.

An Actor exists in the world, while a component adds reusable behavior to it.

• Represent a placed pickup as an Actor with a transform.
• Share health through an Actor Component.
• Choose a Scene Component only when the component needs a transform.

I would extract named behavior and remove duplicated execution paths first.

• Replace copied node groups with functions or components.
• Prefer events and timers over constant polling on Tick.
• Move code to C++ only after measurement justifies it.

Unconditional Tick spends CPU even while a feature is idle.

• Use input, overlap, delegate, or timer events for discrete changes.
• Enable Tick only during temporary per-frame behavior.
• Measure necessary Tick code in Unreal Insights.

Expose a constrained tuning property while retaining movement rules in C++.

• Give it a clear category and units-per-second default.
• Clamp invalid values through metadata or validation.
• Offer methods for state changes instead of public internal fields.

Convert device input into normalized intent relative to the chosen control frame.

• Read one semantic two-axis movement action.
• Build forward and right from camera or character yaw.
• Let the movement component own acceleration and collisions.

Trigger jump on the press edge and gate it with character state.

• Do not treat a held callback as repeated presses.
• Consume grounded permission when takeoff begins.
• Handle release separately for variable jump height.

Trace dash bindings and state entry before changing its timing.

• Log the input with frame and receiving instance.
• Check duplicate subscriptions after enable or respawn.
• Reject dash entry unless state and cooldown both allow it.

Remember the last grounded time and accept a jump for a short grace window.

• Record a timestamp on every valid ground contact.
• Accept takeoff within about 0.1 seconds of that timestamp.
• Consume the grace permission when the jump starts.

Input buffering retains a recent action until a near-future state permits it.

• Store a jump pressed just before landing.
• Attach an expiry such as 0.1 seconds.
• Consume it on execution and discard it on expiry.

Map both devices to semantic actions outside gameplay logic.

• Bind Space and the gamepad south button to Jump.
• Feed one movement vector to the controller.
• Change prompts by last device without changing handlers.