Object Oriented Programming for Unity game devs

Discover how to add a starter project to Unity Hub by unpacking the zip, creating a project folder, loading the project, and testing the main menu scene.

Explore a starter Unity project layout, scenes, and gameplay, and learn to refactor for maintainability with object oriented programming to extend enemies and weapons and manage score across levels.

Explore why object oriented programming improves maintainability by refactoring a single big enemy class into a unit base class with inherited archers, warriors, and mages, guided by a unit manager.

Class acts as a blueprint for objects, defining data and behaviors. Objects share a class but maintain their own state, and Unity uses inspector to set data.

Encapsulation bundles data and behaviors, shown by a mover class handling speed and rigid body movement. It decouples input from movement, enabling reuse for player and enemy.

Explore how inheritance enables data and behavior reuse across weapons like swords and bows. Define an abstract weapon with protected data and an abstract attack method that subclasses implement.

Explore inheritance in unity by comparing abstract classes and interfaces, implement the I weapon interface with perform attack, and use enable and upgradable interfaces to add behavior without shared data.

Explore polymorphism by showing how a player uses an abstract weapon class to perform attacks, swapping swords, bows, or spears at runtime for flexible, maintainable code.

Explore composition as building an object from reusable parts, contrasting it with aggregation and inheritance. See how weapon modifiers in a hierarchy add elemental damage to games while favoring composition.

Assess when object oriented programming benefits a Unity prototype and when to keep it simple. Learn refactoring, modular design, and model–view–controller patterns to prepare for growth.

The lecture analyzes refactoring the shooting system to support multiple weapons, using object oriented concepts like encapsulation and composition to enable spread, double, and burst shot patterns.

Plan a modular solution by decoupling weapon logic from the player using composition and an abstract attack pattern, applying single responsibility and other solid principles for maintainability.

Refactor the Unity player by encapsulating shooting logic into a weapon class within a weapon system namespace, highlighting object oriented principles and separation of concerns.

Refactor the weapon system into an abstract attack pattern as a scriptable object, with protected attack delay and audio SFX and a public abstract perform method.

Learn to implement multiple attack patterns for a Unity ship by inheriting from an abstract attack class, creating double barrel, spread, and burst patterns, and spawning projectiles from rotated barrels.

Design a burst attack by extending the attack pattern to spawn three projectiles with offset and rotation, and share a common projectile across attack patterns for weapon swapping.

Learn how bullet projectiles collide with a meteorite to change direction and with enemies or players to lose lives, using a unified, object-oriented approach to projectile collision in Unity.

Explore implementing a common hittable interface in unity using c# to let projectiles interact with enemies and players by calling getHit with damage and sender info, enabling easy extension.

Leverage unity’s layer collision matrix to control collisions between player, bullet, enemy, and enemy bullet, then implement the IHittable interface on projectiles and destroy them on hit.

Refactor player and enemy scripts to implement the AI hittable interface, encapsulate health, get hit feedback, and death logic, and streamline on trigger enter handling.

Implement a meteorite object in Unity that is pushed by a bullet, with bounce behavior on players and enemies, using a kinematic rigidbody and box collider.

Create a meteor object in Unity with a sprite, circle collider, and kinematic Rigidbody2D; rotate, move, and bounce it using a reusable AI-capable interface.

Learn how object oriented programming improves visual and audio feedback for collisions in a Unity game while refactoring the health and feedback systems for better maintainability and reuse.

Explore component-based architecture and composition over inheritance in Unity, replacing rigid inheritance with reusable health components attached to game objects, accessed via the inspector, and driven by Unity events.

Extract the health system from the player and enemy into a dedicated health class, encapsulating logic for reuse and exposing hittable behavior with Unity events for death and hit.

Refactor the player and enemy scripts to use a shared health component, initialize health values, and drive on death events with get hit feedback and UI updates.

Refactor the health system to use a dedicated feedback system that triggers visual effects and audio on hit and death, creating reusable feedback prefabs for player and enemy interactions.

Wire enemy feedback with prefabs, adding hit and death audio and visual effects, and remove delayed destruction in favor of immediate removal after feedback.

Learn to implement bullet feedback by wiring SFX and VFX to a bullet's death event and attaching a reusable health component, with prefab variants for reuse.

Discover how object oriented programming decouples enemy behavior to add new enemy types and make the system more maintainable using abstraction, encapsulation, and composition.

Explore why inheritance can create duplication in enemy behavior and learn to replace it with a component-based approach in Unity, using small action scripts for shooting, movement, and aiming.

Refactor the enemy by extracting movement into a dedicated MovementAction component, encapsulating rigidbody movement and speed, enabling object-oriented, modular behavior and preparing to refactor shooting next.

Refactor enemies into shoot and aim actions, wire a weapon system, and enable enemies to look at and shoot at the player using updated update logic and attack patterns.

Swap in a new enemy prefab, update its sprite and collider, and swap the enemy script to test a melee variant, then implement wave movement using amplitude and frequency.

Implement a sine-wave enemy movement in Unity by creating a movement script, refactoring the enemy spawner to use a random enemy from a list, and embrace modular, object-oriented design.

Learn how to apply object oriented programming in Unity through prototyping, planning with UML diagrams, and apply design patterns to expand features like enemies, weapons, and inventory.