Game Dev Essentials: RPG Mechanics for Indie Games in Unity

Set up a Unity UI for distributing points, importing Text Mesh Pro and 2D sprite packages, creating a canvas and sliced borders to build an interactive RPG stat screen.

Distribute points to a strength attribute in a Unity RPG prototype by wiring a UI button with serialized fields, tracking points left, and updating on-screen text.

Set up an attribute modifier UI in Unity by importing the package, organizing prefabs, duplicating scenes, and configuring a container, labels, bars, and an agility attribute to visualize stat changes.

Define an attribute class to hold the base value and derive the final value later, exposing the base via a read-only property and serializing it for the inspector.

Create and manage a list of attribute modifiers in Unity to adjust a base value, supporting flat and percentage changes, with add and remove operations and prevention of duplicates.

Calculate the final attribute value by adding base value with flat and percentage modifiers, then recalculate on changes to support an RPG attribute system in Unity.

Experiment with a flat attribute modifier by coding a Unity monobehaviour that equips and unequips a glove to affect agility, updates on-screen text, and demonstrates adding and removing modifiers.

Demonstrate implementing a percentage attribute modifier by duplicating a gloves item to travelers boots, assigning a 20% energy boost, and wiring equip/unequip logic with a fix for float division.

Learn to implement a simple RPG abilities UI in Unity, including a container, icon, level text, ability name, damage, cooldown, critical chance, and two buttons.

Explore how to model abilities with a definition and an instance using a scriptable object, separating data-driven definitions from runtime state, and supporting per-level stats like damage and cooldown.

Define per-level ability details with an ability level info file that stores min/max damage, critical chance, and cooldown, and create a meteor storm with upgrades in Unity via scriptable objects.

Build a core ability system: define abilities, manage levels, and execute spells with min/max damage, critical chance, and cooldown, including level up, reset, and inspector visibility.

Learn to implement a Unity ability system by creating a definition, adding a constructor, and testing level up and reset behaviors with a meteor storm example.

Create a monobehaviour ability view, serialize fields for image, title, damage, cooldown, critical chance, and level, and render the ability data to update the ui in Unity.

Explore damage calculation by combining attribute points with abilities and setting up a Unity user interface, including importing a package, configuring prefabs, and building ability containers.

Create an energy drain ability by adding Script Objects and an Ability Definition asset, name it energy drain, choose an icon, and configure three levels with durations and percentages.

This lecture presents a generic damage calculation using base damage and a multiplier affected by attribute points, including critical hits, implemented via a static combat utils class.

Implement damage calculation and cooldowns for Unity abilities, using an async start cooldown and is in cooldown flag, triggered by keys, with base, final, and critical damage.

Develop and wire a cooldown-based ability button system in Unity: convert UI elements into buttons, assign indices, handle clicks with events, and disable during cooldown and re-enable after cooldown.

Learn how to prototype and spawn a damage pop up in Unity using Text Mesh Pro and the Twin asset, with notes on setup, coding, and runtime.

Import the experience points package, create the scene, and arrange UI elements—buttons, text mesh pro fields, and an experience bar—using the provided fonts, images, and prefab, including the event system.

Implement a Unity C# experience system script that tracks level and current experience, adds XP for quests and battles, and checks level ups against an experience table.

Create an experience table as a scriptable object in Unity, using a list of level thresholds to drive level-up checks. Initialize current level and XP and populate data for levels.

Add experience to the player, check level ups against the experience table, manage max level by resetting xp to zero, and broadcast an on experience change event to listeners.

Create and test an experience system in Unity by wiring a serializable experience table to a MonoBehaviour, updating with space to add experience, and verify level-up logic.

Learn to build a dynamic experience bar in Unity by creating a view script, animating fill using lerp, and wiring texts, levels, and XP updates.

Set up an inventory UI in Unity by importing a package, creating an inventory canvas, and configuring action buttons, item slots, images, and counts to visualize inventory items.

Design an inventory as a list of slots that reference item definitions and hold per-item state such as durability; support nonstackable and stackable items through defined max stack sizes.

Create item definitions as scriptable objects in Unity, capturing id, name, icon, and max stack, then define example items like x of the warrior and gem.

Create and link an item to its definition in Unity by scripting the item class with durability, storing static data in the definition and mutable data in the item.

Define an inventory class that holds a list of inventory slots and enables adding, removing, and swapping items. Serialize the inventory to save state and keep the design simple.

Create an inventory slot in Unity by implementing an InventorySlot class with item and quantity, and expose isEmpty and isFull checks that use the item definition max stack.

Explore adding items to an inventory in Unity by initializing slots, setting capacity, and implementing add item logic with stack and empty-slot handling.

Create a simple inventory example in Unity to test add item functionality, initializing a four-slot inventory, adding items via key press, and demonstrating stacking, slot expansion, and durability changes.

Remove item from inventory by finding the item slot, unstacking if needed, and decrementing quantity or clearing the slot, then return the removed item; test with q to remove x.

Implement a swap feature in the inventory by exchanging two slots with bounds checking, using tuple swap in C#, and testing with gem, x, and broken x.

Learn to render a Unity inventory UI: create an inventory view with slot views, display item icons and counts, handle empty slots, and prepare for drag-and-drop and click interactions.

Learn to implement an in-game inventory view that supports item selection, drag-and-drop swapping, and responsive controls, using slot views, click and drag events, and a Unity event system.

Set up the quest user interface in Unity by importing quest packages, organizing prefabs, and building a canvas with quest views, task items, and finish buttons.

Learn to model quests with a static quest definition and a changeable quest instance, each containing task definitions, and manage them through a quest controller.

Create quest definitions and task definitions as scriptable objects in Unity, with ids, titles, and descriptions; define a quest with tasks: fight seven slimes, collect ten loops, talk with trainer.

Implement the quest and task system by defining Quest and QuestTask classes, linking them to quest and task definitions, tracking completion state, and initializing tasks from the definition list.

Add quests by ID using a Unity scriptable object repository to fetch quest definitions and create new quest instances in the quest controller.

Receive a task ID, locate the matching task in each quest, mark it completed, and return the updated quest. Test by wiring the finish task to UI buttons.

Finish quest flow checks the quest id, retrieves the quest definition from the repository, verifies all tasks are completed, marks the quest as completed, and returns the updated quest.

Build and render a quest view in Unity with a monobehaviour script that loads quest data and displays title, description, and tasks, updating completed tasks with color and strikethrough.