This topic is for real time cooperation. Like google docs.
More details on real time cooperation here: https://construct3.ideas.aha.io/ideas/C3-I-85
Due to misunderstandings I've had to move the old suggestion to a new topic where it is clear that a cloud based SVN is wanted:
We are skeptical of the practicality and feasability of real-time collaboration. Google Docs is not really a good comparison, since it's easy to make completely isolated changes. For example if Alice edits page 1 of a document and Bob edits page 2, there's no problem. Alternatively Alice can edit one range of cells in a spreadsheet without affecting Bob who edits a different range, etc.
Construct is different in that the internal data structures are more complex. There are many cross-references where things depend on other elements of the project. For example a single event can depend on two object types, global variable, a family, a behavior in that family, and an instance variable in that family. A typical Construct project has a huge amount of such cross-references. This makes it far more difficult to edit something without conflicting with someone else's work.
Here is one example to illustrate the kinds of problem that come up:
1. Alice adds a Sprite.
2. Bob adds an event using that Sprite.
3. Alice presses undo.
This happens even though both Alice and Bob are working in different parts of the editor. It is difficult to see a good solution to this:
- The undo could remove Bob's event only, i.e. there is one shared undo stack. This is probably confusing as pressing undo rolls back other people's work.
- The undo could remove Alice's sprite, which in turn will cause Bob's event to be removed. This is probably also confusing, as again Bob's work suddenly disappears.
- Undo could be disabled. But then we've disabled an essential feature of the editor, which makes it harder to use.
- It could prompt asking what to do. But this would likely appear frequently, making it a pain to get anything done.
This is a simple case too - there are many more significantly more difficult cases. For example what happens if someone renames an object while someone else is editing an expression using it? What if two people submit two conflicting edits exactly simultaneously? It is a daunting prospect to handle hundreds of awkward edge cases like this, while avoiding any chance of corrupting the project, and ensuring the software is still practical to use. This could easily take many months of dedicated development work at the expense of everything else, and have significant on-going mainentance costs too. It also seems risky since the cross-references are so comprehensive it's hard to see real-time collaboration as either constantly trampling other people's changes, or locking so many things that you can't get anything done, raising the chance that we do a huge amount of work for something few people end up using in practice.
Meanwhile existing source control tools like SVN and Git already enable collaboration with folder-based projects. This way is already supported, and works well with a clear way for teams to work on a project simultaneously. They also already provide tools to deal with problems like conflicts. And the fact it is not real-time makes it far simpler - for example there is no chance two people can submit changes exactly simultaneously. We think this is the best solution to focus on, and if there are any difficulties with using this, we'd rather put effort in to ensuring this process works smoothly with Construct.
Given the robustness and quality of existing source control tools; the vast, complex and ongoing development work it would take to make real-time collaboration a reality; and the doubts that it would even be practical to use once it's finally done, we feel it would not be the right thing to work on at this time. We don't want to say "never". It's possible that a much more limited version, such as only editing separate layouts, could be feasible. However it's not something we plan on working on. We encourage anyone interested in team collaboration to look in to source controls and submit suggestions to improve that process if there are any difficulties.