How to collaborate on Construct projects with GitHub

31

Index

Stats

6,162 visits, 19,345 views

Translations

This tutorial hasn't been translated.

Tools

Adding collaborators

Your other team-mates also need to get access to your repository. You can add collaborators in the Settings section of your repository on the GitHub website. Note there may be limits depending on your account tier. For more details on inviting collaborators, see GitHub's help on Inviting collaborators to a personal repository.

Once you've invited a collaborator, they should also be able to access the repository on the GitHub website. Then the process is similar to when you first created the repository: download and install GitHub Desktop, then on the website click Clone or download, then Open in Desktop. As before they can choose a local folder to clone the repository to, and it'll download all the project files there. Then they're all set up to push and pull changes the same way you do.

Receiving other changes

You'll frequently want to receive any other changes made to the repository if you have other team-mates making changes.

All you need to do is click Pull origin (sometimes also shown as Fetch origin) in GitHub Desktop to pull any new changes back from the server to your local working copy. However whenever you do this, make sure you have closed your project in Construct. This will update your project files but Construct won't see that they've changed, and next time you press 'Save' you might revert the changes and end up with a mess. Making sure you've closed your project guarantees you won't accidentally overwrite anything, and ensures that when you next open it, Construct will reflect all the latest updates in the editor.

GitHub Desktop can also alert you if there are changes waiting to be pulled from the server, as shown below. Clicking Pull origin will receive those changes - but as noted be sure to make sure your Construct project is closed before doing that.

Thanks to the magic of source control, this will also merge changes with your own files. This is a key feature of source control. Providing you have not changed the same files in the same places, everything should just automatically merge in to a single coherent project.

Conflict resolution

What happens if two people do modify the same part of the same file at the same time? This creates a conflict.

Conflicts are something you should aim to avoid at all costs, since they can easily be complicated and confusing. You should avoid working on the same parts of the project at the same time wherever possible. However they can end up happening accidentally from time to time anyway.

As an example, suppose two people commit a change to the project description. One person changes it to "My awesome project!", commits it and pushes it to the server. Then a second person changes it to something different, like "My SUPER awesome project!", commits that, and attempts to push it to the server. GitHub Desktop will stop the second person pushing because it knows there are changes it hasn't received yet. So it will require you to pull first.

This is where the conflict happens. The second person sees a conflict because they have their own change to the project description, but they are trying to receive a different change to the project description. Which description is supposed to be there? This cannot be automatically resolved, so it has to ask you to fix it.

You will have to manually to resolve this. Often the easiest solution is to abort the merge, then revert your local changes. You can revert a commit in the History section.

However in some cases you will have a lot of changes and you don't want to lose all that work. So alternatively you can manually edit the file to resolve the conflict. The default suggestion is to use Visual Studio Code, a coding editor, to edit the file as text. (You'll need to download and install that first to use it.) It has special support for handling conflicts. In this case it opens the project file with the conflicting description in VS Code, and then if you scroll down it highlights the conflict and also provides options on how to resolve it:

If you know what you are doing, you can edit the text manually. However the easiest way to solve it is to click either:

  • Accept Current Change: use the change you were trying to commit. Remember it's the second person who is resolving the conflict, so this means the second description is used, overwriting the first description.
  • Accept Incoming Change: use the change from the repository. This means the first person's description is used, overwriting the second description.

In this case we'll do with Accept Current Change, so the second description is used. It's possible there will be other conflicts in the file too, so you may need to scroll through the file and fix them all. Once everything is resolved, save the file and close it. GitHub now identifies that there are no conflicts left, so now Commit merge is enabled and you can now continue to pull the changes from the repository.

Note the way GitHub handles this is it adds a second commit that deals with merging the conflict. Then you can finally push your change, and the project is updated on the server.

A good way to review what happened is to look at the commit history on the GitHub website. You can view a list of each commit in the order they were pushed, and see the differences in the files they changed.

  • 9 Comments

  • Order by
Want to leave a comment? Login or Register an account!
  • I've been waiting for this. Thank you finally!!

  • Thanks for sharing this tutorial 👍

    It helps to solve my current problem.

  • After you invite people to join the repository, how do they acccess the construct project?

  • Very cool, when using this though, if I modify the position of an object or add new object etc, changes appear in my GIT commit list. However if I change a tilemap, adding or removing tiles, those changes do not appear in the commit list.

      • [-] [+]
      • 2
      • Ashley's avatar
      • Ashley
      • Construct Team Founder
      • 2 points
      • (3 children)

      All changes should appear in your commit list. If changes do not appear, then you have not saved the project, and the changes won't be there when you next open the project either.

      • Recorded a quick video showing the issue: youtu.be/QRjykEozW-U

      • I've tested a few times, certainly saving the project - if I move an object and save, it appears. If I modify a tilemap and save then nothing appears in the commit list.

        What's interesting is if I edit the tile map and then do something like move an objects position, when I commit the changes the tile map edits are saved. So that data is being captured, its just if I edit the tilemap and do nothing else, git thinks I've made no edits to the project and nothing appears in the commit list.

          • [-] [+]
          • 1
          • Ashley's avatar
          • Ashley
          • Construct Team Founder
          • 1 points
          • *
          • (0 children)

          Tilemap data is saved in the corresponding layout JSON file, so check for changes there. Maybe GitHub Desktop isn't checking there or something, or perhaps you forgot to add the files in the first place.

  • wow. That's a great resource. I haven't used that yet but I really like it