Embedded Files
Gameplay
Gameplay
I was the primary engineer for Eternal Circus, having worked on the core player mechanics, gameplay systems, level logic, UI implementation, and much more. I used a mix of blueprints and C++ where appropriate, accommodating the game and my teams needs.
Prototype Player Movement
Final Player Movement
Player Movement
Player Movement
Nailing how the player character moves and feels was incredibly important since our game's main focus is to have the player experience being an evasive precise mech. As such, I spent a lot of time polishing the player's mechanics and systems to fit our ideals.
Realizing our ideal movement controls took a LOT of iteration, and a lot of iteration meant a lot of code that needed to be tested. In order to avoid the test code clogging up our game, I made sure to seperate what code could be used beyond iteration and what code was being tested, which mostly just involves making sure there's no heavy references to the test code or that they were wrapped.
Example of wrapper function to replace references to code being tested
Use of time dilation to enhance game feel
Cinematic credits to complete the experience
Cinematics
Cinematics
As a short condensed experience, we wanted to enhance the player to experience a lot of cinematic moments. We used every aspect of the game to push this feeling, using VFX, sound, UI, and more. On the engineering side, I mixed in a lot of time dilation and camera effects to further enhance the experience.
Time dilation was especially tricky to touch, since one of our game's main mechanics involved manipulating time. I wrapped all time dilation effects inside functions and tweens to ensure all of it happens in one place, making it easier to track and manipulate across the code.
Use of tweens with time dilation
UI Engineering
UI Engineering
I worked alongside our UI artist/designer to implement the User Interface for our game, including using Unreal's MVVM Plugin to connect the HUD with our code and using a mix of C++ and Blueprints to create custom widgets
Static function to create or grab the view model
Viewmodel handles all HUD logic
Implementing HUD with MVVM
Implementing HUD with MVVM
I collaborated with our UI artist to implement the HUD. We decided we wanted to try using Unreal's MVVM plugin as a method of connecting the HUD with the game logic through a view model.
By using the MVVM workflow, all of the logic connecting to the HUD only needed to reference the view model rather than needing to directly referencing the HUD element. This cleans up the HUD workflow and made it extremely simple to hook up logic to the HUD.
Although this worked great for us, we ended up having a single monster viewmodel that handled all HUD logic. This means we ended up with a similar problem without VMs where our HUD VM was confusing to work with and was referenced by too many things. Ideally we would want to make seperate VMs depending on the HUD logic needed.
Monster VM for all HUD logic
Options Menu
Options Menu
For the options menu, I used a mix of C++ and blueprints to to divide up the logic. This was a collaborative effort between the me and the UI designer, where I would work off their wire frames and bounce the idea back to them until we were both satisfied. To ensure that UI navigation works with both controller and mouse, I used Unreal's common UI features alongside some custom logic.
Initial wire frame from UI designer
Final implemented options menu
C++ script for an individual option panel
Although theoretically all the logic could have been done in C++, blueprints allowed my UI designer and others on the team to interact with the code. As such I generally restricted my use of C++ to back-end code that supported the front-end implementation done in blueprints.
Implementing C++ events in blueprint
Page updated
Google Sites
Report abuse