KnightLight

2D Puzzle Platformer Built in a Custom C++ Engine

Custom C++ Engine • JSON • Custom C# • Systems Design • UX • QA

About the Project

KnightLight is a 2D puzzle platformer built from scratch by a 7-person team in a custom C++ engine. As Design Lead and Systems Designer, I helped redefine the project’s scope into a focused puzzle experience built around a dual-form mechanic where the player switches between Light and Knight.

I prototyped the player controller in Unity, as well as designed and implemented multiple core gameplay systems, including the flash ability, lamp-door puzzle logic, checkpoint torches. the armor recall system, and pipe traversal network. I also implemented visual guidance systems to maintain readability in the game’s dark environment and ran regular playtests to iterate on mechanics and player feedback.

Project Details

Goal: Create a cohesive and enjoyable experience within an evolving custom engine.

Role: Design Lead, UX & Systems Designer, QA
Engine: Custom C++ Engine
Team Size: 7
Duration: 9 months
Year: 2023 - 2024

Contributions

Design Direction

Helped refocus the project from a metroidvania to a puzzle-driven experience.

Core Mechanic Design

Designed the Knight / Light possession mechanic.
Prototyped and refined the player controller in Unity.

Systems Design

Flash interaction ability
Lamp–door tag pairing system
Checkpoint torches and armor recall
Pipe traversal network
Hazard proximity glow readability system

Playtesting

Organized playtests and authored 12 playtest reports.
Iterated on controller feel and mechanic feedback.

Custom Engine Collaboration

Because the project was built in a custom C++ engine that was still evolving during development, implementing gameplay systems required close collaboration with programmers. Mechanics initially prototyped in Unity were later recreated in the custom engine and adapted to its architecture and tools. This process required frequent iteration as the engine’s capabilities expanded.

Core Mechanic: Knight and Light Separation

The central mechanic of KnightLight allows the player to switch between two forms: Light and Knight.

The player primarily controls the Light, a small mobile entity capable of navigating tight spaces and interacting with puzzle elements. When Light encounters an abandoned suit of armor, it can possess it to become the Knight.

This transformation changes how the player interacts with the environment. The Knight has limited mobility but can safely traverse hazards that would destroy Light.

Video of the player moving around as Light

I designed the Knight / Light possession mechanic that forms the foundation for the game's puzzle design.

Light Form

Fast and mobile
Can navigate tight spaces
Uses a flash ability to illuminate areas and activate lamps

Knight Form

Slower but durable
Can safely traverse spike hazards
Can launch Light across larger gaps

Gameplay Loop

Most puzzles follow a simple loop:

Explore as Light to scout the environment and activate lamps
Equip the armor to become the Knight and traverse hazards
Separate again to continue exploring and solving the puzzle

This repeated transformation between forms forms the foundation of the game's puzzle design.

Mechanic Expansion: Armor Launch Upgrade

Later in the game, Light gains the ability to launch upward when exiting the armor.
This upgrade expands the core mechanic into vertical traversal puzzles while maintaining the same core interaction of entering and exiting the armor.

Gameplay Systems

To support the core mechanic, I designed several systems that structure puzzle interactions and environmental progression.

Flash Ability

Light emits a short burst of illumination used to navigate dark areas and activate lamps. This became the primary interaction method for puzzle elements.

Lamp and Door Pairing

A tag-based system that links lamps to specific doors. When activated by Light’s flash, the paired door opens, creating clear cause-and-effect puzzle interactions.

Checkpoint Torches and Armor Recall

Torches function as checkpoints and anchors for the armor recall system. If the armor becomes separated, the player can recall it to the nearest activated torch.

Pipe Traversal

A network system that allows Light to travel through pipes using directional tags, enabling traversal puzzles and hidden routes.

Guidance and Readability

Because the game takes place in near-complete darkness, readability was a major design focus. I implemented several systems to help players identify objectives, hazards, and progression paths without breaking the atmosphere.

Signiflyers

Small glowing fireflies that act as collectibles while subtly guiding players toward important paths and puzzle elements.

Hazard Proximity Glow

Spike hazards gradually glow red as the player approaches them, ensuring hazards remain visible even in dark environments.

A similar glow system was also used for dialogue interactions to clearly communicate interactive objects.

Feedback Iteration

Playtesting revealed that some actions, such as recalling the armor, were not always immediately clear. I iterated on visual and audio feedback to better communicate when the recall action had triggered and where the armor would reappear.

Video showing armor recall without light effects

Video showing awesome finalized armor recall in action

Prototyping and Custom Engine Transition

Gameplay systems were initially prototyped in Unity while the custom engine was still under development. This allowed mechanics and puzzle interactions to be tested quickly before committing to implementation.

Video showcasing one of the Unity prototypes, maybe the new player controller one

Once the engine stabilized, these mechanics were recreated inside the custom C++ engine and adapted to its custom tools and components.

Video showing other prototype

Video showing prototype content finalized in-engine

Because the engine continued to evolve during development, many systems required iteration and close collaboration with programmers.

To support future designers, I co-authored an Engine Design Guide documenting how we used the engine’s tools to implement gameplay systems and build levels.
(If you're interested in seeing this documentation, feel free to reach out.)

Linked capsule for the Engine Design Guide

Playtesting and Evaluation

Playtesting was conducted regularly across both semesters to evaluate player experience and gameplay clarity.

Screenshot of a written playtest report

I organized testing sessions, recruited participants, and authored 12 playtesting reports documenting player behavior, usability issues, and technical problems discovered during testing.

These playtests focused on:

Player controller usability
Mechanic clarity
Environmental readability
Puzzle interaction flow
Custom engine stability

Findings from these sessions directly informed improvements to feedback systems, mechanic clarity, and overall player experience.
(Detailed playtesting documentation is available upon request.)

Outcome

• Released on Steam as a fully playable student project
• Completed over 9 months by a 7-person multidisciplinary team
• Successfully transitioned gameplay prototypes from Unity to a custom C++ engine during development

Lessons Learned

KnightLight was my first experience designing gameplay systems within a custom engine while collaborating closely with both programmers and another designer.

The project reinforced the importance of:

Maintaining a strong core mechanic
Adapting design to technical constraints
Using player feedback to guide iteration

Focusing the design around a single mechanic ultimately allowed the team to deliver a more cohesive and polished puzzle experience.

Video or screenshot of the final game

Play KnightLight on Steam

[Steam Page Link]

Linked capsule for the Steam page