Developing a video game is an exciting yet challenging adventure. Over the course of creating this project—a dynamic strategy game inspired in various idle games. I learned a great deal about game design, problem-solving, and utilizing Unity to its fullest. Here's a detailed look into the process, the hurdles I faced, the solutions implemented, and the invaluable lessons learned.

The Vision: What I Set Out to Build

The core idea was simple but ambitious: a strategy game where players manage resources, buy units, and face increasingly powerful enemies. Key mechanics included:

• Resource Management: Collecting gold and upgrading ships to boost stats.
• Dynamic Combat: Battling enemies whose strength doubles with each defeat.
• Event Integration: Special events offering rewards or challenges to keep the gameplay engaging.
• Scaling Mechanics: Ensuring the difficulty grows as the game progresses, supported by features like exponentially growing numbers and challenges.

The target was to create a mobile-friendly experience with clean UI, touch interactions, and smooth performance.

Key Features Implemented

1. Resource Collection and Scaling: Players earn gold over time, with a scaling mechanism tied to their upgrades. Using a multiplier-based economy system, I ensured that progression felt rewarding while presenting consistent challenges.
2. Combat and Upgrades Ships: are deployed for combat, with upgrades increasing stats like attack power, health, and income generation. Defeating enemies would double their health, introducing exponential difficulty.
3. Special Events: A central feature was the inclusion of events that reward players for completing specific objectives, such as earning gold within a time frame or defeating a certain number of enemies.
4. Progression System: Players could save and load progress, which was crucial for creating a long-lasting experience.

Challenges Faced and Solutions Implemented

1. Saving and Loading Progress
   • Problem: Initial attempts to save player data worked inconsistently, especially on Android. Progress was lost, or data failed to load correctly.
   • Solution: Implementing Unity's Application.persistentDataPath for file storage and adding calls to save data during OnApplicationQuit() resolved the issue. I ensured that save and load functions were executed in the correct game lifecycle events to avoid data conflicts.
2. Touch Interaction Issues on Android
   • Problem: After building the APK, touch inputs were unresponsive.
   • Solution: Configuring Unity's Project Settings, including properly enabling touch inputs and checking platform-specific configurations, solved the problem. Additional debugging ensured the UI elements received clicks or touches as intended.
3. Null Reference Errors
   • Problem: Upon loading saved data, the game would sometimes throw NullReferenceExceptions due to uninitialized objects (like the UI manager).
   • Solution: Adjusting the initialization sequence by moving critical calls like RespawnShips() from Awake() to Start() resolved this issue. Ensuring dependencies were properly initialized before use became a key focus.
4. Scaling Numbers for Exponential Progression
   • Problem: Displaying large numbers cleanly and accurately was essential as values could exceed trillions.
   • Solution: I created a utility function to format numbers up to unimaginably large values, using notations like "aa" and "bb" for numbers exceeding sextillions.

Unity's Role in Development

Unity played a pivotal role in making this project possible. Key tools and features utilized included:

1. Unity UI
   • Essential for creating intuitive interfaces for managing resources, displaying combat stats, and handling touch inputs.
   • Used Event Systems to handle tap and swipe inputs seamlessly.
2. ScriptableObjects
   • Enabled modular, reusable data for defining ship stats and scaling multipliers.
3. JSON file saving
   • Implemented a hybrid saving system for both quick preferences and detailed game state storage.
4. Prefab System and Scriptable Objects
   • Crucial for spawning ships dynamically and maintaining consistency across upgrades and respawns.
5. Coroutines
   • Used for timed mechanics like periodic gold collection or event countdowns.

Lessons Learned

1. Debugging is Key: Understanding Unity's lifecycle (Awake, Start, OnEnable, OnDisable, etc.) was critical to resolving initialization errors.
2. Platform-Specific Considerations: Developing for Android highlighted the importance of testing on actual devices early and often. Some issues, like touch input failures, only surfaced after deploying the APK.
3. The Importance of Scaling: Balancing exponential mechanics was a valuable lesson. Too fast, and the game became unmanageable; too slow, and it felt uninteresting. Iteration and player feedback were key.
4. Documentation Matters: Properly documenting code, mechanics, and processes saved time during debugging and extended the potential for future expansions.

Achievements and What’s Next

This project was completed in just a few days, which felt incredibly rewarding given the scope of the mechanics and features implemented. I’m proud of:

• Building a scalable system that feels engaging and fun.
• Solving critical bugs and ensuring stability across sessions and platforms.
• Creating a foundation for future updates, including more ship types, new events, and competitive leaderboards.

Conclusion: Developing this game was both a technical and creative challenge. From fixing frustrating bugs to optimizing gameplay mechanics, every hurdle presented an opportunity to learn and grow as a developer. For anyone embarking on a similar journey, my advice is simple: embrace the challenges, test often, and never stop iterating.

This project is more than just a game—it’s a testament to persistence, problem-solving, and the joy of bringing an idea to life.