This Git-inspired puzzle game is about building a timeline. Each point on the timeline is a snapshot of your progress in the game. The puzzles cannot be solved in a linear timeline, so you will need to create branching timelines, move between them, and merge branches back together. 

Controls

Action	Button
Move Sideways	Left/Right arrows or A/D
Climb Ladders	Up/Down arrows or W/S
Pick up/Use/Drop items	Space Bar or Enter Key
Enter 3-digit combination	0-9 on keyboard or screen

This game has two screens: the Puzzle Screen and the Timeline Screen. The Puzzle Screen is played using the controls listed above. The Timeline Screen is only played using a mouse.

Puzzle Screen

The Puzzle Screen displays the puzzle that you need to solve.

• The goal of each puzzle is to advance to the right side of the screen and on to the next one. 
• Ladders and keys can be picked up. 
  
• Keys are used to unlock doors and boxes. The key's colour (or shape) must match the door/box colour (or shape). 
• Doors with combination locks require 3-digit codes, which are found on signboards.
• When you're holding an item, you cannot pick up another item or climb a ladder.

• The "Save" button adds a new snapshot that can be accessed by the Timeline Screen. 
• The "Timeline" button navigates you to the Timeline Screen.

Timeline Screen

The Timeline Screen displays the timeline that you build, the buttons you use to manipulate the timeline, and a view of the Puzzle Screen. 

The snapshot on the timeline with a green outline represents where you are currently at on the timeline. 

Adding to the Timeline

• To create snapshots on the timeline: click the "Save" button on either screen.
• Each time you save, you add a new snapshot to the timeline. Saving does not overwrite your existing snapshots. 
• The new snapshot is attached to the right of the current snapshot, and it becomes the new current snapshot. 
• If there is already a snapshot to the right of the current snapshot, the new snapshot will still appear to the right of the current snapshot. It will create a new branch in the timeline.

Moving Around the Timeline

• To move to a snapshot: select the "Load" button and then click on a snapshot. 
• The "Load" button is selected by default, so you often don't need to manually click on it before clicking on the snapshot. 
• The selected snapshot will then be loaded onto the Puzzle Screen, and will become the current snapshot. 

Merging Branches

• To merge a branch with the current branch: select the merge button, then click on the snapshot you want to merge with. If there is a more than one resolution then you will be prompted to select your preferred outcome. 
• A merge combines two snapshots, bringing together the changes that have been made on each branch since the point where they diverged.
• You can merge two branches from any snapshots along those branches. The snapshots do not need to be on the end of the branches.
• If you need to resolve a merge then you wont be able to do anything else until the merge is resolved.
  
• There is an explanation and example of how merges work below.

Comparing Snapshots

• To compare two snapshots: load one of the snapshots, select the compare button, then click on the other snapshot that you want to compare. 
• Comparing is not required for any puzzle, and it has no impact on the puzzle. 
• Comparing can be a useful tool when trying to work out why (or why not) a merge has multiple possible resolutions.

Deleting Snapshots

• To delete a snapshot: select the delete button then click on the snapshot that you want to delete.
• All descendants of the deleted snapshot will also get deleted.
• Deleting is not required for any puzzle. This tool only exists as a way of cleaning up the timeline.
  
• You cannot delete the starting snapshot. 
• If the current snapshot gets deleted then the selected snapshot's predecessor becomes the current snapshot. 

How a Merge Works

In this level, you need to bring the ladder up onto the second platform.
(This level isn't in the game.)

You can pick up the ladder and you can climb the ladder, but you can't do both simulatenously. To resolve this problem, you can create separate branches where you pick up the ladder in one branch and you climb the ladder in the other branch.

When you merge, the game will look at the current snapshot (3) and the snapshot you want to merge with (2).  It searches for a snapshot that is a "common ancestor" (1) which is a snapshot where you can follow arrows leading from it to the snapshots you want to merge.

The game then compares the common ancestor to the two snapshots that are being merged to figure out what has changed since their branches diverted. The game then applies all those changes to the ancestor snapshot to create a new merged snapshot (4). 

If the same variable changes in different ways in both braches in then you will need to resolve the merge. For example, if you had to move the ladder to different positions in both branches then you must decide where it ends up.

When a position in two snapshots are close enough then they don't count as a change, and this could prevent a merge from having multiple resolutions. You can use the Compare tool to check if the ladder was moved far enough in snapshot 3 to be considered a change. In this case, the ladder was detected as a change, which is why you are prompted to resolve the merge.

Bonus Challenges

• Reach the end with the fewest number of snapshots 
• Reach the end with the fewest number of merges that need to be resolved
  
• Find the 2 hidden rooms

Both hidden rooms involve solving a puzzle to reach them. They require you to be observant, but they don't involve fake walls or climbing out the camera's field of view. Also, the trophies don't help you with the puzzles.

Future Work

This game mechanic was inspired by Git. Originally this game was meant to be a tutorial on how to use Git, but I didn't make that because there are features in Git that I did not want to include in this game.

If I ever make a Git tutorial game (or if you want to) then here are a things I would do differently:

• Add a branching story to the game 
• Include more types of variables such as money, health, fuel, plot events, or potion ingredients 
• Include binary variables where both values are important
• Find a nicer way of representing position
• Gradually add buttons to the timeline menu 
• Add cherry picking, reverting, and other Git tools 
• Let the player add messages to snapshots
• Expose the inner workings of a merge without overwhelming the player
• Show unsaved changes
• Intuitive UI

I have attempted to make a game like this once before, but it was text-based and required you to directly use Git. You can download it on Github: https://github.com/jakbrtz/Git-Game

UPDATE: I made a full version of this game that includes half of the bullet points listed above. You can play it here: https://jakebortz.itch.io/anastomosis