A complete 2D action platformer with Paper2D and PaperZD: tilemap levels, three enemy archetypes, and a boss fight.
This project is a 2D action platformer built entirely in Blueprints with Unreal Engine 5, developed following this Udemy course. It uses Paper2D for sprites and tilemaps and PaperZD for animation state machines — the same toolset covered in the 2D Game Prototypes project — but applies them to a more complete game structure: two distinct levels, three enemy archetypes, collectible items, and a boss encounter.
You can watch the prototype in action here: YouTube
Level Structure: Main Level and Boss Level
The game is divided into two levels — a main level where the player fights enemies and collects items, and a boss level that serves as the final encounter. This two-level structure is a deliberate design decision rather than a technical one: it gives the player a clear progression arc (work through the main level, reach the boss) and allows the boss encounter to be designed in isolation, with a dedicated arena and camera framing suited to that specific fight.
The transition between levels is triggered by a condition — clearing the main level or reaching a specific point — and uses Unreal’s standard level streaming or level travel to load the boss arena. Keeping the boss in a separate level also allows its assets and logic to be developed and tested independently without loading the full main level.
Tilemap Level Design with Paper2D
Both levels are built with Paper2D Tile Maps — grids of sprite tiles assembled in Unreal’s Tile Map editor. The tileset defines the available tiles (platforms, walls, backgrounds, hazards) along with their collision properties. Collision is configured per-tile in the tileset: solid tiles block movement, one-way platforms allow jumping through from below, hazard tiles trigger damage on contact.
The efficiency of tilemap-based level design is that a single Tile Map Component renders the entire level in very few draw calls — all tiles in the map share the same material and are batched together. Adding detail to a level is a matter of painting tiles rather than placing individual actors, which is fast to iterate and cheap to render.
Background parallax — the illusion of depth in a 2D scene — is achieved by layering multiple tilemaps at different Z depths, with each layer scrolling at a different rate relative to the camera. Foreground layers scroll faster than the midground, which scrolls faster than the background, creating the characteristic depth illusion of classic 2D games.
Player Character and PaperZD Animation
The player character uses PaperZD’s animation state machine to manage its animation states: Idle, Run, Jump, Fall, Attack, Hurt, and Death. Each state is a flipbook sequence played by PaperZD, with transitions driven by the character’s velocity, grounded state, and action flags. The animation Blueprint reads these variables each frame and determines the correct state without any explicit transition code in the character Blueprint — the state machine handles it declaratively.
The attack animation uses PaperZD’s notify system to activate and deactivate the attack hitbox at the correct frames — the same frame-accurate hit detection concept used in the melee combat system project, applied here to 2D sprites. The hitbox is a simple box collision component that overlaps with enemy collision volumes; outside the notify window it’s disabled and deals no damage.
Enemy Archetypes: Melee, Ranged, and Boss
The three enemy types cover the fundamental design space of 2D action games:
Melee enemies patrol a platform section and turn around at edges or walls. When the player enters their detection range, they pursue and attack on contact. The patrol behavior uses edge detection — a downward trace just beyond the character’s feet checks whether ground exists ahead; if it doesn’t, the enemy turns around. This prevents melee enemies from walking off platforms, giving them a natural territorial feel.
Ranged enemies hold position and fire projectiles at the player when within range. They don’t pursue — their threat is entirely through projectile pressure. The projectile is a simple actor with a ProjectileMovementComponent set to a fixed velocity toward the player’s position at the moment of firing. Leading the target (predicting where the player will be) is not implemented, which keeps the projectile avoidable and skill-based — the player can dodge if they react in time.
The distinction between melee and ranged enemy behavior creates natural encounter design in the level: ranged enemies positioned above melee enemies force the player to deal with projectile pressure while navigating close combat. Neither type is threatening in isolation, but mixed encounters create emergent difficulty.
The boss is a single actor with multiple attack phases and significantly more health than regular enemies. Its phase transitions are health-threshold based — the same pattern used in the Bad Bot spaceship prototype — switching attack patterns as health drops. In a 2D platformer context, the boss arena is typically a single-screen space designed around the boss’s specific attack patterns, giving the player readable room to dodge while remaining under pressure.
The boss combines both melee and ranged attack types: at full health it uses ranged projectile attacks; at low health it switches to faster, more aggressive melee charges. This escalation makes the final phase feel like a genuine climax rather than more of the same.
Item Collection
Collectible items — gems, coins, power-ups — are placed throughout the main level. Each is a static sprite actor with an overlap volume that triggers on player contact, applies the item’s effect (score increment, health restore), plays a pickup animation, and destroys itself. The collection counter is tracked on the player character and displayed in the HUD.
Items serve two design roles simultaneously: they reward exploration (placed in off-path locations) and they support pacing (health pickups placed before difficult sections give the player a way to recover). Deliberate item placement is what separates a designed level from a randomly populated one.
Reflection
The 2D action platformer is the most complete game in the Blueprint series — it has a beginning, a middle, and an end, with escalating challenge and a final encounter. Working through a project with this structure builds a different kind of understanding than isolated mechanic demos: the design decisions interact with each other in ways that only become apparent when building something players actually play from start to finish.
The three-enemy-archetype model — melee, ranged, boss — is essentially universal in action games across all dimensions and perspectives. The same archetypes appear in the melee combat system, the zombie FPS, the bad bot shooter, and the survival horror. Understanding how to design and implement each archetype, and how to compose them into encounters, is one of the most fundamental skills in game design.
Nicolás Bertoa 
Leave a comment