Here are some of the most common mistakes beginning Unity game developers make. You’re eager to start your Unity game development project. You’ve followed a few tutorials and think you’re ready to do it on your own. That’s great, but keep in mind that it’s easy to get lost in all the options Unity has to offer. One of the ‘downsides’ of Unity is that you literally have to do everything on your own, especially when it comes to structuring your project. Keep on reading and make sure you don’t fall for these mistakes, like I have done in the past as a beginner Unity game developer.
1. Lack of Project Organization
That brings me to my first point (and probably the most important one at this stage), project organization. Empty folders etc, are going to be quickly populated soon with scripts, materials, images, and sound effects. At this point, make sure you organize things properly. Name things clearly! When you come back at a later stage, you (or your teammates) should be able to find things quickly in the project.
2. Using the Update method excessively
Many beginning Unity developers write most of the logic in the Update loop. This is particularly bad when it comes to caching references or physics, or updating health/damage to a player. Use Unity’s event methods or coroutines. And when it comes to physics, put it in the FixedUpdate instead.
3. Not taking advantage of Prefabs
Prefabricated objects are invented for a reason. They save you time and performance. If you don’t understand how they work, learn it! Consider making any object you create in Unity a prefab. If you need a copy, or are in another scene, you can easily drag and drop the prefab back into the game project.
4. Ignoring performance
Try to keep your scripts as optimized as you can. FindFirstObjectOfType is fine if you quickly want to test out something, but if you are entering the final stages of game development, do go over it and make sure to cache references like that in the Awake method. The same goes for physics colliders: you don’t need complicated mesh colliders if a box collider is sufficient. 4K textures seem excessive if your game features a zoomed-out camera anyway. And see if you can optimize models that have too many vertices, for example. Object-pooling can greatly enhance performance if your game features a lot of enemies. And finally, learn to use the Unity profiler (it’s a bit tricky to understand, but as long as you comprehend the basics, it’ll get you a long way.
5. Not using Version control
Use some sort of version control, just in case things get haywire. Git is a good starting point to learn, but also Unity’s own version control (previously Plastic SCM), can greatly benefit your project. You can backtrack and revert the project back to a point where everything was working correctly, or experiment with different features in your game.
6. Overengineering code
Please refrain from overengineering your code. More than likely, you won’t need it, and it only causes frustration in your workflow. Start simple, and only refactor code when it becomes a performance issue or the complexity is really necessary for your game.
7. Not being consistent when coding, or writing sloppy code
Coding is likely the backbone of your game development project, and not adhering to consistent coding is one of the most common mistakes Unity game developers make. Making everything public is bad since any other object in your assembly has access to it; instead, use SerializeField or properties with a getter and setter. Writing private fields with a Capital letter one time, but not the next, is another one. Set rules for yourself when it comes to naming conventions, or adopt the standardized ones already out there. Personally, I like to use an underscore for private fields in my project like: bool _doSomething, and use a Capital letter for public fields, like public bool DoSomething {get; private set;} if the boolean needs to be referenced from another script. Doing so not only contributes to writing clean code, but it also prevents spaghetti code, since each field requires you to think about in what way it needs to be written according to your own standards. As you program and become better at it, in the long run, you’ll notice that you’ll adopt your own standards that make sense to you.
8. Not documenting what you’re doing
When you write code, you pretty much know what it does as you type it in. But later, when you get back to the project, you're going to be very confused if you don’t comment things in your script. Especially things that need a little further explanation, instead of referencing the _bar, write _playerHeathBar, or _skip, write _skipIntroScene, to make it clear what it’s doing. Furthermore, try to comment every method in your game (do so by typing three forward slashes ‘///’ in your editor) and comment what the method is supposed to be doing. This last piece of advice helped me a lot. Especially, when I referenced the method from another script. Also, perhaps keep a little readme file inside your project that explains the structure of the project. This is not only handy for yourself when you come back later, but this also may benefit others if they’re working on your project.
9. Trying to build a massive game first
This is probably the most common mistake beginning Unity game developers make: trying to build a massive game, even though they hardly understand what an undertaking that would be. The result is often frustration and abandoned projects. Start small, and try to finish the game from the beginning to the end. You’ll learn so much more, believe me.
10. Not learning Unity
This may seem obvious, but most aspiring game developers don’t take the time to truly understand the game engine. Unity’s built-in tools can already help you on your way, but if you don’t know about it, you’d be spending all that time reinventing the wheel to get that particular feature that already exists (often an even better version!).
Wrap up:
These are some of the most common mistakes beginning Unity game developers make that I see over and over again. To them I say, read this article (seriously, I do!). Once you fix these points, you’ll notice that not only are you becoming a better developer, you’re also saving a lot of time and frustration!
What are some of the mistakes you have made in Unity? Care to share? Write a comment down below!
No comments:
Post a Comment