Jobert: An Explosive Adventure
Gameplay Synopsis
Climb the mountain, reach the top! Created in Unity, Jobert: An Explosive Adventure is a single-player side-scrolling platformer featuring…
Unique Platforming — Take control of an exhilarating movement system based around using explosions to jump between platforms.
Whimsical Atmosphere — Explore each level as you progress and take in the charming details of their fantastical environments.
Delightful Music — Listen to a soundtrack with musical pieces tailored to complement the mystical experience of each level.
Checkpoints — Reach checkpoints carefully positioned to encourage brave attempts at scaling obstacles while still letting failed attempts be punishing.
Personal Contributions
My contributing role was platforming mechanics engineering. While platforming mechanics was where the majority of my efforts were focused, I also cooperated in the early creative process and contributed notably to the respawn system.
Movement System — I was responsible for programming a high-quality, platforming-based movement system which provides players with simple, intuitive controls and satisfying game feel.
Bomb System — I handled the design and programming of a bomb system intended for use as a platforming mechanic. I made sensible mechanic decisions to flesh out gameplay and allow players to feel properly challenged.
Platforms System — I developed the system behind the game’s dynamic platforms, an addition which served to provide more liveliness and challenge to the levels.
Respawn System — My contribution to the respawn system helped control the quality of playthroughs. Specifically, I ensured respawns upheld gameplay consistency by reverting a level to its exact state at the time the player reached their last checkpoint.
*Not everything in trailer represents my work.
*Art not representative of my work.
Movement System
The movement system is the heart of every platformer. Everybody has played a platforming game at some point in their life, a fact which left our team with a wealth of experience and ideas to draw from. I openly welcomed input from all members of my team to ensure our game met the standards of other well-developed platformers published in the past.
Design Goals
Create a movement system that controls smoothly.
Ability to control movement in the air.
Ability to fast-fall.
Design Process
Since the game is a platformer, I reasoned that much thought and effort should be invested into making it control as smoothly as possible. Even though player movement itself was never planned to be the main platforming mechanic, I still treated it with the level of quality assurance it deserved.
I understood early on that programming acceleration into the movement system was of utmost priority for molding our gameplay into an enjoyable experience. I started off with an approach that utilized built-in engine resources to make the player move with smooth velocity. Upon testing however, it did not feel good to play with because the player was too slippery when stopping, even after using in-engine friction tools. As such, I scrapped it and programmed my own approach using basic delta time calculations to give my team perfect control over acceleration and deceleration. Doing this was the perfect choice since it gave us exactly what we needed to make stopping feel natural.
Overarching movement calculations.
Considering how the game was built around the premise of players launching themselves through the air with explosions, I advocated to include controls for strafing in the air using the A and D keys and falling faster using the S key. My reasoning behind this was that without it, players would be helpless to course-correct after the explosion and the game would be extremely difficult as a result. By letting players have the ability to subtly air strafe and fast-fall whenever needed, platforming became just forgiving enough to remain adequately challenging.
Movement Parameters
The final mechanic to be added into the movement system was coyote time. When I was asked by my team to implement this mechanic, I was completely unfamiliar with it. However, I was not about to let my lack of knowledge get in the way of improving our game. I did some basic research into coyote time to gain a complete understanding of its purpose and importance: a subtle but absolutely necessary quality-of-life mechanic for jumping which player’s are not meant to be cognizant of while playing. Needing no further clarification, I went about developing my own implementation that would fit into the rest of the already existing movement system. Through careful consideration, I accounted for all of the pertinent jump scenarios which a coyote time mechanic should cover. The resulting code functioned exactly as intended. With it working, players now enjoyed leniency for pressing the spacebar slightly too late when jumping off an edge or slightly too early when jumping just as they land on the ground.
Working implementation of coyote time.
Key Takeaways
Self Reliance — Sometimes, game engines might not come built with the right tools or resources needed to satisfy the specifications of a gameplay design. In times like these, it is important for an engineer to be cable of relying on their own skills to make a system or mechanic possible.
Game Feel — When it comes to the design of any system, mechanics should be included or excluded out of consideration for what will best reconcile game feel and the gameplay vision.
Willingness to Learn — There is always plenty to learn when doing something new. To succeed, it is important to invest time into learning unfamiliar concepts and to put genuine effort into your work.
Bomb System
Contrary to expectation, the bomb system serves as the game’s primary platforming mechanic. Players are not only encouraged, but required to utilize bombs to propel themselves across large distances that otherwise cannot be traversed. It is the unique point of gameplay that sets our game apart from others.
Design Goals
Create a system that lets players spawn bombs.
Ability to use these bombs for jumping very far distances.
Ability to spawn two different types of bombs.
Design Process
One of our earliest discussions was what our unique platforming mechanic was going to be. I contributed to this conversation and when we had our idea, I made preliminary comments on the feasibility of programming explosion-focused gameplay.
While coding the explosion knockback mechanic, I considered whether or not it should have a drop off mechanic to complement it. Since programming drop off wasn’t a challenge for me, I experimented with it independently. I observed that drop off made it more challenging to achieve maximum propulsion force from an explosion because it became necessary for players to be right on top of the bomb. Furthermore, they also had to time their jump precisely with detonation to remain as close to the bomb as possible. It was very clear to me that this mechanic added a layer of skill to the game it seemed to be missing up until then. Pleased with the results, I brought it to the team to let them form their own opinions. It was swiftly accepted as part of the game.
Explosion Knockback
The discussion within the team eventually migrated toward expanding the content. For this, we agreed on an idea for a flying bomb that works by using right click. The flying bomb spawns at the player and moves to the position they right clicked with their cursor. It explodes when they right click again, enabling players to pair a normal bomb jump with a flying bomb jump if they line it up right.
Flying Bomb (Not My Art)
I suggested a variety of solutions for how flying bombs should handle collisions while approaching their target position. In the end, we agreed the simplest solution would be to ignore collisions altogether. At that, I programmed the flying bomb to move toward its target position without any regard to objects or the world. Doing my due diligence, I verified that the MoveTowards API method I employed for this was written to never overshoot, making my implementation airtight and safe.
Flying Bomb Functionality
Key Takeaways
Experimenting — If it doesn’t get in the way of development, solo experimentation is a great idea to try opening more doors for gameplay. The right person can discover the right path forward if they are able to be creative.
Straightforward Solutions — It is sometimes unnecessary for a feature or mechanic to cover every conceivable gameplay scenario. In this case, abandoning my robust collision handling suggestions for flying bombs was the right move to remain focused and maximize our development momentum.
Platform System
Dynamic platforms are a timeless feature of platforming games and there was no chance we were going to leave them out of ours. Since this was a feature that the level designers needed to be able to work with, I put some thought into how it should best be set up for their ease of use.
Design Goals
Create a system for dynamic platforms.
Support for moving/crumbling platforms.
Ability for players to stand on moving platforms without sliding off.
Ease of use for level designers.
Design Process
What made approaching this system different from the previous ones was how I needed to consider not only the experience of the end user, but also the experience of fellow developers on my team. Knowing that, I started with the premise of how a dynamic platform should behave. In essence, it should simply move back and forth between two points forever. As such, the ability to easily position these two points was crucial.
Since motion was to be defined by an animation curve, linear interpolation was the natural implementation choice to achieve oscillation. The domain of an animation curve can be defined as 0 to 1, and linear interpolation functions using this exact same domain. I fit it all together by using the currently completed percentage of oscillation time in a frame to derive an evaluation between 0 and 1 from the animation curve. That evaluation serves as the platform’s interpolation position for the frame.
Platform Oscillation
I started by exposing the properties for both points in the inspector. By being able to assign an in-level point to both these fields, our level designers could freely move the points around to control where a platform oscillates. I extended this exposure concept to timing and motion as well. The animation curve field made it very easy to manipulate the movement behavior of a platform, whether it be the normal acceleration of an ease-out curve (as seen in the image) or the stylistic overshoot of an ease-out-elastic curve.
Platform Parameters
The next problem to tackle was how moving platforms would slide out from under players and bombs on top of them. My first attempt at solving this was to parent the relevant objects to the platform when entering contact and unparent them when exiting contact. However, this introduced visual problems when the scale value of both the platform and object was not 1 in every axis. Learning from this failure, I ditched the relativistic approach and adopted a purely kinematic one. I made it so that platforms check for players and bombs in contact with them and directly update their positions to mirror their own movement every frame.
Preventing objects from sliding off moving platforms.
Crumbling platforms were very straightforward for me to implement. If a platform hasn’t crumbled yet and a player or bomb has come into contact with it, then it crumbles after waiting a few seconds. I made the crumbling platform class inherit from the regular moving platform class because they otherwise share identical functionality.
Crumbling Platform
Key Takeaways
Developer-Friendly Systems — If a system fundamentally requires fellow developers to interact with it as part of their role, then it should be designed with an emphasis on intuitiveness so they can work independently and efficiently.
Appropriate Solutions — The best way to find a solution is to strike at the heart of a problem. The problem with moving platforms sliding out from under objects was that the objects didn’t move with the platforms, so I should have started with object movement instead of object parenting.
Respawn System
Wanting to guarantee a consistent gameplay experience, I sought to buttress our already existing respawn system with a state-saving mechanic for moving/crumbling platforms. When a player respawns at a checkpoint, all dynamic platforms are restored to the exact way they were when the player first reached it.
Design Goals
Improve the current respawn system to account for gameplay consistency.
Ability to revert a level back to its exact state when the last checkpoint was reached.
No added maintainability requirements to the already existing system.
Design Process
While developing dynamic platforms, I considered how a playthrough would be affected if a player died and respawned at their last checkpoint. I realized moving platforms would likely be in different positions compared to when the player first reached that checkpoint, which could change the course of their run. But more importantly, I realized crumbling platforms that were triggered would be absent upon respawning, posing a serious problem if a level was designed to require a pivotally placed crumbling platform in order to progress. Recognizing the potential for softlocks or constrained level design, I set about fortifying the respawn system against this.
I modified the respawn system to contain a checkpoint-reached event. My idea was that when the event is invoked, all dynamic platforms subscribed to it will receive the notification to save the data of every property representing their current state.
Checkpoint Updates
The properties that platforms save pertain to if they have crumbled, which oscillation point they last reached, if they are on cooldown before moving again, how far into the cooldown they are and how far into their current oscillation they are. Since I already wrote airtight interpolation code for platforms, simultaneously reverting all these values leaves a platform functioning as perfectly as it did before.
Platform Data
The final step in the process was to subscribe the platforms to the player-death and checkpoint-reached events. By using a publisher-subscriber design pattern, I made it so the system works hands-free without any need for members of my team to maintain it. If the level designers chose to add more platforms, then they would come fully functional as is.
Subscribing platforms to checkpoint and respawn events.
Key Takeaways
Proactive Thinking — It is important to consider whether adding a feature will create consequences for already existing ones. In the case of our respawn system, I successfully identified that dynamic platforms came with negative implications for it and effectuated a robust solution.
System Maintainability — By using an established, conventional design pattern which fits a system’s requirements, maintenance responsibilities can be diverted away from developers and toward the engine where they belong.
End of Portfolio
Thank you for taking time out of your day to review my portfolio! If you started reading from the top entry, then I am glad you found my creative methods and thought processes fascinating enough to make it all the way to the end. I appreciate your interest in my work and I hope you had the pleasure of taking something away from it which you personally found insightful. If you want to see more from me, make a mental note to check back here sometime in the future and see what other game development work I’ve gotten up to.
I hope to hear from you soon!