feat: add merge sort

Increased array size from 10 to 16 so divide and conquer algorithms
split perfectly. However, this makes heights hard to distinguish during
merge sort's endgame.

Author: danielzting

levels/bubble_sort.gd

@@ -38,8 +38,8 @@ func next(action):
         _swapped = false
 
 func get_effect(i):
-    if i >= _end:
-        return EFFECTS.DIMMED
     if i == _index or i == _index + 1:
         return EFFECTS.HIGHLIGHTED
+    if i >= _end:
+        return EFFECTS.DIMMED
     return EFFECTS.NONE

levels/merge_sort.gd

@@ -0,0 +1,80 @@
+class_name MergeSort
+extends ComparisonSort
+
+const NAME = "MERGE SORT"
+const ABOUT =  """
+Merge sort is an efficient sorting algorithm that splits the array into
+single-element chunks. Then it merges each pair of chunks until only one
+sorted chunk is left by repeatedly choosing the smaller element at the
+head of each chunk and moving the head back. However, it needs an entire
+array's worth of auxiliary memory.
+"""
+const CONTROLS = """
+Press the ARROW KEY corresponding to the side that the smaller
+highlighted element is on. If you've reached the end of one side, press
+the other side's ARROW KEY.
+"""
+
+var _left = 0 # Index of left subarray pointer
+var _right = 1 # Index of right subarray pointer
+var _sub_size = 2 # Combined size of left and right subarrays
+var _sub_no = 0 # Currently being merged left-right pair number
+
+func _init(array).(array):
+    pass
+
+func next(action):
+    if _left == -1:
+        if action != null and action != ACTIONS.RIGHT:
+            return emit_signal("mistake")
+        _right += 1
+    elif _right == -1:
+        if action != null and action != ACTIONS.LEFT:
+            return emit_signal("mistake")
+        _left += 1
+    elif array.get(_left) <= array.get(_right):
+        if action != null and action != ACTIONS.LEFT:
+            return emit_signal("mistake")
+        _left += 1
+    else:
+        if action != null and action != ACTIONS.RIGHT:
+            return emit_signal("mistake")
+        _right += 1
+    # Test if end of subarrays have been reached
+    if _left == _get_middle():
+        _left = -1
+    if _right == _get_end():
+        _right = -1
+    # If both ends have been reached, merge and advance to next block
+    if _left == -1 and _right == -1:
+        array.sort(_get_begin(), _get_end())
+        _sub_no += 1
+        _left = _get_begin()
+        _right = _get_middle()
+        # If last block has been completed, go up a level
+        if _sub_no == array.size / (_sub_size):
+            _sub_size *= 2
+            _sub_no = 0
+            _left = _get_begin()
+            _right = _get_middle()
+            if _sub_size == array.size * 2:
+                emit_signal("done")
+
+func get_effect(i):
+    if i == _left or i == _right:
+        return EFFECTS.HIGHLIGHTED
+    if i < _sub_no * _sub_size or i >= _sub_no * _sub_size + _sub_size:
+        return EFFECTS.DIMMED
+    return EFFECTS.NONE
+
+func _get_begin():
+    """Get the index of the left subarray's head."""
+    return _sub_no * _sub_size
+
+func _get_middle():
+    """Get the index of the right subarray's head."""
+    return _sub_no * _sub_size + _sub_size / 2
+
+func _get_end():
+    """Get the index of one past the right subarray's tail."""
+    return _sub_no * _sub_size + _sub_size

models/array_model.gd

@@ -32,3 +32,12 @@ func swap(i, j):
     var temp = array[i]
     array[i] = array[j]
     array[j] = temp
+
+func sort(i, j):
+    """Sort the subarray starting at i and up to but not including j."""
+    # Grr to the developer who made the upper bound inclusive
+    var front = array.slice(0, i - 1) if i != 0 else []
+    var sorted = array.slice(i, j - 1)
+    sorted.sort()
+    var back = array.slice(j, size - 1) if j != size else []
+    array = front + sorted + back

views/array_view.gd

@@ -23,7 +23,7 @@ func _init(level):
 func _process(delta):
     """Update heights of rectangles based on array values."""
     for i in range(level.array.size):
-        rects[i].rect_scale.y = -1 # XXX: Override parent Control scale
+        rects[i].rect_scale.y = -1 # HACK: Override scale to bypass weird behavior
         rects[i].color = level.get_effect(i)
         rects[i].rect_size.y = rect_size.y * level.array.get(i) / level.array.size