7 Things to Remember When Working in a Team

Whether you are working in a team or alone, you should know how to efficiently work on a project with other people. It will not only make working on a single project with someone a lot easier, but also improve your coding style and project management skills significantly. It’s nothing to be afraid of, really! I’d like to explain in a few steps what are the most important aspects of working in teams.

1. Organize your project well

Before progressing any further you must make sure that your project is well-organized. It’s an important requirement because unorganized project is very difficult to maintain. It’s not impossible to work on such project by all means, but each time you will be forced to work on it, you may feel an unstoppable desire to murder someone in your near proximity. And this feeling will get worse as the project will grow.

You can learn how to keep your project organized from one of our previous blog posts.

2. Setup an issue tracker

If you aren’t using one already then I am sure that you’ve heard at least about Jira, Redmine, Trac or Mantis. In fact, there are a lot of these and you may have a serious problem with deciding which one to choose. From my experience there’s no solution that can be called “the best one”. All of these has some pros and cons. I strongly encourage you to check at least 3 of them before decidingwhich one will be good enough for your needs. Keep in mind that you will learn what you really need only after a few months of working with any of it.

Why issue tracking is that important? When working in a team, good communication is a key. Humans are lazy and forgetful creatures. If you tell someone that he/she has to do something, he/she remembers that task clearly until tons of similar tasks fall out from the sky. You have to accept that simple fact. Also don’t rely on your own memory – it has been proven that the need of remembering a lot of things significantly increases your stress.

3. Switch your projects to force-text serialization method

It’s obvious but can be often forgotten. Unity is using binary serialization method for its assets by default (hey, Unity guys! Who told you that would be a good idea?). This simply means that if two people will change a scene, animation setting or a prefab at the same time, one person will have to give up his changes because of a conflict. The situation is similat to the one in which two guys dating the same girl. One of them sooner or later will have to give up (let’s not talk about alternatives, shall we?).

Force-text serialization can be enabled in the Edit -> Project Settings -> Editor:

You don’t need to confirm anything. Unity will perform re-serialization of your assets immediately.

4. Agree on a common coding style

Be ready for a big fight – programmers don’t like to change their habits. But you and your colleagues still need to do it, otherwise it will cause a lot of nasty conflicts on code merges. Also, you have to decide if your source files should use tabs or spaces for code indentation. You may look for something like an official or community style guide for a specific language. There’s one for C#  that you may find useful. You don’t have to blindly follow if you don’t agree with some parts of it, but when there will be a disagreement within your team, it may be a good source of possible solution.

Remember to not force any decisions on your team if there’s a strong defiance on that matter. If you want them to give everything they got to your project, you have to make them love working on it, not hate it!

5. Agree on asset changes policy

Some assets can be hard to merge even if you switch the serialization mode to text. It may be necessary to decide on a policy on how and when communicate that someone is about to edit an asset. Some VCS like Perforce or PlasticSCM offer a feature called exclusive checkout. It means that all files are read-only until someone will decide to edit it. If the second person tries to edit that file in the same time, he/she will receive a warning that this file is being checked out by someone else.

You may also want to take more human-like approach. I knew one company that had a magnetic table with post-it notes on it. Each note had a scene name written on it. If someone decided to edit a scene, he or she took matching note to his/her desk so anyone else knew that this scene was currently being changed.

6. Communicate often, but watch for interruptions

Talk often with your team about what they did and what they are about to do. Do it every morning if possible and make it short. Discuss about possible issues and how to solve them, if needed.

Talk with your teammates often if you need to, but watch out for interrupting their work. Avoid calling them or speaking to them personally without earlier notice. If you do that, you decline their right to react whenever it suits them. You make them immediately lost the context of the work they were doing and to focus on your thing – it’s a very selfish thing to do. Even if you’re in a hurry, try to notify them using an email message or IM first.

Choose communication software that allows to freely configure its verbosity level. Some people don’t mind to be interrupted, some does. Nearly every e-mail client allow to freely configure notifications level so if you want to talk about something and you’re not in a hurry, use e-mails. Some things cannot wait for too long, so you need Instant Messaging of some sort. I strongly recommend you to try Slack. Slack highly respects everybody’s right to not be interrupted and gives an option to allow interruption in really important matters. Slack also allows your team to create channels. Channel is a place when two or more people can discuss with each other about one specific matter.

7. Try Unity Collaborate

Not so long ago Unity announced their new service called Unity Collaborate. It’s worth trying because it directly targets Unity developers and the client is working within the Unity editor itself.

We’ve never been using Unity Collaborate (it’s still in beta stage), but it promises to solve issues with data merging and staying in sync with your teammates. It’s worth checking and you can try it for free.

What else?

There are no two identical projects and two teams will never be the same. You should keep your eyes and mind open, and watch for any issues your team encounters that are worth solving. Not all issues can be solved easily and many project directors make a mistake with solving an issue with a solution that makes it even worse. Trying is not a sin, but not admitting we made a mistake and regressing in work that has already been done unfortunately is.

7 Ways to Keep Your Unity Project Organized

I saw a person on Quora the other day, asking how programmers are able to write projects that consist of over 10,000 lines of code. When software gets bigger, it is more difficult to maintain and that’s a fact. So here’s the thing – if you don’t keep your project organized, you’re going to have a hard time to keep the pace. Later on, you will find yourself wasting time with a messy project instead of adding new features. This is also true regarding any Unity Project. Here are (in my opinion) the most important tips that will help you with keeping your project organized.

1. Directory Structure

We cannot talk about organization without mentioning organizing project directory structure. Unity gives you a total freedom in that matter, but because of that, it can frequently get really messy. This is the directory structure I personally use:

  • 3rd-Party
  • Animations
  • Audio
    • Music
    • SFX
  • Materials
  • Models
  • Plugins
  • Prefabs
  • Resources
  • Textures
  • Sandbox
  • Scenes
    • Levels
    • Other
  • Scripts
    • Editor
  • Shaders
  1. Do not store any asset files in the root directory. Use subdirectories whenever possible.
  2. Do not create any additional directories in the root directory, unless you really need to.
  3. Be consistent with naming. If you decide to use camel case for directory names and low letters for assets, stick to that convention.
  4. Don’t try to move context-specific assets to the general directories. For instance, if there are materials generated from the model, don’t move them to Materials directory because later you won’t know where these come from.
  5. Use 3rd-Party to store assets imported from the Asset Store. They usually have their own structure that shouldn’t be altered.
  6. Use Sandbox directory for any experiments you’re not entirely sure about. While working on this kind of things, the last thing that you want to care about is a proper organization. Do what you want, then remove it or organize when you’re certain that you want to include it in your project. When you’re working on a project with other people, create your personal Sandbox subdirectory like: Sandbox/JohnyC.

2. Scene hierarchy structure

Next to the project’s hierarchy there’s also scene hierarchy. As before, I will present you a template. You can adjust it to your needs.

  • Management
  • GUI
  • Cameras
  • Lights
  • World
    • Terrain
    • Props
  • _Dynamic

There are several rules you should follow:

  1. All empty objects should be located at 0,0,0 with default rotation and scale.
  2. When you’re instantiating an object in runtime, make sure to put it in _Dynamic – do not pollute the root of your hierarchy or you will find it difficult to navigate through it.
  3. For empty objects that are only containers for scripts, use “@” as prefix – e.g. @Cheats

3. Use prefabs for everything

Prefabs in Unity are not perfect, but they are the best thing you will find to share pre-configured hierarchies of objects. Generally speaking, try to prefab everything that you put on your scenes. You should be able to create a new level from an empty scene just by adding one or more prefabs to it.

The reason why you should use prefabs is that when a prefab changes, all the instances change too. Have 100 levels and want to add a camera effect on all of them? Not a problem! If your camera is a prefab, just add a camera effect to the camera prefab!

Be aware that you cannot have a prefab in another prefab. Use links instead – have a field that requires a prefab to be assigned and make sure to assign it when instance is created. Consider auto-connecting prefab instances in Awake() or OnEnable() when it makes sense.

4. Learn how to use version control system (VCS)

git logoYou may already know something about GIT, Subversion or any other VCS out there. As a matter of fact, “knowing something” is only a small piece of what you may learn. You should focus on learning about important but infrequently used features of VCS of your choice. Why? Mostly because VCS systems are much more powerful that you think, and unfortunately many users are using these as nothing more than a backup and synchronized solutions. For example, did you know that GIT allows you to stash your changes, so you can work on them later without committing anything to your master branch?

Programmers tend to comment out blocks of code in case it’s needed later. Don’t do that! If you’re using VCS learn how to quickly browse previous versions of a file. When you are familiar with it, your code looks a lot nicer without unnecessary block of commented code.

Here’s a nice resource of tips for GIT users: http://gitready.com/

5. Learn to write editor scripts

Unity is a great game engine in the matter of extensibility (see Asset Store). Learn how to write editor scripts and utilize this knowledge. You don’t necessary need to create fancy GUI for your scripts, it can be something simple, as menu entries that are doing something useful. Here are some examples of editor scripts that I have created not so long ago:

  • Google Sheets .csv download – I had a translation spreadsheet saved on Google Drive. It automatically downloaded the newest version as .csv file, so I never had to do it manually.
  • Randomize the position, rotation and size of trees – I had a lot of trees and wanted it to look more like a forest than a grid.
  • Create distribution – Built for specified target, zips all the files and copy to the right place.
  • String replace in the sources – I had several files that contained the application version.

You can learn how to create editor scripts from the official documentation.

6. Learn to program defensively

Have you heard about defensive programming? Wikipedia defines it as follows:

Defensive programming is a form of defensive design intended to ensure the continuing function of a piece of software under unforeseen circumstances. Defensive programming techniques are used especially when a piece of software could be misused.

Generally when you’re writing MonoBehaviours, you should make sure that:

  • All needed references are set
  • All required components are present
  • If you’re using singletons, make sure that they exists
  • If you’re searching for objects and expect to find something, do it as fast as possible
  • Mix-in editor code (ExecuteInEditMode and #if UNITY_EDITOR) to do as many checks as possible before you run the scene

For many of these checks you can use asserts. You should also read A Story of NullPointerException Part 1 and 2.

7. Implement in-editor and/or in-game cheats

After you learn how to write editor script, you should be able to write a set of in-editor cheats. It can work as menu entry that unlocks something (all levels for instance). It’s really easy to create:

Generally you should write cheats that will allow you to:

  • Unlock all levels, characters, items etc
  • Give you immortality
  • Add/subtract values like time, money, coins etc
  • Allow you to see things not meant to be seen by players
  • Anything else that will help you with testing your game

Of course more practical (but harder to write) are in-game cheats. These type of cheats can be executed outside Unity editor, but you have to think how you would like to execute it. See our other article about implementing cheats subsystem controlled by mouse.

Using the Unity Cache Server

 

Unity Cache ServerIf you’re working on a medium or big project then you may get into a situation when pulling your project from the repository (or switching to a different branch) triggers a time-consuming process of asset importing.  It can be even more painful if you’re targeting at mobile devices like Android and iOS. For instance, on iOS textures or lightmaps, the import may take even several hours! It’s a lot of wasted time because you cannot do anything during that time!

importing assets

Cache Server to the rescue!

The Unity editor, in order to preserve reasonable disk space, removes the imported asset data from the project’s Library folder for those assets that have been deleted. It also removes all assets data for the assets that need to be reimported when switching the target platform. This problem can be easily solved using the Cache Server!

The Cache Server is a separate piece of software that can be installed locally (if you’re working alone) or on a remote server. It collects all the imported asset data from the Library folder and stores all of them until the upper limit is reached (by default it is 50 GB).

Pre-requirements and installation

The Cache Server can be used only by Team License owners (Unity 4) or Unity 5 Professional users (Team License included).

To install the Cache Server, download it from the Unity homepage. The links are frequently updated (Cache Server version changes), so the best is to go there and download the latest version for yourself.

cache server download

After downloading the zip file, unpack it wherever you like to store the cache (locally or on a remote server). Then all you have to do is to double-click on RunWin.cmd file if you’re running it on Windows or open the terminal and execute ./RunLinux.sh on Linux and Mac OS X hosts.

cache server files

Then you have to configure the Cache Server connection for your Unity editor. If there’s more people working on the same project and they have the access to the same server machine that the Cache Server is running on, they should follow this step too.

In the Unity go to the Preferences window. Then in the Cache Server section enable the Use Cache Server option and type in your server ip or hostname.

CacheServerEnabled

From now on, importing assets will first check for availability in our newly installed Cache Server, and then download it if present. Be aware that an asset will be present on the Cache Server if it was imported at least once after the Cache Server was enabled. Therefore, it may take some time before you notice the difference.

using cache server

Use unitypackage files to share part of your project

Did you know that there’s an easier way to share your Unity project files than zipping it all into a single archive? Check the unitypackage file format!

Unitypackage is a basic distribution format of the Unity Asset Store and you might not have even known about it because it is completely transparent for the end user! Yet you can use it for your own purposes and share only a part or whole project. Just select files that you want to share, right-click and choose Export Package option from the context menu.

export package option

You may exclude some files from the package by unchecking them. Decide if you want to include dependencies needed for the assets to work (1) and then export the package (2). Note that Include dependencies option will always include all source files.

Export package window

Finally send the resulting unitypackage file to anyone that you want to share your work with and tell them to double-click on it. It’s just that simple!

0418fccf-6bee-4052-a8bf-0fe3828653b4

The receiver may choose if they want to import all files into the project or only a few of them. Then by clicking on the import button (1) selected files will be added to the project.

Why you should care?

You may ask “Why just not zip part of my project?”. There are at least three reasons why not to do it:

  • Unity caches its resources in the memory before saving it to the hard drive. Accidentally you may copy files that are yet to be updated.
  • You will not know if you zip all necessary files. Unity Export Package window allows you to include all needed dependencies as well.
  • If you have meta files disabled, zipping your files will break the references between them.