Creating a game in just two days is an exhilarating challenge, and developing my Unity-based zombie survival game was no exception. The goal was ambitious: recreate the basic experience of the "Call of Duty Zombies" mode while keeping development simple and efficient. This post will explore not just the development process and challenges, but also the unique solutions I employed—like creating animations entirely within Unity without external tools.

The Concept and Features

The game revolves around a single map where the player must survive waves of increasingly challenging zombies. Its simplicity was intentional, allowing me to focus on the gameplay loop without being bogged down by unnecessary complexity.

Core Features:

• 1 Map: A single play area, designed for a confined, tense experience.
• Points System: Zombies give points when killed, which can be used to purchase weapons and ammo.
• Wallbuy Weapons: Four purchasable weapons scattered across the map.
• Progressive Rounds: Each wave becomes harder, with faster and tougher zombies.

The Development Journey

In just two days, I prioritized the essentials: gameplay mechanics, performance optimization, and player feedback.

Day 1:

• Mechanics First: I began by implementing shooting mechanics, zombie spawning, and the points system.
• Zombie Waves: Using a wave manager script, I ensured that each wave introduced more zombies with increasing health and speed.
• Movement and AI: The zombie AI was straightforward, relying on Unity’s NavMesh to direct them toward the player.

Day 2:

• Weapon System: I implemented purchasable weapons using Unity’s interaction system and ensured they felt responsive through muzzle flash and sound effects.
• UI and Feedback: Adding ammo displays, score counters, and round indicators was critical for keeping the player informed.
• Pause Menu and Cursor Management: I created a toggleable pause menu with cursor unlocking and locking functionality to manage player interaction seamlessly.

Animating Directly in Unity

One of the most interesting parts of this project was creating animations entirely within Unity. External tools like Blender or Maya can be powerful, but for this project, I wanted to maximize efficiency by working directly in Unity.

Weapon Animations:

1. Recoil Effect: Instead of creating a complex animation in external software, I used Unity’s Animation window to adjust the weapon’s position and rotation during firing. A quick upward "kick" followed by a gradual return to the original position gave the appearance of realistic recoil.
2. Reload Animation: The reload process involved moving and rotating the weapon slightly to simulate the player changing magazines. This was synchronized with a reload sound effect to enhance immersion.

Zombie Movement and Death:

1. Idle and Chase States: Zombies’ animations were created using Unity’s Animator Controller. For simplicity, I used basic movement cycles and transitions directly within Unity.
2. Death Animations: Instead of complex ragdoll systems, I used Unity’s Animation window to create quick "collapse" animations. The zombie model was rotated and scaled slightly to give the illusion of falling to the ground.

These techniques eliminated the need for external software while maintaining a polished look and feel. The key was leveraging Unity’s built-in Animation and Animator systems creatively to save time and resources.

Challenges and Solutions

The compressed timeline brought its own set of challenges, requiring quick decision-making and efficient problem-solving:

• Zombie Behavior: While I initially considered adding more advanced AI (such as dodging or pathfinding through obstacles), time constraints meant I had to rely on Unity’s NavMesh. This allowed zombies to follow the player reliably, albeit simplistically.
• Ammo and Weapon Balance: Striking a balance between player empowerment and challenge was tough. I adjusted weapon damage and ammo costs iteratively, ensuring the player felt rewarded for good decisions.
• Performance Optimization: Large numbers of zombies could have tanked performance. To address this, I used object pooling for zombies, reducing the overhead of constant instantiation and destruction.

Tools and Techniques

Unity’s built-in tools were the backbone of this project. Here's how they helped:

1. Animator & Animation Window: These tools enabled me to create weapon and character animations directly within Unity, saving time and avoiding external workflows.
2. NavMesh System: This provided a straightforward solution for zombie movement, ensuring they could navigate the map without custom pathfinding scripts.
3. Particle System: From blood effects to muzzle flashes, Unity’s particle system added visual flair and enhanced player feedback.
4. UI System: TextMeshPro and Unity’s UI tools were used for score displays, ammo counters, and the pause menu.
5. Audio Management: The integration of sound effects, like gunfire and zombie groans, was done entirely within Unity using AudioSources and pooling to ensure performance.

Lessons Learned

This project was as much a learning experience as it was a creative endeavor. Here’s what I took away from it:

1. Unity is Exceptionally Flexible: The ability to create animations, manage physics, and handle AI entirely within Unity streamlined development immensely.
2. Iterate Quickly: Testing and tweaking frequently ensured that every element of the game—from mechanics to animations—felt polished by the end.
3. Simplicity Can Be Powerful: Focusing on a few key mechanics and executing them well proved to be far more effective than attempting to implement complex features poorly.
4. Creativity in Constraints: Limited time and resources pushed me to find innovative solutions, like creating animations within Unity and using simple AI systems.

Final Thoughts

In just two days, I was able to develop a functional, fun zombie survival game that captures the essence of "Call of Duty Zombies." While it’s far from a AAA title, the project demonstrates how much can be achieved with a clear vision, effective use of Unity’s tools, and a willingness to iterate.

This experience has deepened my appreciation for Unity’s capabilities and has left me eager to tackle more ambitious projects in the future.

If you’re looking to build your own game, remember: focus on your core gameplay, use your tools creatively, and don’t be afraid to experiment. And most importantly—have fun along the way!

Thank you for reading, and I hope you enjoy the game! Share your highest round with me!