Intermediate Unity 6 : Connect Complex Game Mechanics

Set up a Unity 6 2D project in Unity Hub with the built-in render pipeline for a minimal, Cookie Man project workflow.

Explore how to import and configure 2D assets and sprite settings in Unity, including texture type, sprite mode, compression, filter, and pixels per unit for grid-aligned gameplay.

Organize sprite sheets and atlases for the Cookie Man game by grouping assets into three Unity-ready images aligned to a 128 by 128 grid with padding to prevent texture bleeding.

Learn how Unity uses sprite maps and rule tiles to generate level layouts from abstract geometric shapes, automating tile placement with rules rather than manual drawing.

Apply neighbor-based rules to a sprite map, exchanging the middle tile when neighbors match. Build with top, bottom, left, and right rules and a priority order in Unity.

Transform imported sprites into tiles, then add them to a tile palette. Use the tiles on a tile map to draw in your Unity scene.

Connect the roof tile to a tile palette, create a tile map and palette prefab in assets, and learn rule tiles and palette painting.

Define rules for tiles by using the inspector to set neighbor-based conditions, using green arrows and red crosses to apply sprites for center and edges.

Extend unity's rule tiles by adding a new inside and wall tile, create a custom wall tile script, and configure minimap rules to detect neighboring tiles.

Learn how to implement custom rule tiles in Unity by defining inner tiles, checking neighbors in the rule match method, and drawing rooms with vertical, horizontal, and edge rules.

Learn to draw castles in unity with rule tiles, a tile map, and prefabs, switching between 2d and 3d views while adjusting the grid swizzle to the x z axis.

Explore texture bleeding in Unity tile maps, compare padding versus no padding sprite sheets, adjust pixels per unit and grid slicing, and apply padding to eliminate gaps and artifacts.

Create the main level in a new Unity scene using tile maps and rule tiles, forming an eight-by-five inner chamber with one-unit paths and a grid for movement and AI.

Explore why grids in Unity transform endless world space into manageable cells, enabling simple placement, movement between walkable neighboring cells, and occupancy checks.

Create a lightweight, non-monobehaviour grid system in Unity. Build a 2D array of grid objects that store their cell positions, with a grid manager to initialize and expose cells.

Derive the grid size from the tile map’s size and expose width and height, then add an editor tool to regenerate the grid as the level changes.

Create an editor script for the grid manager with inspector buttons to regenerate the grid and toggle visibility, ensuring the grid respects the level's bounding box and origin.

Learn how to make a Unity grid position independent by adding a grid renderer that translates grid cells to world space using the level origin, keeping the grid math simple.

Export the grid scripts as a package and import them into the main Unity project, then tidy assets by moving scripts into a scripts folder for a future refactor.

Connect the grid to the level by compressing the tilemap and regenerating the grid, then add path and wall types to grid objects for movement.

Explore basic movement in unity, focusing on input and perception within a simple playground. Decide between physics-based movement and custom logic for collisions and control.

Import grid package to establish a Unity grid, refactor to a grid cell type, and expose a grid manager API via partial classes for player movement access to grid size.

Learn to combine raycast targets with grid logic by converting world position to a grid cell, translating input vectors to directions, and retrieving the neighbor's center position.

Implement and validate neighbor cell logic on a grid, handle invalid directions, enable rail-like player movement with dynamic target updates, and use grid centers for precise positioning and debugging.

Replace raycasts with a grid-based movement system that uses walkable and wall cell types to validate neighbors, via a dedicated grid API and neighbor checks. Verify the grid visually.

Explain how to reduce corner cutting by buffering a turn target until the player reaches the cell center for perpendicular turns, using a two-target approach to smooth turning.

Buffer the previous and current input directions to drive movement. Use a grid-based target system and a center-of-cell check to switch targets and move in the chosen direction.

Polish improves player movement by preventing corner cutting and distinguishing turns from direction switches. It uses a grid center fallback and a speed field for smoother motion.

choose between a quick and dirty integration or a polished, detailed refactor of movement changes in the Unity course project; two versions are provided, one export-based and one hand-refactored.

Import and merge grid scripts into course project, resolve conflicts, export grid and player movement packages. Update grid initialization to support path tiles and enable movement in play mode.

Refactor the grid system by introducing grid cell as position type and separating vectors for direction from world positions, and enhance the grid visualization to distinguish path and wall cells.

Add and integrate the player movement script with the grid manager API, translate directions, calculate grid coordinates, and verify cell centers and neighbor cells are walkable.

Refactors and extends the grid API to determine neighbor cells, validate walkable neighbors from world positions and directions, and compute neighbor positions and cell centers for movement.

Refactor grid API to get cell position from any world position, connect grid to the renderer and constructor, and enable player movement through the input system and Onmove events.

Learn how the animation controller uses a state machine to pick a single animation clip, switching between rotate right and rotate left through transitions and parameters in Unity.

Learn to create sprite sheet animations in Unity by slicing sprites, building left and right walk cycles with animation clips, and mirroring with flip X for efficient right-direction animation.

Create a top-down Unity character with a four-direction sprite sheet and an animation controller. Drive down, up, left, and right movement using any-state transitions and x and y direction parameters.

Create a player controller to connect input with the animation system, updating the animator's x and y integer parameters from move input and a moving flag, while enabling speed adjustment.

Layer and animate a character in Unity using two animation layers for direction and movement, with idle and moving states, size tweaks, and an isMoving parameter linked to scripts.

Decouple the player controller from the animator by introducing a dedicated player animator script connected via events that signal move state and direction.

Connect the player movement to animations in Unity with a direction changed event using a vector2. The player animator converts this to moveX and moveY and subscribes to the event.

Create a three-state monster animation system in Unity—default, frightened, and eaten—using per-direction clips, a shared animator controller, sprite sheets, and flicker timing for frightened timeout.

Use animation override controllers to share a base monster controller across the four ghosts, overriding only each monster’s default movement while keeping eaten and frightened states shared.

Set up Unity monster animation transitions using any state, with move x/y and three boolean states (default, eaten, frightened) plus a frightened timeout trigger; test in play mode.

Create a monster animator script in Unity to encapsulate monster animation access, reuse the player animator template, manage direction changes, and expose public methods to set isDefault, isFrightened, and isEaten.