Hi, welcome to Mix and Jam, a channel about game development experimentation. Today's project is inspired by the game The Pathless. The gameplay of The Pathless involves an incredibly smooth movement system where the hunter can shoot arrows into targets to build up stamina which allows the player to run faster. The game feel here is fascinating and as a game developer I want to try my best to recreate the basic movement in arrow mechanics using the Unity Engine. So let's break down the main components needed for this recreation. First, we have the basic third person controller which provides the player with simple movement and the ability to adjust the camera. Then, there's a target system responsible for the selection of visible targets and the display of the user interface. There's also the arrow mechanic which determines the release precision for the arrows and also manages the stamina that allows the player to run. Next, we have some procedural animation work which dynamically changes the character's facing direction and modifies the placement of the bow and arrow. And finally, we have all the different visual effects and game-fuel details to wrap up the experience. I began by creating a new project in Unity and importing Gemmo, the official character from the channel into the project. I added a simple jump logic to the character by detecting the duration of a button press in order to build up vertical velocity. Then I started working on the target system. I placed a bunch of objects in my scene as my targets and each one of them has a script that uses the on-became visible function to add itself to a target list. At that point, I created some logic to compare the distances from the targets to the center of the screen to determine which one to focus. In afterwards, I replaced the visual of the targets by creating an image that closely resembles the graphics from the game. Next, I started looking into the arrow projectile system. While playing the actual game, I noticed that the arrows would wiggle in the air a little bit. This gave me the idea to use particles as the actual arrows. And by using the particle system, I was able to set gravity and noise values to release the arrow in a trajectory similar to the game. Then I used the mesh emission instead of billboard to render a 3D model. And for the actual mesh, I went to Sketchfab and downloaded a simple arrow model made by Tesla. And since I was in the website, I also downloaded this bow model created by GW1P. To determine the precision at which the arrow is released, the player has to press and hold a button that builds up a meter visible on the target's position. There are 3 possible states for the arrow release. And the meter is fully charged, which guarantees a hit on the target but takes a while to load. When the meter has been released too early, which launches the arrow with bat precision. And when the meter is half charged, which guarantees the hit and takes less time to load, but creates this risk reward situation because you have to release precisely in the middle of the meter. Otherwise you will just miss and have to wait for the cooldown. To implement the indication of the arrow precision, I created a UI slider that uses the Radio360 fill method instead of the default horizontal filling. This allows me to slowly review a color that then I can mask inside of this diamond shape similar to the game. Then I used the value of the slider to determine which arrow particle emission I would use. If the release wasn't full or half charged, I would just emit a particle from the player's reference point. This emission uses a cone shape that sets a random launch direction for the arrow, which in most cases would make you miss the target but it would still give you a chance to land the hit if you were close enough to it. However, if the player releases the arrow in one of the two success points, I made it so that the particle object places itself at the target's position but the emission is offset to the player's reference point. This allows me to use negative radio velocity to make the particle travel back to its origin point, making it so that the arrow always ends up in the target. On the target hit, I created a particle system that uses the same radio velocity technique to replicate the effect of the target's energy being pulled by the player. This action fills up another slider that represents the player's stamina and whenever this value is bigger than zero, the player is then allowed to run. To implement the running logic, I created two variables that would determine the speed when normally running and the temporary speed burst value when hitting a target. I then interpolated the values based on the actual running state. And when the character is running, instead of being able to move in all directions, the controller steers the character's forward direction based on the input value, resembling a vehicle controller. For the speed burst effect, I created a mesh around the character similar to the one in my Metroid Red project. I created a shader for it that uses a texture as its transparency mask and I also offset its UV position to move the texture outwards. In the game, when this speed burst happens in mid-air, the player gains additional vertical speed. I reproduce this by simply executing an additional jump if the player isn't grounded in that moment. Then, I downloaded an Airflip animation from Miximo for this specific action. Another cool detail from the game that I implemented is that whenever the player perfectly releases the arrow in the middle point, time gets slowed down for a small interval, providing the user with a very nice success feedback. To increase the general speed sensation, I modified the camera's view of the view based on the different running states. Then, I started working on most of the procedural animations. I created a few poses where the arms are fully straight. This setup allows me to use Unity's Animation Ringing package to set a bunch of constraints that can dynamically change the animation. First, I made a rig that parents the bow object to the left hand. Then, I made some aiming constraints that make the head, chest and both arms look at a specific target. Finally, there's an IK rig that changes the position of the right hand to create the polling motion, which is followed by a line render in the bow in which the center point follows that animation. For some polish, I created a fire shader for the targets based on this tutorial by Gabriel Aguía. This setup offsets both a noise texture and a Voronoid texture to then combine them to create the effect, which I stylized by using a step node on the final output. Another implementation to improve the game view is to add camera shake, which I added to whenever the burst of speed is activated and also at the moment of the perfect error release. Next, I started creating another shader that I would use as a full screen effect for when the player is running. I came up with this ripple effect that is combined with a custom texture. To actually use this effect on the entire screen, I used a blit render feature created by Sine Nylux, which allowed me to apply the material with the shader into the screen. And finally, for a polished environment, I downloaded this free nature pack by Polytope Studio on the Asset Store and started creating a terrain using the assets provided. And after a bit of adjustments, this is how the project turned out. If you are interested in downloading the project and checking out the code behind it, there's a link for the project's repository in the description of this video. A massive thanks to those of you who support me on Patreon, including these top tier supporters, and also big thanks to the composer of the game soundtrack, Austin Wincery, for allowing me to use the music in this video. If you want to see more videos like this, consider subscribing and sharing this video with friends. Thank you so much for watching and I'll see you in the next one.