Abraham Charara

Software Engineer & Developer

The Cave that Eats
Lead Engineer
The Cave that Eats is an isometric shooter video game made in Unreal Engine 5 with similar elements to that of TORN's previous project, The Cave Prototype. This project will be where I use everything I've learned from past projects to properly write efficient blueprints, tables, objects, etc. Our hope is that, by making The Cave that Eats, we will also have made a codebase that we can use for all future projects.
Given the nature of this game, I knew the first thing I needed to do was create a proper gun system where we can easily create, equip, and drop guns. But before even that, we would have to define what a gun is. I decided to write out a table schema for what would eventually become our in-game Gun Table. This way we could properly communicate what attributes should be part of every gun in the game. Keeping in mind that we will be using this table in future projects, I also added how we could use this table for not only guns, but all sorts of weapons.
Once we settled on the guns' attributes, I created the project and GitHub and got to work. I used Unreal's Third Person Template, set the camera up high, and removed the player's camera controls to start. I then created the player's inputs (Aim, Shoot, Reload, and SwitchGuns) and started working on aim. When the player holds the aim button, they will slow down and the player will always be looking at the mouse cursor. This is to tell the player that they will fire bullets at wherever their cursor is. Finally, I began work on the guns for shooting and reloading. I created the Gun Table with two test guns, one single fire and one automatic. Throughout the rest of the month, I had successfully implemented most of the gun attributes into the game, including shot delay, fire rate, reload time, and spread into a component class called EquippedGun. Making this class as a component allows me to put multiple guns (and all of its functionality) onto the player and enemies alike.
The month of July was spent finishing my concurrent project, VR Wheelchair Basketball. But with that project completed and my Software Engineering diploma received, I was able to shift my primary focus over to TORN for the remainder of the month. Within 2 days, I was able to complete the guns' fundamental features as well create the ability to switch between multiple guns that the player is holding. Thanks to the EquippedGun component system, each gun holds onto its own attributes and ammo count.
With guns in a complete state for now, I moved on to the camera. I created a CameraFocus component that, when put on an object, will smoothy take the camera's attention away from the player and onto the object. Because all objects should not be of equal importance to the camera, I created 3 primary attributes that can be adjusted for each class of objects:

- Distance : How close the object needs to be to the player for it to grab the camera's attention.
- Alpha : How much the camera's attention should be on the object vs the player or other objects. In this example, the camera slightly shifts towards the silver ball, but shifts largely towards the gold balls.
- Priority : If multiple objects are in range of the player, higher priority objects will take the camera's attention and lower priority objects will be ignored completely. If there are multiple objects with the same priority, the camera will focus on a center point between them while taking their alphas into consideration. In this example, the gold balls take priority over the silver ball.
When there are no objects left to focus on, the camera will smoothly shift back to the player.
August smoothly transitioned into September as I continued to work on making the camera dynamic and seamless. At this point, I liked how the camera followed objects, but I wanted to ensure that everything stays in frame even when far apart. I decided to add a zoom function that zooms the camera out depending on the distance between the player and the furthest object. This feature is very subtle but extremely important for preventing frustration when aiming at far off enemies.
Moving on from the camera, I wanted to begin work on the core functionality for firing at objects. This functionality would have to be universal for all kinds of enemies and environment pieces that we will implement later in development. This is why I created an interface that can be applied to any class in the game. When the player shoots at an object, the game will check if that object has the "shot" interface; if it does, the player will tell the object to execute its specific code for that interface. In this example, the bell uses the shot interface to make a sound when the player shoots it.