Email:
jesusromandisini@gmail.com

Contact No:
+1-425-403-5303

Links:
LinkedIn Resume

During my internship with Taktyl Studios, I was tasked with creating a prototype for a character action game in Unreal Engine. This prototype was made to help pitch a video game based on an award winning Filipino graphic novel, and was also to be included as part of an initiative towards preserving the national martial art of Arnis.

I was responsible for programming the core functionality of the game and piecing together the whole prototype using guidelines, design documents, and art assets provided to me by the studio.

For this prototype I implemented:

• player locomotion with the ability to walk, sprint, jump, and vault over ledges
• combat with light and heavy attacks and a variety of special moves
• enemy AI using behavior trees with attacks controlled via animation notifies
• a global enemy encounter controller and token system to control encounter difficulty

I paid attention to code cleanliness throughout this project, and also focused a large part of my efforts on implementing features in ways that could easily be modified by designers without having to interface directly with implementation.

As mentioned above, attacks are handled via animation notifies that can be attached directly to the enemy and player attack montages. This system allows for designers to easily modify variables like an attack's damage and range without having to directly open an enemy's blueprint class. Being attached directly as an animation notify also allows for precise timing with animations that can easily be modified in the event that an attack animation is replaced or retimed in some way.

Player attack combos are also stored in a tree styled data structure with each attack having references to various "next" attacks depending on the next player input. This system was made to enable designers to easily create and modify different combo strings of heavy and light attacks plus pause combos without having to directly deal with the underlying blueprints.

I designed everything this way so that, in the event that the project gets greenlit, this prototype could be used as a workable base for other programmers and designers to work off of.

Throughout the project, I communicated with a designer to ensure an overall level of quality and adherence to the requirements. I was also monitored closely by higher-ups in the studio to ensure a consistent rate of progress over the time that I had to create the prototype.

HexenHold is a tower defense game where players defend an evil necromancer against ghosts and monsters as they try to disrupt the ritual. The game fuses tower defense gameplay with platforming elements, requiring players to run and jump around the stage placing towers and throwing enemies away from the necromancer.

I worked on this game as a member of Hazard Stripes Productions, an interdisciplinary team formed during my sophomore game class. A large part of my time was spent working and communicating with designers, and figuring out ways to make our engine tools more robust and accessible to allow for their expertise to truly shine. This project greatly helped my development both as a programmer, and as a team player.

HexenHold was developed using a custom engine written in C++ and utilizing OpenGL for graphics rendering. The engine made use of the ECS architectural pattern, where components are stored in individual cache coherent containers and read by systems that governed all functionality in the engine. This was done for learning purposes, as well as to improve performance to facilitate the large waves of enemies typically expected of a tower defense game.

I programmed the OpenGL 3.3 graphics backend using GLFW. The engine can display, rotate, and scale textured quads and has support for additive blending for certain lighting effects. I also implemented various structures to contain and serialize sprite data in order to make modifying and interfacing with this backend as user friendly as possible.

I also created a basic in-game ImGui editor with the ability to move and spawn entities on command, and modify specific entity attributes on the fly. This was created to help programmers and designers iterate on ideas faster without having to modify the engine code.

I implemented a frame based animation system to allow for easier implementation of sprite-sheet based animations. Animation data is serialized in JSON format to allow for ease of use.

Using this implementation, I created a proper animation editor that allowed designers to create and edit animation timings while previewing them in real-time. This editor took a lot of inspiration from the Unity animation editor, as it was what our designers were most accustomed to at the time. Over the course of the project, I updated and maintained this editor, modify and adding features according to feedback from the team's animator and sprite artist.

I implemented an enemy wave editor to allow our systems designer to more easily iterate on the balance of enemy encounters in levels without having to directly interface with JSON files.

I also implemented Tiled integration, allowing levels created in Tiled to be exported as JSON files and read into the engine as level data. the engine supports placement of background tiles, color tints and parallax for individual layers, and the placement of entities into the level using Object Layers.

These features allowed our level and systems designers to more easily create and iterate on levels.

I implemented a lot of other miscellaneous systems for the engine, most notably a basic "tagging" system which allowed for strings to be attached to individual entities, which proved quite useful for implementing things like filtered collisions and projectile targeting.

I worked on other gameplay related functionality such as player control, enemy behaviors, and throwing interactions alongside our other gameplay programmer.

In addition, I handled implementation of the in-game tutorial to the custom engine, porting over functionality from the rough prototype created by the designers.

I also handled the implementation of a number of menu interfaces throughout the game, such as the in-game pause menu, and options menu.

I was the one responsible for editing together the game's trailer video, and also took it upon myself to compose all the original music heard in-game and in the trailer.

For the steam version of the game, I primarily worked on implementing controller support.

The Children Are Sleeping is a 3rd person stealth horror game about a kid escaping a nightmare while being chased by a horse-like monster and grappling with the trauma of losing her father in war.

This game was developed in Unreal Engine 5. This project is more narrative driven than most of my previous team efforts, so many decisions end up being made by art and design, with tech having to adjust more to the ever changing requirements. As such, a lot of my time was spent figuring out ways to better support the needs and ambitions of our design team.

I worked on this game for my junior game project alongside a team of 12 designers, artists, and other programmers.

I implemented a lot of the core mechanics of the game including the sanity/health mechanic that relies on light, and the basic stamina mechanics.

I also created a large portion of the player controller, with major functionality being controlled using C++.

I collaborated heavily with our AI programmer to implement new gameplay features to the monster such as the ability to hear sounds from the player or the environment and immediately moves towards them to investigate. I added in a throwable item mechanic to allow players to utilize this aspect of the monster to their advantage by making a sound to get it to move out of the way.

I was responsible for implementing many UX improvements based on play-tester feedback, such as a light in the eyes of the monster that shows its cone of vision, and changes color when it sees the player.

I also implemented the point and click puzzle interface that facilitates much of the game's progression. It interfaces with the player's inventory, dynamically showing and hiding individual pieces depending on collected items. The system was designed to be inuitive for designers to work with, with movable pieces having a "key" attached which has a corresponding "lock" on a slot. If all keys are in the right place, the puzzle is registered as solved. This allowed for our designers to quickly conceptualize, implement, and iterate on different puzzle concepts.

I implemented a myriad of menus for the purposes of player experience including the inventory checklist screen, the dynamic map screen with fog of war, the note glossary, and others, in collaboration with the team's artists and UX designer to ensure a high level of quality and usability.

Early in development, the design called for the ability to carry and drop items across levels to solve puzzles. To achieve this without making too many changes to our designers' workflow, I created a scene persistence system which could save relevant actor data for each level upon exiting, and load that data when re-entering the same room. This allowed the player to hold onto and move puzzle related items and keys around rooms without losing progress. The system also allowed for items to be brought between different levels to enable designers to create more complex puzzles that would require bringing physics objects back and forth between areas of the map. The system was designed to require as little manual input as possible, allowing designers and artists to create props and puzzles without having to worry too much about the underlying functionality.

In addition to my role as a programmer, I was also the game's Audio Lead and the sole sound designer of the team. All the game's sound effects and ambience were mixed and mastered by me. I composed most of the music in the game, consisting currently of the title track, game over theme, and monster chase theme. I also arranged the credits song in collaboration with our producer.

I am particularly proud of the final chase sequence, for which I did both the programming and sound design for, and collaborated closely with our environment artists to conceptualize and bring to life.

We are currently on the way to bringing the game to steam.

This project is a top down 2D action game inspired by Ultrakill and CrossCode. I created the prototype during the summer of 2024 in the Godot engine, and have been working away on it in my free time ever since.

I created this mostly as a passion project, and to refine my skills as a solo developer after primarily working on team projects for two years. I was inspired by games that I had been playing at the time, and with nothing to do over the summer, thought to try and see how my skills had improved since I started college.

I also took it as an opportunity to better learn the Godot Engine, a project that I had been keeping an eye on for a while. I believe this project helped bolster my general confidence and skill in all aspects of game development and reignited my passion for creative expression through games.

As this was a solo project, I was responsible for all aspects of development.

As the focus was on melee combat, I made sure to implement attacks and damage to be as modular as possible. All attacks are stored as custom resources (the Godot equivalent to Unity's serialized objects) that contain stats like damage, knockback, and ideal distance, and a reference to an animation to play on the attached actor. The actual triggering of attacks as well as cooldown timing is handled using the animation system, which allowed for me to precisely time frame data to animations. These attack objects are placed in a "combo" container, which allows for easy sequencing of attacks to be used both by the player and enemies. This system allowed me to easily iterate on enemy behaviors, as creating new attacks and modifying existing ones was as easy as changing some values in the inspector.

Enemy AI is handled as a finite state machine, with enemies switching between getting in range of the player and executing attacks. Enemies store a weighted table of attack patterns that can be edited in the inspector.

For testing purposes, I also implemented a basic telemetry system, tracking the time and specific events relevant to gameplay. This system allowed me to more quantifiably gauge things like which encounters players would get stuck on or spend too much time in, as well as diagnose any potential bugs if the data doesn't seem to behave as intended.

I made a point to focus on the user experience, adding in features like hitstop and dynamic camera zooms to make combat feel as satisfying as possible.

I created all character and monster designs, as well as all art assets used in the game. I made use of Blender to model and animate 3D characters and environments to speed up the development process, and rendered them as low resolution sprites with an amount of color filtering applied to achieve my desired art style. I also made significant use of Godot's 2D lighting system to provide a more atmospheric and dynamic feel to the visuals.

I composed and mixed the background music used in the demo, making use of an array of free VSTs to achieve my desired sound.

Interdimensional Tactical Chess is a two player chess game played across four boards, each board being a parallel game of chess. Players have the ability to transfer chess pieces from one game to the other, allowing for unique and mind bending tactics. Whoever wins the most boards wins the game.

I worked on this project alongside three other programmers as part of team MagiCats.

Interdimensional Tactical Chess was developed in a custom engine using a rudimentary graphics library provided by the university that was written in C.

I implemented all gameplay interactions with the chessboard, allowing players to examine and move chess pieces through and across boards. I was also largely responsible for UI implementation. I created move overlays, allowing players to see all valid moves both within the current chessboard, and across all parallel games, and handled dynamic drawing the internal chessboards onto the screen with tiles.

I handled implementation of audio using FMOD Core and created a handful of icons like the capture and move icons.

Pillbugs Tower Defense is a tower defense game where players must use acorns to defend a tree from waves of hostile pill bugs.

I worked on this project alongside three other CS students as member of Untidy Judgement. The game was developed as part of my first semester in Digipen Institute of Technology in Fall 2022.

PBTD was developed over the course of 4 months using CProcessing, a C based port of the Processing graphic library.

Synthesized Anxiety is a narrative focused turn based game that chronicles the story of Clef, a socially awkward music enthusiast who, against all odds, has found himself in the middle of the largest party in town. Time passes as more people approach him, each one proving to be a challenge for the natural shut in. The night is still young, and it's only a matter of time before everything melts down.

The game's mechanics and battle system were specifically designed to simulate the feeling of conversation for someone with anxiety, and was largely based on my own experience dealing with autism and social anxiety.

The goal of the game is to maximize your social status resource.

Each turn, you're given a dialogue prompt from a character and are able to verbally respond or react. You lose or gain social status based on if your response was socially acceptable. Certain responses will increase your stress meter, which if filled will cause a mental shutdown to occur.

During a mental shutdown, the current prompt will be garbled, making choosing an appropriate response more difficult. The player loses if they have 3 mental shutdowns.

Stress can be relieved by stimming once per turn. Each stim has a random chance of being noticed by your conversation partner, which can cause you to lose social status.

The game was developed using Unity.

I was responsible for all the original music in the game as well as all art and UI assets.