CloneRush

First person view of the highlighted weapon when attempting to equip it in "aim" (shift) mode. The weapon glows to give attention to users.
Menu Screen of CloneRush containing the title, play button, and three memorable taglines depicting the various endeavors the game possesses.
Major Game UI including Healthbar, Ammo Coutner, Wave Number, and AI enemies facing the player when in the first person "aim" (shift) mode.
Third person view of player, and spawning AI enemies on platforms. UI such as the crosshair is displayed.
Glowing weapons indicate that they are able to be picked up; AI enemies are scattered across the map as seen in the screenshot above.

Inspiration

We garnered inspiration for our project through ideas of overwhelming escalation through the cloning of enemies/mobs--what happens when enemies don't simply respawn, but replicate when they do so, inspired by wave-based shooters and sci-fi cloning tropes where the threat does not lie within the hands of a single power enemy, but an unremitting, evergrowing swarm. Hence, amid the prompt for this hackathon being "Cloning", we decided to delve into how cloning could serve more than a figment of our future or a narrative theme, but rather a core pressure mechanic defining the moment-to-moment gameplay of CloneRush. Traditional shooters often reward aggressive play, but in CloneRush, every second of hesitation can lead to exponential difficulty. This inspired us to design gameplay that constantly pressures the player to move, react, and adapt, reinforcing the sense of urgency and panic that naturally arises from uncontrollable replication.

What it does

CloneRush is a third-person shooter game where players must be able to fend off mobs of cloning enemies that are persistently conjured and spawned, overwhelming the high-detail, blender-created map. Each wave instantiates numerous spawn points with increasing enemy counts, spawn rates, and overall pressure over time. Players are hence challenged into managing their positioning, aim, and survival amid a high-definition battlefield riddled with replicating mobs. This game consists of a wave system, enemy spawning, player combat mechanics and animations, real-time UI depicting health and wave progression, and complex 3D structures generating an intrinsic battleground for players to jostle with cloning mobs of capsule-shaped savages adorning rapidfire firearms set to impose fury. As waves progress, the battlefield becomes increasingly chaotic, forcing players to make split‑second decisions under pressure. The combination of enemy density, environmental constraints, and limited player resources ensures that no two waves feel the same. CloneRush emphasizes survival through awareness and movement rather than brute force alone, rewarding players who can read the flow of the battlefield and react accordingly.

How we built it

We created CloneRush using primarily Unity and C# which focuses on modular systems that can be rapidly and consistently iterated throughout the extents of this hackathon. The core game mechanics includes a WaveManager C# script that controls the enemy waves and the spawn frequencies at the randomly selected spawn points on the map, an EnemySpawner system that dynamically activates spawn points in real time, a simple AI enemy that can navigate and attack players and alternate between Patrolling, Chasing, Attacking, and Idle states depending on distances from the player, and player combat scripts that handle shooting, recoil, reloading, and health. UI elements such as the health bar, wave counter, and ammunition counter were created using Unity's UI systems via utilizing image-based fills for smooth visual feedback. Enemy behavior and spawning was particularly catered and curated in order to emphasize the quantity and pressure of the mobs over complex AI to reinforce the cloning theme as the capsule-shaped mobs replicate in anarchy. We also dabbled in creating player animations in withdrawing, dropping, firing, and idling with the player's weapons. We were able to make players pick up weapons while they are aiming (shift), indicated by the weapon being highlighted in blue, and could be picked up with the E key by utilizing Unity's Input System which was used in all the player controls, and by using raycasts to detect whether the camera was directly facing the weapon, of which was animated via the use of cinemachine to create exciting camera physics. We also utilized blender to create the various models that constitute the map of our game including the buildings, roads, textures and materials used with Unity's built-in Universal Render Pipeline, and smaller models to create a detailed vibe to the game. Throughout development, we prioritized the overall gameplay feel and clarity over visual complexity to ensure the core loop was solid. To support scalability, systems were designed to be data‑driven where possible, allowing wave parameters such as spawn rate, enemy limits, and active spawners to be adjusted without rewriting code. This allowed us to rapidly test difficulty curves and tune the gameplay experience. Careful consideration was given to performance, particularly with enemy spawning and destruction, ensuring that the game remained responsive even as enemy counts increased dramatically. Although most of the code was written by ourselves as frequent coders and game developers, we did gain AI assistance from Github Copilot in order to fix errors with subscribing our methods in the PlayerShooter class to the Unity Input System, and to fix certain syntax errors such as misspellings and forgetting semicolons (Used GIthub Copilot's with the Claude Sonnet 4.5 model).

Challenges we ran into

A major challenge that we ran into was managing rapidly increasing enemy counts without breaking the gameplay balance,. nor the performance of the game. Furthermore, fine-tuning the spawn intervals, wave scaling, and the limits of the enemy as well as dictating the shift in states from Patrolling, Chasing, Attacking, and Idle and programming the Enemy AI's behavior in these various states (particularly in Patrolling where we had to make the Enemy coordinate through a variety of points and detect whether the player is nearby), and nemy limits also required significant iteration. Another pertinent issue was separating the gameplay logic from the UI logic especially amid the time pressur ewhich resulted in us refactoring our systems to keep our responsibilities clean and to avoid bugs. We used Unity's Version Control System (formerly Plastic SCM) to collaborate which had many issues when we tried to merge branches and lost some of our work in the progress which set us behind. We also ran into issues with Unity's input systems and UI behavior which required simplifying and stabilizing our approach to keep the game development of CloneRush going. Balancing player survivability against escalating enemy pressure proved especially difficult, as small changes to spawn logic could drastically alter difficulty. Time constraints forced us to make careful tradeoffs between adding features and stabilizing existing systems. Communication and coordination under pressure were also challenges, particularly when resolving merge conflicts and recovering lost work while continuing active development.

Accomplishments that we're proud of

We are inexplicably proud of generating a fully functional wave-based third-person shooter game that scales difficulty dynamically and adorns the cloning theme related to this year's Academies Hacks. We successfully implemented responsive player combat, enemy spawning across multiple points, and clear visual feedback for health and wave progression. Most importantly, we delivered a playable, cohesive experience where the core idea that enemies that keep multiplying comes through clearly and consistently. The successful integration of player control systems, enemy AI behavior, and wave escalation resulted in a game that feels intentional rather than experimental, which was a major goal for our team.

What we learned

Throughout the extents of this hackathon, we garnered information on how to design and implement scalable wave systems, manage enemy spawning efficiently, and structure Unity projects to keep gameplay, UI, and input concerns separate. We gained hands‑on experience balancing real‑time combat mechanics, handling iteration under tight deadlines, and making design decisions that prioritize player experience. We also learned the importance of simplifying systems when things become unstable, especially during rapid prototyping. We also learned how critical communication and task delegation are in collaborative development, especially when multiple systems are being built simultaneously. The experience reinforced the value of modular code, version control discipline, and iterative testing. These skills will directly translate to future projects.

What's next for Clonefall

Given more time, we would expand enemy variety, introduce elite or modifier clones, and add more arenas with unique layouts that change how waves behave. Additional progression systems such as upgrades or abilities could further deepen gameplay. We’d also refine visuals, add audio feedback, and explore more advanced AI behaviors to push the cloning mechanic even further. We would ultimately make the game multiplayer with advanced bots, and better models for enemies in order to make this game well-rounded. Long‑term, CloneRush could evolve into a roguelike or endless survival experience, where procedural wave generation and modifiers ensure long‑term replayability. With expanded content and multiplayer support, the cloning mechanic could become the foundation for competitive or cooperative modes centered around survival under extreme pressure.