Udemy
    •  
    •  
    •  
    •  
    •  
    •  
    •  
    •  
Turn what you know into an opportunity and reach millions around the world.
Learn More
Your cart is empty.
Keep shopping
Create a 2D procedurally generated Roguelite in Unity 6.2
Rating: 5.0 out of 5(2 ratings)
81 students

Create a 2D procedurally generated Roguelite in Unity 6.2

Learn how to make procedural game similar to Nuclear Throne
Created byJMG Studios
Last updated 10/2025
English
English [Auto],

What you'll learn

  • You'll learn how to create a highly customizable random walker algorithm
  • You will learn to master the tools Unity Engine 6.2 has to offer
  • You will have a great understanding and practice of scripting in C#
  • You will learn how to create modular code for professional result

Course content

5 sections49 lectures9h 2m total length
  • Download, install and set up Unity, VSCode and dotnet6:09

    Install Unity using Unity Hub, create a Unity ID, choose the personal plan, and install VS Code, .NET, the C# dev kit, and Unity tools for coding.

  • Create the project and setup the scene9:56

    Create a new Unity 2D project, configure Unity 2D, set up ground and background tile maps, then import a tileset, slice into 32-pixel tiles, and build a tile palette.

  • Create the walker script and all the variable needed13:58

    Develop the walker script and all generation variables in Unity 2D, wiring tile maps, serialized fields, and grid and worker management for procedural roguelite levels.

  • Coding the walker algorithm16:02

    Code the walker algorithm to stay within workable bounds, perform a random walk inside the grid, and mark visited tiles. Enable grid bounds handling and runtime level generation.

  • Using the walker to create the level24:29

    Create a two-dimensional roguelite level in Unity by calculating grid and walker bounds, generating the level with walkers, and filling tile maps from visited tiles.

  • Restart the level with new input system9:11

    Bind the R key in the Unity input system’s UI action map to restart the level, wiring an onRestart callback to regenerate the grid and level.

  • Adjusting the Camera setting3:02

    Adjust the main camera size to fit your screen resolution and test changes. Demonstrates the procedural map view and prepares for Cinemachine and a sprite atlas.

  • Coding the player handler16:07

    Implement a player handler in Unity to place the player at the leftmost tile and the exit at the right, using grid min/max and ground tile map for level generation.

  • Creating the player prefab and placing the player in the level15:45

    Place the player prefab after level generation by destroying existing instances, finding the leftmost floor tile, converting to world coordinates, centering the spawn, and waiting with a coroutine.

  • Coding the player movement14:22

    Learn 2D player movement in unity by adding a rigidbody 2d with zero gravity and frozen rotation, wiring the move action, and driving velocity in fixedupdate.

  • Adding collider to the tilemap3:00

    Add a tilemap collider 2D to the background, then attach a composite collider 2D with a static rigidbody, merge tilemap colliders, and ensure the player remains within the generated level.

  • Creating an autotile with Bitmask for creating a seamless background13:59

    Build a seamless 2D background in Unity using an autotile with a bitmask, adjust camera projection to fix tearing, and configure platformer and top-down tile sets.

  • Fixing the tearing of the tilemap with a Sprite Atlas3:51

    Learn how to fix tilemap tearing by creating and configuring a sprite atlas in Unity, switching to point filter, disabling compression, and packing tiles for a seamless atlas.

  • Importing the final tileset4:27

    Import the final tile set in Unity, slice 32x32 auto tiles, and create reusable bitmask tiles to build the 2D background and set up custom physics shapes for collision.

  • Creating custom physics shape to adjust the tilemap collider4:06

    Create and apply a custom physics shape in the sprite editor to generate precise tile colliders across the tile set, then test and adjust the Unity 6.2 collision system.

  • YSorting object at runtime so they display at the front or behind other objects6:41

    Master runtime y-sorting in Unity 2D by using custom axis transparency sort, aligning background tile map and player sorting layers, and adjusting colliders for correct overlap.

Requirements

  • A little programming experience is good to have, but I'll walk you through all the concepts

Description

Dive into the thrilling world of roguelite game development with this comprehensive, hands-on course! Learn to create a dynamic 2D top-down roguelite in Unity 6.2, featuring procedurally generated levels, modular gameplay systems, and polished mechanics that keep players coming back. Whether you're a beginner or a seasoned developer, this course guides you step-by-step to craft a replayable, action-packed game from scratch, perfect for your portfolio or indie release.What You'll Learn:

  • Procedural Level Generation: Master the walker algorithm to create unique, fully customizable levels at runtime, tweakable through Unity’s Inspector for endless variety.

  • Top-Down Movement & Shooting: Build a responsive player controller with modular, expandable gun abilities for dynamic, satisfying combat.

  • Unity’s Autotile System: Harness Unity 6.2’s new autotile system with custom physics shapes to design stunning, seamless levels that look professional.

  • Diverse Weapon Systems: Implement a variety of guns with unique behaviors to diversify gameplay and keep players engaged.

  • Smart Enemy AI: Spawn enemies that dynamically detect and shoot at the player when nearby, creating challenging and immersive encounters.

  • Polish & Optimization: Learn techniques to optimize performance and add polish, ensuring a cohesive, replayable roguelite experience.

Why Take This Course?

  • Build a game from start to finish with industry-standard tools.

  • Gain practical skills in procedural generation, modular design, and Unity’s latest features.

  • Perfect for indie developers, hobbyists, or anyone looking to create portfolio-ready games.

  • No fluff—just real, actionable techniques to bring your roguelite vision to life.

Who This Course Is For:

  • Aspiring game developers eager to learn Unity 6.2 and roguelite mechanics.

  • Intermediate developers wanting to master procedural generation and modular systems.

  • Unity enthusiasts excited to explore the new autotile system and physics shapes.

Prerequisites:

  • Basic knowledge of Unity and C# programming.

  • A passion for game development and roguelites!

By the end, you’ll have a functional 2D roguelite with procedurally generated levels, exciting combat, and polished visuals. Join now and start building your own procedurally generated 2D roguelite in Unity 6.2!

Who this course is for:

  • Student in computer science looking for portfolio project, beginner to programming, indie developer looking to expand their knowledge