'We felt a strong desire to pay tribute to the game that had been such a significant part of our studio's journey.'
Game Developer Deep Dives are an ongoing series with the goal of shedding light on specific design, art, or technical features within a video game in order to show how seemingly simple, fundamental design decisions aren’t really that simple at all.
Earlier installments cover topics such as developing a rating system and making juicy TV in The Crush House, the development of custom tools for the 2D photo mode of A Highland Song, and refreshing the Crusader Kings III tutorial mode through optimized UX.
In this edition, the team behind The Cycle: Frontier tell us about their decision to recreate the game in Fortnite and how they addressed the technical challenges along the way.
Hi, we are producer Alexandra Norman, senior technical designer Michał Lorczak and senior technical designer Guillermo Ortega at YAGER, and we're here to share our team's experience of adapting The Cycle: Frontier to Unreal Editor for Fortnite (UEFN).
In September 2023, we made the difficult decision to sunset our beloved extraction shooter The Cycle: Frontier. It was a bittersweet moment for our team and our dedicated player base. As we closed this chapter, we felt a strong desire to pay tribute to the game that had been such a significant part of our studio's journey.
As an exclusively Unreal-focused studio, we saw an opportunity in UEFN to keep the spirit of The Cycle: Frontier alive while exploring new technological frontiers. As a small but highly skilled team at YAGER, we took on the challenge of evaluating this new platform's potential. Our core implementation team consisted of senior technical designer Michał Lorczak, senior game designer Guillermo Ortega, QA PC coordinator Sarah Junger, principal/lead technical designer Oliver Stubenrauch, and producer Alexandra Norman.
This dedicated group worked on the project for approximately four months. Additional resources, including tech artists, animators, and QA, were brought in on an as-needed basis, typically for periods of one to two months, to provide specialized expertise and support. All team members, even those in non-implementation roles, contributed to the hands-on development of the project.
This lean, agile team structure allowed us to remain focused and efficient, while still having access to the diverse skill sets necessary for such an innovative project. Their combined efforts and expertise were crucial in navigating the unique challenges and opportunities presented by UEFN.
Our goal was ambitious yet focused: to bring as much content and spirit from The Cycle: Frontier to UEFN as possible, resulting in what we now call The Cycle: Prospect Island.
This project was as much about research and development as it was about game recreation. Our primary goal was to thoroughly explore the capabilities of UEFN, pushing its boundaries to understand what's currently possible within this framework. We were particularly interested in identifying which features might potentially make their way into future versions of Unreal Engine. By attempting to capture The Cycle: Frontier's tense extraction gameplay, risk-reward mechanics, and immersive world within UEFN, we gained valuable insights into both the constraints and innovative possibilities of this platform. This approach allowed us not only to pay homage to The Cycle: Frontier but also to position ourselves at the forefront of understanding and leveraging emerging game development technologies.
Image via YAGER.
Our journey with UEFN has been filled with both exciting discoveries and significant challenges. In this postmortem, we'll dive into what went right, what went wrong, and the valuable lessons we learned along the way. Whether you're a developer considering UEFN for your next project, a The Cycle: Frontier fan curious about its afterlife, or simply interested in the evolving landscape of game development, we hope our experience provides valuable insights.
Let's begin by exploring what went right in our UEFN adventure...
One of the most significant advantages of UEFN was the speed at which we could prototype and iterate on our ideas. The system's built-in devices and intuitive event system allowed us to quickly set up basic gameplay elements that resembled The Cycle: Frontier's core loop. This rapid prototyping capability was particularly useful when we were trying to adapt complex The Cycle: Frontier mechanics to fit within UEFN's framework.
For instance, when implementing our extraction mechanic, we utilized UEFN's existing storm system. While we couldn't fully customize it to match The Cycle: Frontier's extraction zones, we managed to create a workable solution by placing three "safe spots" within the storm. This ability to quickly implement and test ideas allowed us to maintain a good development pace despite the limitations we faced.
UEFN's integrated systems for version control, build pipelines, and playtesting were a pleasant surprise. Getting new team members up and running was quick and painless, which was crucial for our collaborative effort. The ease of submitting unpublished islands to Fortnite servers for testing was particularly valuable. It allowed us to test our creation in a real multiplayer environment with minimal setup, something that would have been much more complex and time-consuming in a traditional development pipeline.
Moreover, the ability to make certain changes on the fly during playtests was a significant advantage. This feature allowed us to rapidly iterate on design elements, tweaking values and settings without needing to go through a full build and deploy cycle.
UEFN's built-in optimization tools were a standout feature. With just a few clicks, we could reduce texture sizes, build HLODs, and measure memory consumption. This streamlined process ensured that our island would work well across all platforms, including mobile devices, without requiring extensive manual optimization work from our team.
This aspect of UEFN was particularly impressive, as optimization is often a time-consuming and complex part of game development. The fact that we could achieve good performance across platforms with relatively little effort allowed us to focus more of our time on adapting The Cycle: Frontier's gameplay to the Fortnite framework.
Image via YAGER.
The most significant challenge we faced was the limited ability to customize existing Fortnite functionality, the lack of access to underlying code, and that BP scripting was not possible. This limitation became apparent when we tried to implement core The Cycle: Frontier mechanics that didn't have direct equivalents in Fortnite.
For example, we wanted to create custom lootable containers, a staple of the extraction shooter genre. However, UEFN doesn't allow customization of what lootable containers contain. As a workaround, we had to place items directly on the map, which wasn't ideal for the gameplay experience we were aiming for.
Similarly, when adapting The Cycle: Frontier's NPCs, we could only use existing Fortnite AI behaviors. We couldn't modify crucial aspects like damage output or behavior trees. This meant that our NPCs, while visually reminiscent of The Cycle: Frontier's, behaved more like standard Fortnite characters.
Importing assets from our original Unreal Engine project into UEFN proved to be more difficult than anticipated. While basic elements like meshes and textures imported without much trouble, we ran into significant issues with materials. Our The Cycle: Frontier project used a lot of custom material functions that were incompatible with UEFN, often resulting in crashes.
This limitation forced us to rebuild much of our environment using Fortnite assets. While this ensured better compatibility and performance, it also meant that our UEFN version of The Cycle: Frontier looked and felt more like Fortnite than we initially intended.
The limited debugging features in UEFN posed a significant challenge for our development process. Without access to breakpoints or comprehensive logs, tracking down and fixing bugs became a much more time-consuming process than we were used to.
This limitation was particularly frustrating when dealing with more complex gameplay systems. We often had to rely on print statements in Verse (UEFN's scripting language) as our primary debugging tool, which was far less efficient than the robust debugging capabilities we were accustomed to in full Unreal Engine development.
Image via YAGER.
Our journey with UEFN to adapt The Cycle: Frontier was filled with both exciting possibilities and significant challenges. While UEFN's rapid prototyping capabilities, streamlined DevOps, and built-in optimization tools allowed us to quickly bring a version of The Cycle: Frontier to the Fortnite ecosystem, the limitations in customization and debugging made it challenging to fully realize our vision.
Despite these hurdles, we managed to create an experience that captured the essence of The Cycle: Frontier within the Fortnite framework. This project taught us valuable lessons about working within constraints, finding creative solutions, and adapting our development processes to a new environment.
As we look to the future, we're excited about the potential of platforms like UEFN to bring unique gameplay experiences to wider audiences. While it may not replace traditional game development for complex, custom games, it offers an intriguing middle ground for developers looking to leverage existing game ecosystems.
Our experience with UEFN has given us new perspectives on game development and content creation. As these platforms continue to evolve, we look forward to seeing how they will shape the future of game development and player creativity.
You May Also Like
