Game Development with Unity

Live: Online

Rs 9,500/- PKR

About Course

This beginner-friendly course offers an exciting journey into Unity game development, combining theoretical concepts and hands-on projects. Starting with a gentle introduction to programming through Scratch, learners will transition and deep-dive into object-oriented programming (OOP) concepts in Unity. The course then progresses to creating increasingly sophisticated games, including a 2D platformer hack-and-slash, a 3D ball runner, and a 3D kart racing game.

Week 1: Game Development Basics with Scratch

Introduction to Scratch Programming
- Understanding the Scratch interface.
- Creating simple animations and interactive stories.
- Introduction to logic: loops, conditions, and events.
Game Mechanics in Scratch
- Designing player-controlled characters.
- Implementing basic enemy behaviors and scoring systems.
- Creating a complete mini-game.
Transitioning to Unity
- Comparing Scratch blocks with C# code.
- Introduction to game design paradigms.

Week 2: Developing a 2D Platformer Hack-and-Slash Game

2D Level Design
- Designing platforms and obstacles.
- Building a cohesive game environment.
Player and Enemy Mechanics
- Implementing player movement and attack combos.
- Designing enemy AI with health and attack patterns.
Animation and Visual Effects
- Sprites animation (combat, jumping, running).
- Adding visual effects for attacks and damage.

Week 3: Developing a 3D Ball Runner in Unity

3D Environment Creation
- Designing a game level with planes and obstacles.
- Integrating 3D assets and materials.
Game Mechanics
- Applying Rigidbody, colliders, and forces.
- Implementing collision detection and dynamic obstacles.
Level Progression
- Level design strategies.
- Scaling difficulty as the player progresses.

Week 4: Developing a 3D Kart Racing Game

Kart Mechanics and Controls
- Programming acceleration, braking, turning, and drifting.
- Tuning physics for responsive and fun gameplay.
Environment and Track Design
- Creating a racetrack with checkpoints and obstacles.
- Applying 3D assets, lighting, and materials for visual appeal.
Gameplay Features
- Adding power-ups (e.g. speed boosts, traps).
- Developing AI opponents for single-player racing.
- Implementing lap tracking and race timers.
Final Polish and Presentation
- UI enhancements and camera work.
- Playtesting, debugging, and balancing.
- Presenting and showcasing the completed game.

What Will You Learn?

Implementing classic games like Space Invader, Pac-Man, and Angry Bird in Scratch and Unity.
Understanding the fundamentals of game development from beginner to intermediate levels.
Exploring the Scratch interface, including sprites, instructions, and attributes.
Learning Scratch blocks and adding scripts for motion, sensing, events, controls, and variables.
Demonstrating motion patterns on sprites, such as circular, spiral, square, and triangular motion.
Planning and developing a Space Shooter game with custom sprites and controls.
Creating bullet sprites, implementing firing methods, and managing bullet positions and motion.
Implementing enemy spaceship sprites with motion behavior, hiding, and scoring systems.
Designing and creating custom backdrops for game scenes and transitions.
Generalizing game mechanics through cloning and enhancing features like firing multiple bullets and animating enemy sprites.
Managing bullet and enemy sprite interactions, including hiding, delaying, and deleting clones.
Adding sound effects, creating a controller sprite for game management, and handling lives and game over features.

Implementing moving background sprites with scrolling effects and continuity management.
Introducing Pac-Man in Scratch, including game rules, sprites, and maze backdrop.
Creating start screens, generating coins, and managing Pac-Man character sprite movement.
Implementing ghost character movements, variable usage in blocks, and scripting level controllers.
Introduction to Unity game engine, player ball management, and script implementation for gravity and velocity.
Building player rotation and movement scripts, scene management, and reloading scenes.
Creating generalized games using prefabs for object management, upgrades, and investments.
Making Angry Bird in Unity, including player setup, spring addition, scripting, and enemy creation.
Designing 3D environments for FPS shooter games using ProBuilder, including ground, walls, and stairs.
Adding player movement and gravity management, along with jump factors and ground checks.
Integrating assets, like guns and targets, into Unity scenes, and implementing firing and damage mechanics.
Developing 3D hypercasual games, including player character animation, clone creation, particle systems, and bonus implementation.

Installation and Setup Guidelines

How To Install Unity & VS Code:
https://drive.google.com/file/d/1D22EP8jsw8hU8FuFuZwc1mGRZ9C4qufM/view?usp=sharing
How to Create New Project and Connect With External Coding Editor:
https://drive.google.com/file/d/1CDZ3-eb-sAbOqADn1rsj8qnbgBiYF9HZ/view?usp=sharing
VS Code Extensions & Auto Code Indent:
https://drive.google.com/file/d/13FhTTMd-oXn72Ioi14bfd0EdtZ7icCye/view?usp=sharing

Certifications

“Game Development With Unity”

June’2025-July’2025

Certified Students 🌟

Here you can view and download your certificates

Recorded Lectures

With lifetime access to our lecture content,
you can revisit and refresh your concepts at your convenience.

Lecture 01: Orientation

Unity Overview:
- Cross-platform engine for 2D, 3D, AR, VR, and simulations
- Widely used in both indie and AAA game development
Game Development Industry:
- Rapidly growing global market
- Careers in mobile, PC, console, and indie games
Core Game Development Fields:
- Programming, Design, Art & Animation
- Sound, Level Design, QA, Production
Team Roles:
- Differences in indie vs. AAA team structures
- Examples: Gameplay Programmer, Technical Artist, Narrative Designer
Unity in Action:
- Video demos of Unity-made games
Course Projects Overview:
- Stack Clone (physics basics)
- Jetpack Joyride Lite (sidescroller)
- Temple Run Lite (endless runner)
- Crash Kart (racing game)

Lecture 2: Programming Basics Part 1

C# Introduction:
- Used dotnetfiddle.net for writing/testing code
- C# is a strongly-typed, object-oriented language used in Unity
Data Types:
- Common types: int, float, double, string, bool
- Choosing correct type affects memory and behavior
Integer vs. Floating Point Division:
- int / int gives an int (no decimals)
- Use float or double to get decimal results
Type Conversion:
- Convert strings using int.Parse() or Convert.ToInt32()
- Be cautious with user input conversion
String Concatenation:
- string + int becomes a string
- Can cause issues in arithmetic with console inputs
Conditional Logic:
- Used if, else if, else for decision-making
- Applied in real-world code examples
Operators:
- Comparison: ==, !=, >, <, >=, <=
- Logical: && (AND), || (OR) for combining conditions

Help Session 01

Help session covered all tasks from Assignment 1: Programming Basics.
Showed how to use dotnetfiddle.net for writing and testing C# code.
Explained how to take user input and display a greeting (Task 1).
Discussed integer vs float division and how to fix it for decimal output (Task 2).
Identified the string concatenation issue and how to convert input for correct addition (Task 3).
Reviewed if-else conditions for checking teenage age range (Task 4).
Guided students on finding the larger number and checking for negatives (Bonus Task).
Helped fix common mistakes with type conversion and logic errors.

Homework 1

Lecture 3: Programming Basics Part 2

Advanced Conditional Structures:
- Used if, else if, and else for control flow
- Explained difference between multiple if statements vs. if...else if...else blocks
Logical Operators Review:
- && (AND) – both conditions must be true
- || (OR) – true if at least one condition is true
- Used in practical decision-making examples
Arrays vs. Lists in C#:
- Arrays: fixed-size (int[] arr = new int[5];)
- Lists: dynamic-size (List<int> list = new List<int>();)
- Lists offer more flexibility and built-in methods
Unity FPS Microgame Template:
- Explored Unity Learn’s FPS template
- Useful for understanding game mechanics and structure
Unity Interface Overview:
- Scene View – place/edit objects
- Game View – camera preview
- Hierarchy – lists GameObjects
- Inspector – shows selected object’s details
- Project – all assets
- Console – messages, warnings, errors

Lecture 4: Stack Clone Part 1

Unity Interface Recap:
Reviewed key windows: Scene, Game, Hierarchy, Inspector, Project, Console
Emphasized their roles in the development workflow
GameObjects & Primitives:
Introduced basic shapes like cubes and spheres
Everything in Unity is a GameObject with components
Scene Basics:
Camera – player’s viewpoint
Lights – scene illumination
Global Volume – post-processing effects (bloom, color grading, etc.)
Materials & Rendering:
Materials define object appearance
Rendering turns 3D data into 2D visuals
Mesh = object’s geometry (vertices, edges, faces)
Functions in Unity:
Functions = reusable code blocks
Key Unity functions: Start() (runs once), Update() (runs every frame)
Stack Clone – Movement Logic:
Began coding block movement
Used logic like speed = -speed for direction reversal
Forms the base mechanic for the stacking game

Help Session 02

Introduction to Classes in C#
Why classes matter in Unity
- Everything is a GameObject + Class
Recap of Functions
Classes as blueprints, objects as usable instances (House example)
Each instance is independent
Static members don’t need an object
Basics of Inheritance: parent Building, child House, Apartment
Abstract classes/functions and overriding
Unity uses this by inheriting from MonoBehaviour and customizing Start/Update functions

Lecture 05: Frames, Events & Object References

Introduced Update and explained how it’s tied to frame rate—more FPS means faster movement.
Highlighted fluctuation issues and how it affects speed; introduced Time.deltaTime to normalize it.
Compared Update vs. FixedUpdate—FixedUpdate runs on a fixed interval and is better for physics.
Introduced Input Manager for handling user input; briefly explained KeyCode enum.
Demonstrated how to reference another object (like the stack) to call its script function StopMoving.
Recapped object-oriented concepts—why we assign references instead of using new to maintain state.
Discussed the issue of updating the reference for every newly spawned stack object.
Introduced Events and how they allow objects to subscribe and react (used to stop movement and spawn cubes).
Added a StackManager to handle cube spawning when the screen is tapped.
Answered a student question by introducing Script Execution Order and showed how to change it.

Lecture 06: Stack Slicing & Movement Axis

Alternated movement direction for each new cube added to the scene.
Used vector indexing (e.g., vector[0], vector[2]) to choose the movement axis dynamically.
Removed if-else checks by using numeric axis indexing.
Applied modulo operator (% 2) to switch between x-axis and z-axis movement.
Implemented logic to detect overlap between the current cube and the one below.
Calculated overlap distance to decide whether to keep a part or end the game.
Resized the cube to retain only the overlapping section.
Repositioned the trimmed cube to align correctly with the stack.
Spawned an overhang object to represent the sliced-off portion.
Applied physics to the overhang so it falls naturally using gravity.

Help Session 03

Fixed a slicing bug where overlap distance was incorrectly used as the new position.
Corrected the logic by adding overlap to the current position instead of replacing it.
Implemented upward camera movement to follow the stacking.
Applied interpolation to smooth out camera transitions.
Added post-processing effects like Bloom and Vignette for better visuals.
Improved visual appeal and polish of the scene using Unity’s post-processing stack.
Identified a bug where the slab got stuck at movement limits.
Traced the issue to rapid direction reversals when Abs(position) >= limit.
Fixed it by checking for both positive and negative limits separately.
Ensured the slab direction is correctly reset, preventing movement from freezing.

Lecture 07

Created a new 2D Unity project and configured the scene and camera for 2D gameplay.
Introduced Colliders (BoxCollider2D, CircleCollider2D) to detect object collisions.
Explained Rigidbody2D for enabling gravity, mass, and physics-based movement.
Differentiated between kinematic and dynamic rigidbodies.
Implemented player movement using AddForce() for smooth, responsive control.
Adjusted force values to fine-tune movement behavior.
Imported a spritesheet and sliced it using Unity’s Sprite Editor.
Created Animation Clips and an Animator Controller for idle and walk animations.
Linked animations using the Animation and Animator components.
Shared free asset sites for game art: kenney.nl and itch.io (Free assets section).

Lecture 08

Sprite Sheets & Slicing – One image contains multiple sprites; slicing extracts them automatically or using grids.
Sprite Tiling – Repeats a sprite to fill areas like floors; requires correct import settings for seamless look.
Pixels Per Unit (PPU) – Controls sprite size; lower PPU = bigger sprite, standard is usually 100.
Child Transform Positions – Child objects move relative to their parent; moving parent affects the child.
Vectors Refresher – Vectors represent position and direction, useful in movement and aiming.
Vector Arithmetic – Vectors can be added/subtracted; Vector3.right, up, etc., help move along axes.
Infinite Level Tiling – Reuse tiles by repositioning them ahead of the player for endless scrolling.
SpriteSheet Animations – Use sliced sprites to create frame-by-frame animations with loop and speed settings.
Animator Introduction – Manages animation transitions using state machines and parameters like bools or triggers.
Parallax Backgrounds – Adds depth by moving background layers at different speeds (closer = faster).

Help Session 04

Parallax:
- Background layers move at different speeds for depth.
- Follows camera offset.
Animator:
- Controls animation states (Idle, Run, Jump).
- Uses transitions with conditions.
Code Control:
- GetComponent<Animator>()
- SetBool(), SetTrigger(), SetFloat()
- Strings must match Animator parameters.
Collision vs Trigger:
- Collision: Physical contact, uses Collision2D.
- Trigger: No contact, uses Collider2D.
- Use for reactions vs detection.

Help Session 04: Extended Version

Obstacle Creation:
- Design prefabs (spikes, pits, walls) with colliders/scripts.
Random Spawning (1 per tile):
- Use lists; loop through tiles, spawn one random obstacle each.
Die Animation:
- Trigger with animator.SetTrigger("Die").
- Disable movement/collision after death.
Animation Events:
- Call methods from specific animation frames.
- Methods must be public void in relevant script.
UI: Canvas & TextMeshPro:
- Canvas: Holds UI, set to Screen/World Space.
- TextMeshPro: Advanced text; import essentials package.
GameManager (Game Over + Pause):
- Show Game Over UI on death.
- Pause: Time.timeScale = 0f
- Resume: Time.timeScale = 1f

Lecture 09

Mixamo Animations: How to import and retarget them to custom characters.
Rigs & Skeletons: Bone hierarchy and joint roles in animation.
Root Motion: Difference between root motion and manual movement.
Fixing Mixamo Textures: Manually assign missing textures; common issues with material links.
Player Movement:
- transform.forward: based on object rotation
- Vector3.forward: fixed world direction (0,0,1)
Unwanted Root Motion Fixes:
- Turn off “Apply Root Motion”
- Remove with script or animation window

Lecture 10

Rigidbody Movement: Moving the player using Rigidbody.velocity or AddForce for physics-aware control.
Collision Accuracy: Smooth and realistic behavior through physics-based interactions.
Sliding Mechanic: Resize collider height and center dynamically during slide.
Jump Reset: Restore original collider size and center when jumping or standing.
CapsuleCollider Tips: Use .height and .center to prevent ground clipping.
Debug.Log(): Print messages to the console for quick runtime feedback.
Inspector Debugging: Track variable values in real-time during gameplay.
Breakpoints: Pause and inspect code using Visual Studio breakpoints.
ProBuilder Overview: Unity’s built-in tool for quick level geometry creation.
Level Design with ProBuilder: Create/edit 3D shapes directly in the scene view for rapid prototyping.

Lecture 11

Object Following: Used vectors to make objects follow a target; introduced direction and magnitude.
Obstacle Issues: Faced limitations with basic vector following when obstacles blocked paths.
NavMesh System: Applied Unity’s NavMesh, Agents, Surfaces, and Modifiers for AI navigation.
Pathfinding AI: Enabled dynamic pathfinding using built-in AI Navigation tools.
Dynamic Surfaces: Showed real-time updates to NavMesh as levels changed.
Smart Tile Spawning: Designed rules to avoid circular paths and conflicting turns.
Turn Restrictions: Prevented opposite turns from spawning side-by-side on half tiles.
Canvas Types: Explained Screen Space (Overlay, Camera) and World Space canvases.
Button Creation: Built UI buttons with onClick() event handlers.
Button Transitions: Used Sprite Swap, Tint, and Animation for button visuals.