Blightspire (currently in progress)

Fps arena shooter made in a custom engine

Project overview

This project is open source, Click here to take a look!

Scope:

Blightspire is an fps arena shooter made in a custom engine over the course of 32 weeks. Our team included 11 people of which 10 were programmers and 1 designer.

Tech Stack & Workflow:

  • Languages & APIs: C++, Vulkan, Wren

  • External dependencies: SteamSDK, EnTT, WrenBind17, FMod, ImGui, stbImage, SDL(windowing and platform abstraction only).

  • Shaders: GLSL

  • Build & Tools: Clion & Cmake, GitHub and Perforce(version control),Codecks (collaboration) and Tracy for profiling.


My Role, contributions, and responsibilities

  • Architected, implemented and maintained the core UI system for our custom engine.

  • Developed key UI elements, including the HUD and Main Menu.

  • Enhanced the engine's resource loading pipeline for improved robustness and integration with the rest of our engine.

  • Collaborated across disciplines, contributing to level design, Being responsible for UI design later in the project and creating our animations.

  • Proactively identified and resolved technical challenges and design conflicts through effective communication and problem-solving.


UI system (Lead & Almost sole Implementer)




Heads-up Display (HUD)

Leveraging the custom UI system, I developed the in game Heads-Up Display. This involved translating design concepts into a fully functional and responsive interface element. Key tasks included:

  • Responsive Layout: Engineering the layout to dynamically adapt and scale correctly across a wide range of screen resolutions and aspect ratios, ensuring a consistent player experience.

  • Data Binding: Integrating HUD elements with the engine's scripting system to accurately reflect real-time game state (e.g., player health, ammo, interactables) through data bindings.

  • Collaboration & Iteration: Working closely with the designated UI designer and incorporating feedback gathered from team/volunteer playtesting sessions to iteratively refine the HUD's appearance and usability.

  • Creating art assets for the HUD: due to our lack of artists I took it uppon myself to make all the art assets for the HUD.

  • responsive Animations: to make the HUD feel dynamic and to convey the information to the player in a satisfying way I developed a simple tween system and leveraged it to create smooth transiitions for the UI elements.


Examples of dynamically driven elements in the HUD

The player can see that status of our "dash charges" on the HUD. when the charge is ready it has a shimmer effect.


when the player picks up health a little green icon along with a green glow around the border lights up.


Dynamic Text rendering


The final HUD in our developer branch (note that a certain screen space effect we employ creates visible artifacts during video compression)


Key Challenge & Resolution: Navigating Differing Design Visions

  • Situation: During development, differing perspectives arose regarding the HUD's layout direction, partly due to team members stepping into design roles outside their primary expertise. These differing views risked compromising the final quality and user experience.

  • Task: My responsibility extended beyond pure implementation to ensuring the final HUD was of the highest possible quality. This necessitated addressing the differing opinions constructively.

  • Action: I initiated and facilitated a focused discussion involving all relevant team members. Each member presented their viewpoint and rationale. I consolidated this feedback, mediating the discussion to arrive at a consensus that prioritized player clarity and aesthetic cohesion. I also offered to prototype multiple variations if the schedule allowed, demonstrating flexibility and commitment to finding the best solution.

  • Result: This collaborative process resulted in several well-considered HUD iterations. The final design achieved team-wide approval and garnered positive feedback from players during testing, successfully balancing various viewpoints to create an effective and well-liked interface. Comparing user response to the previous HUD against the later itteration of the HUD, we saw a clear increase in user approval.


Main Menu

I implemented the game's main menu, providing the primary navigation interface for players outside of gameplay. This involved:

  • Layout & Visuals: Constructing the menu screen according to design mock-ups using the UI system's components.

  • Controller Navigation: Implementing menu navigation using gamepad/controller input, leveraging features built into the UI framework.

  • Functionality: Connecting menu buttons (e.g., "Start Game," "Options," "Quit") to corresponding game logic using scripting callbacks.

  • Designer Collaboration: Maintaining close communication with the UI designer to ensure accurate implementation of the intended visual style and layout, Over time this concept evolved to what it is Implemented in the game right now


The settings menu and controls menu where implemeted through a collaboration with other teammates using the UI framework that I created, this shows the extendability and usability of the Framework.


Key Challenge & Resolution: Addressing Engine Dependencies

  • Situation: Progress on implementing level selection/transition logic within the main menu was temporarily blocked due to limitations in the engine's existing level loading system. The system lacked the necessary flexibility for the menu's requirements.

  • Task: To unblock menu development and ensure a robust solution, the engine's level management needed enhancement, specifically requiring script-driven control over resource loading and unloading on a per-level basis.

  • Action: I clearly identified this technical dependency and proactively communicated the specific requirements (script-driven loading/cleanup via level-specific scripts) to the engineer responsible for that engine module. While awaiting the necessary engine updates, I strategically pivoted my focus to other implementable UI tasks to maintain development momentum.

  • Result: The responsible engineer integrated the requested functionality in the subsequent development sprint. This not only unblocked the main menu implementation but also resulted in a more modular and robust level management system for the entire project, benefiting future development.


Resource Loading Pipeline Enhancement

I made significant contributions to improving the engine's resource loading pipeline, focusing on enhancing its reliability and integration with the overall architecture. Specific areas of focus included:

  • Better seperation of concerns: changed the resource loader to output intermediate data which can be transofrmed into the wanted form by other engine systems.

  • GPU Resource Creation: Implemented systems for creating gpu resources from this intermediate data(textures, meshes, models, and materials).

  • Integration & Robustness: Worked to ensure the loading process was less prone to errors and integrated smoothly with other engine systems that rely on loaded assets. This resulted in increased developer velocity later on in the project in multiple areas including but not limited to:

    • GLTF animation parsing

    • NavMesh creation from imported meshes

    • Creating collision data from imported meshes


Cross-Disciplinary Contributions

Beyond core programming tasks, I actively participated in other areas of development, including contributing ideas and efforts towards level design and creating animations. This provided valuable context and a broader understanding of the game development process.