Unity C# Scripting Tutorial for Beginners: Introduction to Game Development

In Unity, the Update method runs once per frame and is suitable for general game logic but is framerate-dependent; FixedUpdate runs at a fixed interval (default 50 times per second) and is essential for physics calculations to ensure consistent behavior regardless of frame rate; LateUpdate runs after Update completes and is ideal for actions requiring previous calculations to finish first, such as camera following, ensuring smooth and predictable game behavior.

Unity provides four essential lifecycle functions: Awake() runs first during object initialization, Start() runs once when the scene launches, Update() executes every frame for smooth animations, and FixedUpdate() runs at fixed intervals for physics calculations. Understanding when each function executes is crucial for proper game development, as they serve different purposes in the game loop.

Unity's MonoBehaviour lifecycle follows a specific execution order: Awake runs first when the script instance is loaded (before Start), followed by OnEnable when the script is enabled, then Start just before the first frame update, FixedUpdate at a fixed interval for physics calculations, Update once per frame for frame-dependent tasks, LateUpdate after all Update methods for post-update adjustments, OnDisable when the script or game object is deactivated, and finally OnDestroy when the object is about to be destroyed.

Unity3D provides several event functions that control script execution order: Awake is called before Start when the game object is enabled, Start is called before any game frames begin, Update runs on every frame for game logic, LateUpdate runs after Update for systems like cameras that should follow player movement, and FixedUpdate handles physics-based calculations with a reliable timer that adapts to performance conditions.

Unity scripts contain lifecycle functions that execute at specific times: (1) Awake() runs once when the script is initialized, before Start(), (2) Start() runs once when the game begins, after Awake(), (3) Update() runs every frame for general updates, (4) FixedUpdate() runs at fixed intervals for physics calculations. For tasks that need to run only once (like instantiating coins), use Start(). For continuous movement requiring physics accuracy, use FixedUpdate() instead of Update().

In Unity3D physics, objects need both a Collider (to define their physical shape) and a Rigidbody (to enable physics simulation like gravity and movement); Colliders with the 'Is Trigger' option allow objects to pass through without physical interaction but can still trigger code callbacks, while non-trigger Colliders enable full physics interactions like bouncing and collision detection; Physics Materials control properties like bounciness and friction (values 0-1) which combine with other materials using average or maximum modes; Collision events use OnCollisionEnter for physical interactions and OnTriggerEnter for trigger-based area detection, each requiring specific callback methods in scripts.

In Unity, collision detection is implemented using the OnCollisionEnter function. This function is automatically called whenever two objects with colliders collide. The syntax requires 'void' before the function name, followed by 'OnCollisionEnter' with capital letters. The function must be placed within parentheses and curly brackets. For this code to work, the object must have both a Rigidbody and a Collider component attached.

In Unity, rigidbodies are physics-simulated objects that respond to forces and collide with other objects, while colliders are invisible geometric shapes that enable collision detection. Unity provides three types of colliders: static colliders (stationary objects that cannot be moved during runtime), rigidbody colliders (dynamically moving objects that respond to physics), and kinematic rigidbody colliders (can be moved but don't respond to forces). Unity also distinguishes between physical collisions (where objects physically interact and bounce off each other) and trigger collisions (where objects can pass through but detection events are triggered). Developers can respond to collisions using event methods like OnCollisionEnter, OnCollisionStay, and OnCollisionExit for physical collisions, or OnTriggerEnter, OnTriggerStay, and OnTriggerExit for trigger collisions.

In Unity, collision detection between objects is implemented using colliders (which define the physical boundaries of objects) and rigid bodies (which enable physical movement and interaction). Unity provides three built-in collision event functions: OnCollisionEnter (triggered when a collision begins), OnCollisionStay (triggered continuously while a collision is occurring), and OnCollisionExit (triggered when a collision ends). These functions allow developers to detect and respond to physical interactions between game objects, such as when a moving object hits a static wall or ground plane.

OnCollisionEnter and OnCollisionExit detect when objects touch or separate. These methods receive collision data including relative velocity and other colliders involved. They're useful for detecting ground contact for jumping mechanics.

To integrate the Unity Input System into game scripts: (1) Create a private variable of the generated InputSystemActions class; (2) Instantiate the input system in Awake() or Start() using new InputSystemActions(); (3) Enable input processing with the Enable() method; (4) Access actions through the action map hierarchy (e.g., input.Player.Move); (5) Use ReadValue<T>() to retrieve current action values. For value-type actions like Vector2, this returns directional input values that can drive character movement. The system requires explicit enabling/disabling and provides comprehensive debugging capabilities through console logging.

This section covers setting up player movement using Unity's New Input System. First, install the Input System package via the Package Manager. Then create an Input Actions asset to define custom controls. Configure ActionMaps for different contexts and create Vector2-based movement actions using the Up/Down/Left/Right Composite binding. Map these to WASD or arrow keys. Attach a Rigidbody2D component to the player object and configure it with GravityScale set to 0. Finally, add a Player Input component and link it to your Input Actions asset, selecting the appropriate ActionMap containing your movement actions.

This comprehensive section demonstrates how to implement player movement in Unity using the modern Input System. The workflow includes: installing the Input System package via Package Manager; adding the Player Input component to the player GameObject; creating and saving default input actions with standard keyboard bindings; writing a C# movement script with essential variables (movement speed, Rigidbody2D reference, and Vector2 for input); implementing the Move function using InputAction.CallbackContext and ReadValue<Vector2>(); connecting input actions to scripts through Unity Events by setting Behavior to 'Invoke Unity Events' and assigning the Move method. This represents the core gameplay loop where player input translates into character movement through physics-based velocity application.

Unity's Input System enables cross-platform game controls by allowing developers to create input actions that can be bound to multiple input devices (keyboard, Xbox, PlayStation) through a unified system; the implementation involves creating Input Actions assets, defining action maps and bindings, adding a Player Input component to GameObjects, and using InputSystem.GetInputValue() in scripts to retrieve and process input data for game mechanics like character movement.

Create a function 'public void OnMove(InputAction.CallbackContext context)' that reads the input values from the action map. Use 'context.ReadValue<Vector2>()' to get the current input values and store them in the 'move' variable. This connects the input system to the movement logic.

To create an Apple prefab, you create a cube, assign it a custom material (like Apple material), and drag it into your project folder. The prefab can be instantiated at runtime using the Instantiate function. You create a public GameObject field in your script, assign the prefab to it by dragging from the project folder, then call Instantiate with the prefab reference. The instantiated object is a clone of the prefab, and you can create multiple copies. After instantiation, you must cast the returned object to GameObject and modify its position using the transform property (like position = new Vector3(8, 4, 0)). This allows you to spawn game objects dynamically during gameplay.

In Unity, prefabs are reusable game object templates that can be instantiated (created) at runtime. To spawn a projectile, you create a prefab of your bullet object in the Project window, then use the Instantiate function in your script to create instances of this prefab at specific positions. The Instantiate method takes the prefab reference, position, and rotation as parameters. This allows you to efficiently create multiple identical objects without manually creating each one in the scene editor.

Prefabs in Unity are master templates that allow developers to create reusable game objects; when you drag an object into the Project window, it becomes a prefab that can be instantiated (spawned) anywhere in the scene, and any modifications applied to the prefab will automatically update all instances, while the Instantiate method in C# allows spawning prefabs dynamically during runtime by specifying position and rotation parameters.

Use GameObject.Instantiate() to create copies of prefabs at runtime. This is essential for spawning game objects like balls, paddles, and levels dynamically. The Instantiate method takes the prefab reference and optionally a position and rotation. This allows you to create new instances of game objects during gameplay, such as spawning a new ball when the player loses one, or instantiating new levels when progressing through the game.

In Unity, objects can be created dynamically at runtime using the Instantiate method, which requires three parameters: the prefab to instantiate, the position (Vector3), and the rotation (Quaternion). To properly create objects, you must reference a prefab (an object moved to the project folder) rather than a scene object, and you can store the instantiated object in a GameObject variable to manipulate it further, such as changing its position or adding components.