How to become a Hypercasual Game Dev Ninja 🤺 ? The skill map

Hypercasual Game Production is an intense and competitive domain. You can’t expect your first idea to become the next hit game: you will need to create a bunch of prototypes and do some user testing to focus your efforts on the most promising concept.

At Dual Cat, our game creation squads develop a new high quality prototype in 2 to 5 days. To achieve these results and remain innovative, our game developers need to have a broad and solid set of skills.

Laser Cutting & Spiral Craft 3D, two hits developed by Dual Cat

Inspired by Brandon Morelli’s Game Developer Roadmap, we designed charts describing the skills that our ninja (hypercasual) mobile game developers should tend to master.

We use these maps to make sure every game developer knows in which field they can still improve. The beauty of game development is that you always have something to learn, and we want to make sure everyone is learning on a daily basis.

Regardless of where you feel you’re at when it comes to your Unity game development skills, it’s always useful to know where you’re good, and where you can improve.

To guide you on your continuous path toward improvement, we color coded each field relative to their importance and complexity: green — basic, yellow — intermediate, red — advanced.

Indeed, the game development sphere is always evolving and these charts could be updated monthly to include the newest techniques and features of the engine, but this is a good starting point to guide you in your learning process.

Disclaimers: The Charts are based on the Unity engine, broadly used in mobile game development, but they could be adapted to other engines (Unreal, Godot, Cocos2D…), and even fields other than mobile game development.

You can find the full skill map at the end of this article!

Game Dev Charts

The boxes are color coded according to this legend.

Unity Core Concepts

Obviously, any Unity developer needs to understand the basics and core concepts of Unity: what scenes are, or prefabs, how cameras are used to actually show your objects in your scene, what a MonoBehaviour is and how to add inputs to your game.

Unity UI

• Even though “UI Elements” is pushed as the future of Unity UI management, a good understanding of the entire uGUI workflow is a must-have.
• When in the mobile industry, extra care needs to be taken to produce a responsive UI, especially when safe zones and notches enter the equation.
• Anchors, pivots are a good start, but never forget that an early setup of a Canvas Scaler will direct your entire UI pipeline, from how assets are exported to how they are integrated in your game.
• As for fonts, Text Mesh Pro allows you to do much more than the traditional Text component!

Physics

• Basic understanding of the physics pipeline, how triggers and colliders work together. How many times as a beginner have you asked yourself: Why is this collision not triggered in my code? Hopefully, you will quickly get a grasp on how to debug these issues, and immediately configure your collision matrices as soon as you start your project.
• Joints can be overwhelming at first (I mean, look at how many parameters configurable joints have!), but they are key to making many satisfying mechanics in hypercasual gaming — and who doesn’t love ragdolls?

Animations & Tweening

• The Animator Controller, at the core of the entire animation pipeline, is one of these features that have many different parameters & caveats. Knowing how to create a simple state machine is one thing, understanding the deepness of what sub state machines, blend trees and layers offer is something else and merits its own learning session.
• While the Animator Controller is powerful, it comes with a heavy setup pipeline and has horrendous performance when paired with UI. For the latter, tweens are the way to go 99% of the time. You can’t create juicy interfaces without a strong tweening library. Create your own if you will (it’s a very fun task as a programmer to design the architecture of a library that can tween literally anything), but cheap options like DOTween exist and can save you hours of work on each project.
• Inverse Kinematics are not immediately out-of-the-box in Unity, and understanding how to set them up can be a useful tool to have in your pocket for very satisfying visuals.

Serialization : Saving & Loading Data

Such a complicated name for something so essential.

• For what we could call “static” data (data that is not altered by the player) you only need to know one thing: Scriptable Objects. Learn about them, use them, love them, they are awesome. Combine them with custom editor windows and you’ve got a very UX-friendly editor for anyone to use. Want to create different skins for your characters? Want to have different graphic setups for different atmospheres throughout your game? Or maybe different difficulty setups for your AI? Don’t look anywhere else: use Scriptable Objects.
• And for player data, you have tons of options. Explore what Playerprefs can do, know their limits, and then choose your own format: JSON, CSV, even a simple text file of your own format can do the job. Oh, and remember one thing: if you roll out an update for your game, make sure your save files are backward compatible. I learned that the hard way in my early days.
• Finally, do you know what meta files in Unity do? You don’t necessarily need to, but understanding what’s under the hood of Unity can sometimes help you big time when you have weird behaviours to debug…

Debugging

Speaking of Debugging, many programmers limit themselves to using traces (Debug.Log) to eradicate bugs in their programs. Why so much hate for breakpoints? It can take a while to get used to navigating step by step in the debugger, but when you get fluent with it, you can easily halve your debugging time. Especially when you learn how to do it while directly attached to your target device!

Rendering

Rendering was a tough one. There’s probably three times as many things we could fit into this graph, but some cuts had to be made.

• You will find a few useful tools that can accelerate development a lot for 2D games like the 2D Lighting package or Tilemaps.
• Shaders can be the bane of the beginner. If you are like me, you will/did not understand a thing about shaders for at least the first year of your game development career. Thankfully, you now have awesome free content such as Freya Holmer’s Shaders for Game Devs & Intro to Shader Coding to help you catch up faster. And once you start to get a grasp of the concept, you will be addicted to it!
• Lighting is a vast field and you can easily get lost in all the options. For hypercasual games, focus on Ambient Lighting, Directional Lights, and how to tweak your shadows using them. That will be more than enough for most of your projects.
• Render Pipelines are very powerful, but also quite a challenge to set up and understand. Do note that Unity is pushing them to be a standard, so if you have some spare time, learn about how they work.
• You can also find Compute Shaders here, which are not exactly “rendering” but are very powerful to optimize things that could hinder performances when developed in C#.

Game Optimization

Optimization is often overlooked in hypercasual gaming.

• The key to efficient optimization is good profiling. You can’t blindly optimize without knowing where the bottleneck is first. And to understand bottlenecks, you need to understand which hardware components are working together to actually run your game.
• Optimization techniques can increase the load on a component to decrease the load on another, and also take time to implement. Thankfully, Unity has powerful built-in ways to help you (Dynamic Batching, Asset Import Settings, …).

AI

To be completely honest, AI isn’t the best aspect of hypercasual games.

• However, in case you didn’t know: no, the players you are competing with in most hypercasual games are not real players 🙂. Consequently, knowing how to have them behave like they are is important. Finite State Machines & Behaviour Trees are a must-have in your programmer’s toolbox to do so.
• In addition, your AI characters will need to know where to go and how to get there: Unity’s Navigation System with Navigation Meshes will be your friend to accomplish this task.
• You can also find more niche concepts in this section, but if at any point your game resembles a board game, designing AI for board games requires some knowledge of Game Trees and Graph Theory.

Math

MATH! The bane of so many game developers here. I wish math did not get as much hate as it does: it is useful in every single project you will find yourself working on, and to be honest, it’s pretty fun to see some very theoretical stuff you might have seen in school come to life in a video game. Rendering, shaders, game logic, physics… name it: there’s probably math involved.

• Want to move your camera on the shell of a sphere or the edge of a circle? Number Systems like polar, spherical or even complex numbers can help you.
• Linear Algebra: While Matrices have their use case as well, Quaternions are THE way to manipulate rotations in Unity. You don’t necessarily need to understand the whole mathematical concept behind these complex numbers, just know what they do to Vectors and how to compose them. Speaking of Vectors, you will use them. A lot. Dot product, cross product, adding & subtracting vectors, computing distances… they are everywhere!
• Trigonometric functions such as cos, sin, or tan deserve their own bullet point. Especially if you are programming special effects in shaders, you will use sin in 99% of them.
• If at any point you want to work on procedural levels, Randomness will be involved. Knowing when to use certain types of randoms like Uniform or Gaussian can make a big difference, and understanding how to use Seeded Random can save you huge amounts of time when debugging.
• Sometimes, faking physics instead of using Rigidbodies can help you build a very quick prototype. The very scholarly problem “Find the equation of the position of a ball thrown with an initial velocity v0 and being only affected by gravity” (spoiler alert: it’s a parabola) is very easy to implement in a game engine! It does require some basic integration and derivatives knowledge.

Side note: if you want to (re)fuel your love for math, check out Freya Holmer’s Math For Game Devs for math content adapted to game development, or Grant “3blue1brown” Sanderson’s YouTube channel for learning material I wish existed 15 years ago.

Object Oriented Programming

This is where programmers can gain a lot of productivity. There’s nothing more time consuming than battling with your code editor or struggling to understand how this or that is doable in a specific language. Problem solving is the fun part, fighting with code syntax is not.

• First of all, choose an Integrated Development Environment, and master it. The key to being a good programmer is mastering your IDE. Learn the most useful hotkeys (Go to definition, find references…), be aware of what it can do (Mass renaming, auto-snippet creation…), and force yourself to use these features. This is where you will gain time. This is your efficiency engine.
• Object Oriented Programming base concepts such as class responsibility, inheritance & polymorphism are a must-have, you need to master them. I hate seeing some developers out there think that when you are making hypercasual games, you probably do not care about code quality. Please do care about it, both your co-developers and your future self will thank you for it.
• C# and .NET offer a huge library of different Collections. Lists are not the only collections out there! Learn what other types of collection exist, and their use cases, to further improve your efficiency.
• There are dozens of Design Patterns, and chances are if you went to a programming school that you probably know a lot about them. I would like to go out on a limb here and say that Singleton is probably the most undeservingly hated pattern. Seriously, it’s great. Don’t overuse it, sure, but it’s such a time saver and it makes code so much more readable. Other than that, you probably do not need to know all of the patterns. Events are a great C# tool which you will see yourself using without knowing that you are implementing a Listener pattern.

Unity Custom Tools

A short one… or is it? In reality, making custom tools is such a broad field that it is often overlooked.

• If you are working in the hypercasual game business, you will find yourself churning out prototypes. It is very important not to develop the same thing over and over again. As a result you’ll find yourself in need of custom tools to help you accelerate the prototyping stage. Most of the time, adding a button or a custom field in an inspector takes you 5 minutes to implement and saves you hours in the long run.
• Once you get used to developing custom Editor Windows, you’ll add a very useful string to your bow: the ability to create custom level editors, skin editors… Again, spending time outside of pure gameplay development can help you save hours of repetitive work. Your first editor windows will probably seem counterproductive as the learning curve is very steep, but you will be amazed at what they can allow you to do.

Build System

This is the least fun part of the development process if you ask me. You probably just want to develop your game, not battle to build it on the target device. The fact that you are probably integrating dozens of SDKs is a real pain at build time. Thankfully, Google’s External Dependency Manager already helps you a lot to avoid conflicts between SDKs.

• Thorough learning of each platform’s Build Environment will save you hours if not days of work to understand why a project doesn’t build.
• App / Code Signing is a major hiccup when you upload your project for the first time, especially on iOS. The concept of App ID / Certificate / Provisioning profile is hard to apprehend at first.
• For iOS, basic understanding of xCode’s interface and functionality is mandatory to build on iOS. That’s yet another IDE to learn, and it’s a big one.
• At Dual Cat, we built our own build pipeline deployed on a dedicated build machine to make sure game devs don’t have to worry about all of these things. We want development teams to focus on gameplay, not struggle with a non-compiling project throwing shady errors due to a malfunctioning SDK integration.

Going Further

In this one, I dropped a few skills that are always useful to have to keep increasing your productivity further:

• Strong knowledge of a Version Control System is the most important one. Most devs know how to pull, commit and push (in git terms), but there are times where your local repository is in shambles and it can be a headache to get it back on its feet. Also, learn which parts of a Unity project are important to version (Assets, Packages, Project Settings). Please do not try to version the Library & Temp folders!
• Some notions of how to use a scripting language such as Python or Bash can help you create mini-scripts (such as mass-renaming, image resizing, etc.) that save you a lot of precious time!
• With basic 2D or 3D software usage, you can prototype ideas yourself and create placeholders before artists create the final asset.
• Finally, know how to stay up-to-date on the latest Unity features. I love browsing Reddit on a daily basis in search of inspiration, more underground Unity features, shaders, … but there are a ton of YouTube channels, such as Sebastian Lague, Makin’ Stuff Look Good or Mix and Jam, to name a few, which are gold mines. The fact that you can get such amazing content for free is spectacular! (but please consider donating to their Patreon)

Conclusion

And.. done! While this might seem daunting at first glance, don’t be afraid, everyone has to start somewhere.

Also note that while these only cover hard skills, do not neglect soft skills, which are at least as important (communication, measuring how long specific tasks and features can take…)

What do you think? Anything we missed? Don’t hesitate to give us insight and tell us what you think is essential for hypercasual game development.

At Dual Cat, we value versatility a lot. We do not expect our game developers to necessarily be experts in specific fields, but rather to have broad knowledge in many fields. Our internal workshops are planned to help game developers share & learn on many different subjects that you can find in these charts, so that they can become hypercasual mobile game developer experts! As promised, here’s the full printable skill map for your reference. 😁