October 2, 2019
Beginner Programming: Unity Game Dev Courses
Beginner Programming: Unity Game Dev Courses
Unity Learn Course – Beginner Programming
Module Introduction
This has basic coding principles, like formatting code files, naming conventions, namespaces, and effectively using comments. These are all concepts I know about, but only have some experience with so seeing another view should be beneficial. One of their main principles is “Consistency trumps style”.
Formatting your Code Files
The main points for this section are: value of conventions, anatomy of a code file, and formatting guidelines and tips.
Conventions provide a consistent look, make your code more accessible, makes it easier to maintain and extend, and shows your understanding.
Starting basic script structure: At the top there are using directives for namespaces. This is followed by the definition of the class. This defaults to deriving from Monobehaviour, and creating methods for Start and Update.
Editing Visual Studio Code Formatting Preferences
You can change your code formatting preferences in Visual Studio on Windows by going to Tools -> Options. Here, you can find “Text Editor” and find a bunch of formatting options, some for general purposes and then others for specific languages. Under C# for example, it breaks down even further into “Code Style” and more formatting options. These can be used to change how Visual Studio does default spacing for you, bracket placement, etc.
What’s in a Name?
The values of conventions (again) are: provide consistent look to your code, makes your code more accessible, makes it easier to maintain and extend, and show your understanding.
The benefits of naming conventions are: tell us what something represents, tell us what something is, leverage capabilities of modern IDEs, and (although less common currently) can indicate scope.
As usual, they say make your names descriptive (without being too wordy) and be consistent.
C# Naming Conventions in Unity
The capitalization techniques are: Pascal Case and Camel Case. Pascal Case capitalizes the first letter of every word, and single word identifiers are capitalized. Camel Case starts lower case, and only capitalizes every word after the first. For single word identifiers, camel case leaves it lower case.
General Naming Guidelines:
- use descriptive names
- use easily readable names
- avoid abbreviations
- do not use underscores between words
- be consistent
Use Pascal Case:
- namespaces
- classes
- structs
- methods
Use Camel Case:
- fields
- parameters (arguments)
- local variables
There was an older convention to prefix field names with an underscore, an m, or both. This is not done as much anymore, but it is good to mention since you will come across it often. These were originally done to show a difference in scope between variables (i.e. local and non-local variables), but it has been deprecated with the advancement of modern IDEs. They will show you the scope of a variable just by hovering it.
Namespaces and Regions
Namespaces
These are spaces or containers for names. The benefits are modularity and avoiding naming collisions.
Modularity is accomplished by helping group types, classes, delegates, interfaces, etc. logically under a specific namespace. For example, the UnityEngine namespace contains a lot of commonly used tools such as Monobehaviour or Debug.
Fully qualifying the reference: This is when you precede something with its namespace to directly specify which reference you are using.
Including the namespaces used in the using directives at the top of your code file tells you and others that see it what types of objects they can expect to see in the file. Namespaces can even include other namespaces.
Naming Collisions
This occurs when the same name is used to reference different variables representing different things. Modern IDEs help minimize this issue, but it can still happen.
It is not mandatory to put your own code in namespaces, but it is strongly recommended to use in larger projects with project specific features to help keep your code organized and make it easier to maintain.
Regions
Regions are technically preprocessor directives, but they are used often in Unity for their visual purposes. They provide collapsable sections of code to help focus on what is necessary.
Regions are declared with the word region along with a “#” and the name of the region. Everything within the region is contained within a set of brackets. Finally, you end the region with the keyword “#endregion”.
FINAL NOTES
As expected, a lot of this is covering topics I already know, but it is good to confirm some of the practices I use and go over the terminology again. For example, I do still see a lot of underscores used for indicating scope of fields but it is not something I particularly use so it was nice to confirm that its less standard practice now with modern IDEs. These tutorials consistently use all the proper programming vernacular, which is a very nice plus over a lot of other learning sources I use that just want to get across the end game result as quickly as possible.