Abdur Rehman

I implemented a stamina system that dynamically decreases the player's stamina based on their actions and also created a simple UI to display it.

I replaced the jumping mechanic with a dodge ability because jumping didn’t feel meaningful in this type of game, whereas dodging adds more to the gameplay and generally fits the entire game better.

Made it so the camera can’t go below the terrain anymore. I also tried refactoring the player code into subclasses, but that caused a bunch of bugs and ended up being a total mess. I gave up and reverted back to the original player class. Next up I’m gonna add stamina mechanics.

Added better lighting and shadows to the game. Also started working on making sure the camera can’t go below the terrain. It’s only half done right now and still has a bunch of bugs, so I’m gonna go refine it now.

I added a randomly generated infinite terrain to the game and got physics working with it so things can collide properly. It came with a bunch of bugs that took a while to sort out, but I finally got everything working. Next, I’ll be working on the lighting and shadows to make the game look better.

I added a head bobbing effect to the camera that changes with the player's speed, and also added a landing impact effect. I fixed a few bugs here and there, and now I'll work on simple terrain for the game.

I’ve implemented the attacking state and completed all the associated animations. With that, all player states are now fully integrated, and all animations are in place. While I might add a few more in the future, everything is good to go for now. The player now has 20 states and around 30 animations in total.

Implemented blocking and kicking functionality. Next, I'll work on adding additional attack mechanics.

Added jump and fall animations, along with their respective states. All movement related animations and states are now complete. Next, I'll be focusing on implementing the attack, block, and related combat mechanics.

I've added all the movement animations except for the jump and fall animations. There are now 17 animations and 14 states implemented. Next, I'll be adding the jump and fall animations along with their corresponding states, before moving on to blocking and attacking mechanics.

I implemented the entire animation and state management system for the player. So far, I’ve integrated six animations: four idle animations that play in a sequence when the player is stationary, and two movement animations for walking forward and backward. Next, I plan to add additional basic movement animations and their corresponding states.

I’ve added the base player model to the game and refined both the controls and camera to better suit gameplay after integrating the player character. I also fixed several bugs related to the camera and other minor issues. Next, I’ll begin working on player animations.

I improved the player's movement to make it smoother and added a transition when crouching, so the body scales down smoothly instead of being abrupt. Additionally, I created a sky to enhance the overall lighting.

I implemented jumping and crouching mechanics for the player. To start, I added raycasts to detect ground collisions, which allowed me to enable jumping only when the player is grounded. Next, I added crouching functionality. When the player holds the C key, they crouch and can move through low or tight spaces. Additionally, the player will remain crouched if there isn't enough headroom to stand up, even after releasing the C key. Once there is enough space overhead, the player will automatically uncrouch, provided they are no longer holding the crouch key.

I’ve implemented basic player movement and introduced third person camera controls to the game. The camera now smoothly follows the player, with added functionality for zooming in and out. Next, I’ll focus on enhancing the movement mechanics by adding actions such as jumping and crouching.

I set up the basic scene for the game and initially attempted to integrate Rapier.js as the physics engine. However, after running into many issues, I decided to just use Cannon.js. I’ve added a capsule shaped physics body to the player and will now move on to implementing third person player controls.

I've completed the final touches on the game, written the README, and deployed it. The game is now complete.

I've implemented a muffling effect on the background music that triggers when the game is paused or ends. It adds a subtle but cool touch to the overall experience. With that, the project is mostly complete. Now it's time to clean things up and create the README.

I added the final audio to the game and refined the entire audio based logic for improved clarity by removing unnecessary stuff.

Began integrating audio into the game, starting with footstep sounds, which are now complete. Next, I'll be working on additional audio elements. I also experimented with lighting and tone mapping to enhance the overall visual quality.

I significantly improved the death sequence and made several updates to the code.

I implemented a death screen that appears when the player falls off the platforms.

I designed a visually engaging pause screen and implemented the pause functionality. The game now automatically pauses when the user switches browser tabs or navigates away from the application.

Created a cool looking loading screen for the game. Now I will work on the pause screen.

I've significantly improved the HUD design and added some smooth animation effects to it. Next, I'll be working on the loading screens and stuff.

I've added various gameplay elements like score, distance traveled, and more. I also put together a simple UI for now. Next, I'll focus on improving the current UI before moving on to the loading screen and other features.

I added a cool looking model to the platforms and significantly simplified the difficulty manager for better clarity by deleting all the unnecessary stuff.

I added props to the spawn point to make the area feel more lively and visually appealing. Next, I’ll be adding models to the platforms to enhance the overall look even further.

I improved the main spawn area by integrating a new platform model. After selecting an appropriate design, I added it to the game and added collision to it.

I added spawning and despawning animations to the platforms, and also introduced a new platform type.

I designed a variety of platform types, including rotating and moving platforms, among others. I also enhanced the difficulty manager by introducing more challenging platform types as the difficulty level increases.

I've implemented a difficulty manager that increases the game's difficulty as the player progresses by varying the distance between platforms. Next, I'll add different platform types to enhance gameplay variety.

I've built a basic platform spawning system for this game. It generates platforms indefinitely, creating an endless course for players. Next, I'll be working on a system to gradually increase the game's difficulty as the players progress. I also spent time fixing several bugs related to ground checks and physics, which were causing issues with player movement and collisions.

I decided to remove the dynamic terrain from the project since I wasn’t able to get the physics working properly with it despite trying several approaches. It just didn’t come together as expected, so I’ve moved on for now and am considering new ideas for what to build next. In the meantime, I’ve added some visual effects to the game, including film grain, bloom, and other stuff to enhance the overall look.

I've implemented simple terrain generation using Simplex noise and resolved several bugs in the process. The next step is to integrate physics to enable terrain interaction.

I’ve added a new falling state that activates whenever the player is off the ground. This change makes movement feel much more dynamic. I also implemented a camera impact effect that triggers when the player lands after being airborne, adding a nice visual feedback. Now I did try to add different fall states like falling flat and rolling but they just didn't work and added too much complexity and they seem a bit unnecessary for my purposes right now. So I might add them later. Right now, I’m tracking down a bug where the player physics aren’t behaving as expected, and I’m working on getting that sorted.

I implemented a ground detection system using raycasting. Multiple rays are now cast downward from the player, and if a set number of them make contact with a surface, the player is considered to be grounded. I also added proper jump functionality. Previously, only the jump animation would play, but now the player's physics body receives an upward force when jumping, resulting in actual movement. To help with development, I introduced a physics visualization system for debugging and other physics related testing. Next up, I'll be working on adding different falling animations along with their states.

I began by refining the player animations and state transitions. I improved the blending and transition speed between animations to make them feel more responsive. Additionally, I edited several animations in Blender. I shortened their durations and tweaked the timings to improve the overall gameplay. Next, I focused on enhancing player movement. I added acceleration and deceleration mechanics to give the movement a more polished feel. Previously, velocity changes were applied instantly, which felt abrupt. I also reworked the player's rotation logic to achieve smoother, more visually pleasing turning. After that, I shifted attention to the camera system. I adjusted the camera to maintain a slight offset to the right of the player, which just looked good. I also modified the overall camera positioning and added camera shake effects when the player walks or runs. Following these changes, I made several minor improvements and then created a sky for the game environment. The next feature I plan to implement is adding states such falling.

I started by adding all the necessary animation states to the model like crouching, for example. Integrating all these states and managing the transitions between them wasn't easy, but after a lot of effort, I eventually got everything working. Once that was done, I moved on to implementing the actual player movement (until now only animations had been playing), which turned out to be the most challenging part for me. I began with by implementing basic movement like going forwards or something, for example. It was relatively straightforward and worked as expected. However, things got tricky when I started thinking about the diagonal movement. The player could move diagonally but I couldn’t find any suitable animations for diagonal motion, so I came up with a workaround which was rotating the player model to simulate diagonal movement. The functionality worked, but integrating it with all the other animation states and their transitions just didn’t feel right. The entire system looked and felt awful and unpolished. So I tried tweaking the code to improve it, but nothing really worked. That’s when I realized I had too many animation states. Some, like strafing, were unnecessary for my current goals. So, I simplified the system by reducing the number of states from 14 to 7. This made the codebase much cleaner and significantly easier to manage. I ended up removing the entire movement system to implement a new one. It took some time to get everything working, but in the end, it felt solid. Not perfect, but good enough for now. After that, I added a basic third person camera that follows the player. It’s still quite simple, but I plan to enhance it with more features and functionality soon. Right now, I’m experimenting with different stuff to refine the movement system further. Once I’m satisfied with how it feels, I’ll shift my focus to improving the entire camera system.

When I started this project, I knew I was going to run into a lot of problems and I definitely did. This is my first time creating a third person game, and I jumped into it as soon as I had a clear idea of what I wanted to build. As usual, I began by setting up a boilerplate scene using classes, and then moved on to finding a player model. At first, I looked on Sketchfab like I always do, but I couldn't find anything that fit the style of the game I wanted to make. So, I decided to try something new and turned to Mixamo for animated models. That ended up being a great decision as I found a character that looked perfect and there were great animations too. Next came setting up the model in Blender, which was completely new territory for me. In fact, I had never even downloaded Blender before. After going through a bunch of tutorials and experimenting, I managed to import the animations and apply them to the main model. That process was frustrating and confusing at times, but after countless trial and error sessions, I finally got it working. I then created a state machine for the player to easily switch between animations with smooth transitions. Right now, I have about 4–5 animations implemented, but I’ve added around 14 total for various actions, which I’ll be adding in next.

I finally added audio to the game, which has been a major improvement to the gameplay in my opinion. I started by setting up the basic foundation for the audio which is creating a listener and I optionally implemented a simple audio cache to store all the game sounds (just like I was doing with my models). This caching system helps with performance (I think) and makes it easier to reuse sounds later on and just makes it easier to make the loading system. Next, I focused on finding a suitable sound for when the player shoots. After some searching, I found one that sounded pretty good to me. I then moved on to the reload sound. While I’m not completely satisfied with the one I chose, it was the best I could find after a lot of searching. Scoping in/out sounds took even more searching and experimentation. I tested multiple sounds until I found a combination that felt right. Then I worked on the sounds for item drops being collected. After some searching I eventually found ones that worked and added them in. After that, I added audio for when enemies are shot and included a hitmarker sound as well. I might add more sounds in the future, but finding the right audio takes a lot of time, so I’m putting that on hold for now. One of the more immersive features I added is a heartbeat sound that plays when the player’s health is critically low, accompanied by a visual damage effect. It really adds tension to some moments. I also implemented a feature where the game automatically pauses if the player switches to another tab or application. After that, I made various tweaks and finalized some values across the game. Once everything felt polished, I created a README file for the project. That’s pretty much where things stand for now. I might release future updates, like one feature I’d love to add is a leaderboard but honestly, this project has been a long journey. I’m really proud of how it turned out. There are a few areas I could refine, but nothing major. For now, I’m happy with it.

I started by refining the pause and death screens and addressing many UI-related bugs. Once that was dealt with, I decided to enhance the damage feedback by adding a damage effect that plays whenever the player gets damaged (which includes a red overlay and screen shake) because before you couldn't even notice that you were taking any damage). Next, I focused on improving the HUD. I revamped the ammo display thing by playing with its styles until i got something that looked good and replaced the simple health display with a more dynamic circular health bar. To make it look like you were actually gaining health and ammo, I also added effects that trigger when the player picks up health or ammo. I then turned my attention to the death screen. I implemented a death animation where the player's gun drops when health hits zero, with the previous glitch effect that I had but I toned it down because previously it was too extreme. I also made several minor adjustments to polish the overall appearance and added additional ranks for the player to achieve. I also added a warning text that appears whenever the games difficulty level increases so the player can actually see their progress. To balance gameplay, I introduced a static enemy type (which is like an enemy that doesn't move) to provide a break in the challenge. Finally, I'm now working on adding the audio and searching for sound assets to enhance the overall gameplay.

I began by playing with something called tone mapping, but ultimately decided the game looked better without it. With that settled, I finally shifted my focus to the UI. I started by building the loading screen, then implemented pause functionality along with a dedicated pause screen. I also introduced a scoring system to track player performance. Next, I tackled the death screen, adding features like the accuracy the player had throughout the game and giving the player a final rank based on the score and the difficulty level reached, topped off with a cool glitch effect that plays when the game ends. While the UI logic was fairly minimal, the real time taking part was the CSS. I spent a lot of time fine-tuning subtle details and effects to make everything look and feel just right (the animations were annoying as hell to add). Now the UI isn't complete like the HUD looks pretty ugly right now compared to the other stuff so I will spend some time making it look better. After that I'll move on to polishing the experience by adding small features and improvements that elevate gameplay before adding the final major functionality which is audio.

I started off by squashing a whole bunch of bugs, and I also removed the light effect from bullet impacts. It looked cool, but it was causing lag. After that, I dealt with a few more performance related issues, and then moved on to tweaking the spawn rates of the enemies and the drops. Originally, the health and ammo drops would spawn simultaneously, but now the health drop takes longer to appear. This adds more challenge to the gameplay, maybe too much (I might revisit the difficulty settings later). With those changes in place, I turned my attention to the environment. First up I did the sky. I figured creating a sky would also help with creating a suitable lighting. I started by trying to use an HDRI image for the background, but even at 1K resolution, it caused major lag. I tested a few lighter HDRIs, but the result was the same. So I scrapped that idea and went with a skybox instead. I eventually found some suitable skybox textures and built a dedicated SkyBox class to handle all sky related stuff. Unfortunately, performance (while better than the HDRIs) still wasn’t great, and visually it just didn’t work (probably due to low-res textures, but I couldn’t find better ones). So that idea got tossed too. In the end, I decided to use the sky provided by Three.js. After taking a quick look into the docs and doing some quick experimentation, I got it working. At one point, I tried to implement a day/night cycle just because I thought it would look cool and be easy to set up. Turns out, it was neither. Not only did it not work, it also looked kind of awful. That’s when I decided on a static sky. I picked a preset I liked (from my previous experimentation), tweaked it a bunch, and finally got a result I was happy with. Next, I adjusted the lighting by making it bright (way too bright). Then I turned my focus to the map. Up to this point, the ground was just a plain blue block. I looked for shooting range models on Sketchfab and found nothing. I tried searching for shed like structures, but they didn't look good to say the least, and seemed too complex to integrate hitboxes into easily. So I decided to build the map myself. Surprisingly, it was pretty straightforward and actually a lot of fun. I thought adding physics to each prop would be a pain, but that turned out to be easier than expected too. I added a bit of randomness to how some of the props behave to keep things interesting. After that, I toned down the excruciatingly bright lighting, updated the drop spawn points and the possible enemy spawn areas. Now, I'm in the phase of experimenting with different things like tone mapping. Next I will build the UI, add audio, and implement a scoring system as the final cherry on top.

I began by creating the muzzle smoke effect, followed by making the bullet hit effect look better and making it trigger on collision with every object. Once that was working, I turned my attention to the enemies. After some refactoring to the enemy classes, I realized the enemies looked quite dull, and I only had one enemy type. I searched for 3D models but couldn't find anything suitable. So instead of creating multiple enemies with different appearance, I decided to introduce behavioral variety. I implemented eight different movement patterns and now randomly assign one to each enemy. After that I made enemies disappear on their own after a certain period if not shot, also adding a disappear animation. With that in place, I moved on to implementing the player health system, which is a core part to the game loop as it creates the game over condition. Now, if the player fails to shoot an enemy before it disappears, they lose health. When health reaches zero, the game ends and this is where a death screen will be added (for now the game doesn't update when the health is 0). Next, I created a difficulty manager to gradually increase the difficulty over time by adjusting enemy speed, movement duration, and other things. After crushing a few bugs, I worked on health and ammo drops. I found suitable models, created a drop manager to handle their logic, and set them to spawn at regular intervals. With all that complete, the core gameplay loop is now functional, though I might add some other stuff in the future. My next steps include squashing additional bugs I noticed, tweaking difficulty settings, and fine-tuning the spawn rates of drops. Once that's done, I’ll focus on enhancing the visuals by improving the environment and adding visual effects followed by implementing audio and finally building the UI.

I’ve made several improvements to the game. First, I implemented a basic enemy spawning system. Right now, it spawns enemies at fixed intervals with a maximum number of active enemies. In the future, I plan to make the game progressively more difficult by reducing the spawn interval and increasing the maximum number of enemies over time. I’m also planning to make the enemies disappear after a certain duration if they’re not shot. When that happens, the player will lose health. If the health reaches zero, that'll be the point when the game is over. Currently, the enemies (or targets) are static, but I intend to introduce movement patterns such as vertical or sideways motion to make the gameplay more fun because right now it is child's play to hit the targets. I had planned to add multiple enemy types but couldn’t find a suitable model. However, I’ve already set up the system to support multiple enemy types in the future. For now, there’s only one. I’ve also added a shatter animation for when enemies are successfully hit, along with a bullet impact effect and a hitmarker. Additionally, I implemented a spawn animation for enemies using GSAP. At one point, I tried to replace my manual animations with animations using GSAP, but it didn’t go well, so I’ve dumped that idea. I also added a smoke effect, which I used on the bullet impact effect and also plan to use for the muzzle smoke. Next, I’ll be working on adding ammo drops and other small (or possibly large) gameplay features. After that, I’ll focus on improving the visual quality of the entire scene by adding props among other stuff, and eventually, I’ll begin working on the UI.

I adjusted the reload time and added a reload bar that fills up as the weapon reloads, also displaying the remaining time. Then, I refactored the code by creating utility functions, which significantly reduced repetition and made the codebase much cleaner.
Next, I introduced a Shootable class to define all objects that can be shot. All enemies inherit from this class. I also created a Target subclass (a basic enemy type), imported its model, and set it up in the scene. Currently, there is only one enemy type, and its behavior is simple. It only interacts with bullets and has no movement or advanced logic yet. I'm now working on adding more functionality to the enemies, and once that's done, I plan to implement multiple enemy types with varying behaviors.

I started by tweaking the gun movements and adding recoil to improve the overall feel. After that, I noticed the bullets didn’t look great, so I redesigned them with a better appearance and added trail effects for better visuals. I also fixed an issue where bullets would rotate wildly upon hitting the ground and now they bounce off smoothly. Next, I implemented scoping/zoom functionality and built a reload system for the gun along with some simple reloading based UI (which is subject to change). I also created a crosshair and added animations to it. Currently, I'm still working on refining the reload mechanics and will start on making the enemies.

I started by setting up a basic Three.js scene. Then I added Cannon.js and experimented with it for a while before deciding to make a shooting game. After that, I refactored the entire codebase to use classes, since I find them easier to work with. I then created the player, found a model for it, added its basic functionality, and spent some time tweaking things to make it feel right. I also implemented bullets and created a class to handle all input. Now, while continuing to work on the other aspects of the game, I'm also thinking of a fitting name for this game (because Shooting Game doesn't sound like such a good title, now does it?).

Made this cool 3D animation of the earth in space. Spent my time by first of all making the scene itself and tweaking stuff (especially the lighting and the placement of things) to make it actually look good. Then went on to make a loading screen, the background stars, and adding some background sounds for a better atmosphere. Plus I added some minor functionalities to improve the overall look and user experience.