Portfolio
PROJECT
TOOLS
Video Game: Samsara
Unreal Engine, Hansoft, Flowchart, Discord, Niagara Particles, Blueprints, C++, Perforce, Visual Studio, ACF Framework.
DESCRIPTION
As a freelance developer for Infinity27, I worked on the documentation (UML/Flowchart designs) and the technical art and C++/Blueprints of 3 spells.
FREELANCE
03/06/2024 - 03/09/2024
BOOTCAMP
03/04/2024 - 03/06/2024
GENERAL OVERVIEW
Green Tara's Light:
-
A homing missile seeking system for the orbs to target the enemy.
-
Trigonometrical orbiting system, so the orbs no matter the count surround the player.
-
Vector length comparison to detect collision distance between enemy and orb.
-
Dynamic material for orb fading.
-
Niagara particles to surround the orb for improved visuals.
Arrowstorm Inferno:
-
Recursive explosion system so it chains amongst enemies.
-
Vector length comparison to detect collision distance between enemy and orb.
-
A homing missile seeking system for the orbs to target the enemy.
-
Niagara particles for flames around the arrow mesh.
GREEN TARA'S LIGHT
ARROWSTORM INFERNO
ROLES & RESPONSIBILITIES
-
Design the UML/Flowchart of the spells.
-
Develop the Blueprint and C++ version of the spells.
-
Showcase and discuss the work with senior developers.
-
Handle the Hansoft tasks and Miro board for the spells.
-
Plan the roadmap/sprints for the spells completion.
-
Complete LOF0 to LOF3 checks to show progression.
TECHNICAL & INTERDISCIPLINARY SKILLS
-
During my freelance and bootcamp work at @Infinity27, I demonstrated a range of technical skills, such as using C++, Blueprints, adhering to coding standards, the use of source control (Perforce), game maths, optimisation, testing, debugging, code design, and iterative development.
-
I also showcased a range of interdisciplinary skills: excellence in communication among team members; research skills to design spells around the culture and time setting; problem-solving by retrieving and applying the information required to fix bugs or improve user feedback for my spells; collaboration through presenting my spells, interpreting feedback, and clearly communicating ideas and implementation intentions; the use of agile practices by working within the framework and applying iterative and incremental development; version control using Perforce; remote working by using common remote working tools; time management by logging information in Hansoft, attending meetings, and scheduling work accordingly; documentation by creating UML and flowchart diagrams; and project management by using LOF checks and Hansoft to manage the stages of work effectively.
Code review
Firstly, I'd like to state that intellisense is broken for the Parsec machines.
The code in the screenshot below returns values for the spell "Green Tara's Light".
The "GetWisdomValue" returns the wisdom value from the "UARSStatisticsComponent" class using gameplay tags.
"CalculateDamage" returns the value from a math scale system, which allows for the damage to curve with diminishing returns by using the wisdom value.
"CalculateOrbTotalToSpawn" depending on the total wisdom, the orb total to spawn for Green Tara's light, which in the next snippet of code is used to determine how the orbs should be placed via offset and angle so the orbs surround the player.
The code below showcases the use of degrees to radians and trigonometry to calculate the position and distance between each orb so they can orbit the player's position.
UML OVERVIEW
Here are the UML diagrams of "Green Tara's Light" & "ArrowstormInferno".
2 MONTH BOOTCAMP @Infinity27
Before I started the freelance work for Infinity27, I did a bootcamp with them for 2 months to improve my professional skills as a developer with Unreal Engine 5 & C++/Blueprints. I earned a 91% pass for my efforts.
.png)
THE "ARROWSTORM INFERNO" STORY AND OVERVIEW
General Overview:
Four flame arrows spawn one after the other, and if they find a target they will act like a homing missile, and if the final arrow collides with a target it causes a recursive chain of explosions.
I was inspired by Baldur's Gate flame arrow, and wanted to improve upon that spell with the recursive explosions and multiple arrows being used for the cost of one spell.
Context:
In Buddhist mythology, fire represents a purifying force that eradicates all evil and impurities. This is often linked to the intense suffering associated with the hellish realm of Naraka.
The spell having a recursive nature symbolises the cycle of rebirth and karma. For each explosion occurring one after the other, can be seen as a chain of cause and effect, also known as karma, which represents the cycle of suffering amongst beings.
Communication & Problem Solving:
One of the biggest issues I came across was that the homing missile component wouldn't work for collisions on enemies, so the team lead (Nathan) and I spent quite some time together changing collision channels. Eventually I made my own homing missile maths in Blueprints to change the rotation and velocity of the arrow to the target, and still the issue was present.
Eventually I came up with a solution to just go through all the arrows and targets locations and compare their vector lengths to fake collisions.
Another issue Nathan and I had was setting the homing component with a USceneComponent, since the offsetting was quite strange to implement, but eventually I got it to work.
Collaboration:
I spent some time with Chris from the level design bootcamp branch giving feedback on their level, who in return gave feedback on my spell. We both gained valuable information on one anothers work.
From a few conversations with other people in the group too, I concluded that the arrows shouldn't return to the player after colliding with their target, since it may confuse the player, so that feature was removed.
Nathan also made a suggestion on recursive explosions, so that was added to increase the depth of my spell's gameplay mechanics.
Agile Methodology:
I split the spell's features across different stages of importance and overtime developed the spell until each LOF check was approved by the lead developer.
Remote Working & Source Control:
We worked on our project remotely for the entire bootcamp, which meant we had to have the discipline to work on our spell, documentation and join meetings ourselves.
In this bootcamp we used Perforce for source control.
The main thing about using Perforce was to make sure our notes were descriptive for what we had done, as well that they kept a consistent pattern such as using our Name and referencing what we worked on.
Optimisations & Testing:
To reduce the spells memory I made soft references to the particles, sounds and the manager
class. I also ended up using the homing missile component instead of my own system since it was already there to use.
The CPU and GPU time only increased by a few milliseconds or so during the spells usage.
Which means my spell shouldn't have too much of an effect on the games performance.
During testing I set the max focus to a high value so I could keep repeatedly using my spell.
When creating my spell in Blueprints, I initially had some bugs to do with the arrays for checking distance and moving the projectile to the target, which I eventually fixed by testing with debug statements.
Code Design:
The code for my spell and manager class was designed so no circular dependency occurred, which essentially means the spell can speak to the manager, but not back around again
The manager then handled the arrows collisions, target setting and the recursive explosion system.
Iterative Design:
The development cycle started with creating the overall idea of the spell, requirements, blueprint version and finally the C++ version.
How the spell was developer overtime:
creating the basics of the spell, then spawning the arrows, refunding or assigning targets to the arrows, applying visual and audial effects for refunding or explosions, adding the explosion system, and finally optimising the spell by reducing its size map.