refactor: move level information into constants

This effectively undoes 7cdc05f, which
was honestly a dumb idea to begin with, and turned out to break
exports for some reason after doing a git bisect.

Author: danielzting

levels/bogo_sort.gd

@@ -1,16 +1,13 @@
-"""
-BOGOSORT
-
+class_name BogoSort
+extends ComparisonSort
 
+const NAME = "BOGOSORT"
+const DESCRIPTION = """
 Generates random permutations until the array is sorted.
-
-
+"""
+const CONTROLS = """
 Keep on hitting RIGHT ARROW to CONTINUE and hope for the best!
 """
-
-class_name BogoSort
-extends ComparisonSort
-
 const CODE = """
 def bogosort(a):
     while not a.sorted():

levels/bubble_sort.gd

@@ -1,7 +1,8 @@
-"""
-BUBBLE SORT
-
+class_name BubbleSort
+extends ComparisonSort
 
+const NAME = "BUBBLE SORT"
+const DESCRIPTION = """
 Bubble sort looks at consecutive pairs of elements and swaps them if
 they are out of order, finishing when it has gone through the whole
 array from beginning to end without a single swap. The actual level
@@ -12,15 +13,11 @@ Due to its simplicity, it is commonly taught as the first sorting
 algorithm students learn in computer science classes, but is rarely used
 in real life because it is slow on large data and other simple quadratic
 algorithms like insertion sort perform better.
-
-
+"""
+const CONTROLS = """
 If the two highlighted elements are out of order, hit LEFT ARROW to swap
 them. Otherwise, hit RIGHT ARROW to continue.
 """
-
-class_name BubbleSort
-extends ComparisonSort
-
 const CODE = """
 def bubble_sort(a):
     swapped = true

levels/cocktail_sort.gd renamed to levels/cocktail_shaker_sort.gd

@@ -1,24 +1,21 @@
-"""
-COCKTAIL SORT
-
+class_name CocktailSort
+extends ComparisonSort
 
-Cocktail sort is a variation of bubble sort that alternates going
+const NAME = "COCKTAIL SHAKER SORT"
+const DESCRIPTION = """
+Cocktail shaker sort is a variation of bubble sort that alternates going
 backwards and forwards. The actual level contains an optimization that
 skips over elements guaranteed to be already in place.
 
 Because it is bidirectional, it is slightly faster than bubble sort, but
 is still quadratic and therefore not used on large data.
-
-
+"""
+const CONTROLS = """
 If the two highlighted elements are out of order, hit LEFT ARROW to swap
 them. Otherwise, hit RIGHT ARROW to continue.
 """
-
-class_name CocktailSort
-extends ComparisonSort
-
 const CODE = """
-def cocktail_sort(a):
+def cocktail_shaker_sort(a):
     swapped = true
     while swapped:
         swapped = false

levels/comb_sort.gd

@@ -1,7 +1,8 @@
-"""
-COMB SORT
-
+class_name CombSort
+extends ComparisonSort
 
+const NAME = "COMB SORT"
+const DESCRIPTION = """
 Comb sort is a variant of bubble sort that compares elements a certain
 gap apart instead of consecutive elements. This gap is divided after
 every pass by an experimentally determined optimal factor of about 1.3.
@@ -10,15 +11,11 @@ Once the gap becomes 1, comb sort becomes a regular bubble sort.
 This allows comb sort to get rid of small values near the end more
 quickly, which turns out to be the bottleneck in bubble sort, but still
 has a quadratic worst case.
-
-
+"""
+const CONTROLS = """
 If the two highlighted elements are out of order, hit LEFT ARROW to swap
 them. Otherwise, hit RIGHT ARROW to continue.
 """
-
-class_name CombSort
-extends ComparisonSort
-
 const CODE = """
 def comb_sort(a):
     gap = len(a)

levels/comparison_sort.gd

@@ -11,9 +11,6 @@ const EFFECTS = {
 }
 
 const DISABLE_TIME = 1.0
-var NAME = _get_header().split("   ")[0]
-var DESCRIPTION = _get_header().split("   ")[1].replace("  ", "\n\n")
-var CONTROLS = _get_header().split("   ")[-1]
 
 var array: ArrayModel
 
@@ -28,9 +25,6 @@ func _init(array):
     self.connect("mistake", self, "_on_ComparisonSort_mistake")
     self.connect("done", self, "_on_ComparisonSort_done")
 
-func _get_header():
-    return get_script().source_code.replace("\n", " ").split('"""')[1].strip_edges()
-
 func _ready():
     set_process_input(false)
 

levels/cycle_sort.gd

@@ -1,7 +1,8 @@
-"""
-CYCLE SORT
-
+class_name CycleSort
+extends ComparisonSort
 
+const NAME = "CYCLE SORT"
+const DESCRIPTION = """
 Cycle sort looks at the first element and finds its correct final
 position by counting the number of elements smaller than it. Then it
 saves the element at that index, writes the first element there, and
@@ -11,15 +12,11 @@ demonstration, in the actual level, swaps are used instead.
 This results in a quadratic runtime but gives it the special property
 of being optimal in the number of writes to the array. This makes cycle
 sort useful in situations where writes are very expensive.
-
-
+"""
+const CONTROLS = """
 If the highlighted element is less than the element below the blue
 pointer, hit LEFT ARROW. Otherwise, hit RIGHT ARROW.
 """
-
-class_name CycleSort
-extends ComparisonSort
-
 const CODE = """
 def cycle_sort(a):
     for i in range(len(a)):

levels/insertion_sort.gd

@@ -1,23 +1,20 @@
-"""
-INSERTION SORT
-
+class_name InsertionSort
+extends ComparisonSort
 
+const NAME = "INSERTION SORT"
+const DESCRIPTION = """
 Insertion sort goes through the array and inserts each element into its
 correct place, like how most people would sort a hand of playing cards.
 
 It is one of the fastest quadratic algorithms in practice and is
 efficient on small or almost sorted data. It is also simple, stable, and
 in-place. For these reasons it is sometimes used within faster divide
 and conquer algorithms when the array has been divided to a small size.
-
-
+"""
+const CONTROLS = """
 If the two highlighted elements are out of order, hit LEFT ARROW to swap
 them. Otherwise, hit RIGHT ARROW to continue.
 """
-
-class_name InsertionSort
-extends ComparisonSort
-
 const CODE = """
 def insertion_sort(a):
     for i in range(len(a)):

levels/merge_sort.gd

@@ -1,21 +1,18 @@
-"""
-MERGE SORT
-
+class_name MergeSort
+extends ComparisonSort
 
+const NAME = "MERGE SORT"
+const DESCRIPTION = """
 Merge sort merges subarrays of increasing size by setting a pointer to
 the head of each half. Then it repeatedly copies the smaller pointed
 element and increments that side's pointer. When one side is exhausted,
 it copies the rest of the other side and overwrites the two halves with
 the merged copy.
-
-
+"""
+const CONTROLS = """
 Press the ARROW KEY corresponding to the side that the smaller
 highlighted element is on or the non-exhausted side.
 """
-
-class_name MergeSort
-extends ComparisonSort
-
 const CODE = """
 def merge_sort(a):
     size = 1

levels/odd_even_sort.gd

@@ -1,22 +1,19 @@
-"""
-ODD-EVEN SORT
-
+class_name OddEvenSort
+extends ComparisonSort
 
+const NAME = "ODD-EVEN SORT"
+const DESCRIPTION = """
 Odd-even sort is a variant of bubble sort that alternates between
 comparing consecutive odd-even and even-odd indexed pairs.
 
 It is not of much use on a single processor as it is designed for
 parallel processors, which can perform every comparison in a single pass
 at the same time, thus making the algorithm much more efficient.
-
-
+"""
+const CONTROLS = """
 If the two highlighted elements are out of order, hit LEFT ARROW to swap
 them. Otherwise, hit RIGHT ARROW to continue.
 """
-
-class_name OddEvenSort
-extends ComparisonSort
-
 const CODE = """
 def odd_even_sort(a):
     swapped = true

levels/quick_sort.gd

@@ -1,7 +1,8 @@
-"""
-QUICKSORT
-
+class_name QuickSort
+extends ComparisonSort
 
+const NAME = "QUICKSORT"
+const DESCRIPTION = """
 Quicksort designates the last element as the pivot and sets a pointer to
 the first element. Then it iterates through the array. Every time an
 element smaller than the pivot is encountered, that element is swapped
@@ -11,15 +12,11 @@ recursively repeated on the left and right halves.
 
 Quicksort competes with other linearithmic algorithms like merge sort,
 which it is faster than at the tradeoff of stability.
-
-
+"""
+const CONTROLS = """
 If the highlighted element is less than the pivot or the pivot has been
 reached, press LEFT ARROW. Otherwise, press RIGHT ARROW.
 """
-
-class_name QuickSort
-extends ComparisonSort
-
 const CODE = """
 def quicksort(a, low=0, high=len(a) - 1):
     if low < high:

levels/selection_sort.gd

@@ -1,23 +1,19 @@
-"""
-SELECTION SORT
-
+class_name SelectionSort
+extends ComparisonSort
 
+const NAME = "SELECTION SORT"
+const DESCRIPTION = """
 Selection sort incrementally builds a sorted subarray by finding the
 smallest unprocessed element and putting it in place.
 
 It is not very useful in real life as it is beat by insertion sort.
 However, it has the distinguishing feature of making the least number
 of swaps in the worst case.
-
-
+"""
+const CONTROLS = """
 If the two highlighted elements are out of order, hit LEFT ARROW to swap
 them. Otherwise, hit RIGHT ARROW to continue.
 """
-
-
-class_name SelectionSort
-extends ComparisonSort
-
 const CODE = """
 def selection_sort(a):
     for i in range(len(a)):

levels/shell_sort.gd

@@ -1,7 +1,8 @@
-"""
-SHELL SORT
-
+class_name ShellSort
+extends ComparisonSort
 
+const NAME = "SHELL SORT"
+const DESCRIPTION = """
 Shell sort is a variant of insertion sort that compares elements a
 certain gap apart instead of consecutive elements. This gap is divided
 by 2 after every pass. Once the gap becomes 1, shell sort becomes a
@@ -10,15 +11,11 @@ regular insertion sort.
 This allows the final pass of insertion sort to avoid having to move
 elements long distances. However, it still has a quadratic worst case,
 which can be reduced with more complex gap sequences.
-
-
+"""
+const CONTROLS = """
 If the two highlighted elements are out of order, hit LEFT ARROW to swap
 them. Otherwise, hit RIGHT ARROW to continue.
 """
-
-class_name ShellSort
-extends ComparisonSort
-
 const CODE = """
 def shell_sort(a):
     gap = len(a)

project.godot

@@ -42,7 +42,7 @@ _global_script_classes=[ {
 "base": "ComparisonSort",
 "class": "CocktailSort",
 "language": "GDScript",
-"path": "res://levels/cocktail_sort.gd"
+"path": "res://levels/cocktail_shaker_sort.gd"
 }, {
 "base": "ComparisonSort",
 "class": "CombSort",

scripts/levels.gd

@@ -48,8 +48,12 @@ func _reload():
     _restart()
     _load_scores(_level)
     $NamesContainer/Names/Current.text = _level.NAME
-    $Level/Left/Code.text = _level.DESCRIPTION + "\n\n" + _level.CODE.strip_edges()
-    $Level/Right/Info/ControlsContainer/Controls.text = _level.CONTROLS
+    $Level/Left/Code.text = _format(_level.DESCRIPTION) + "\n\n" + _level.CODE.strip_edges()
+    $Level/Right/Info/ControlsContainer/Controls.text = _format(_level.CONTROLS)
+
+func _format(text):
+    # Helper method to format text
+    return text.strip_edges().replace("\n", " ").replace("  ", "\n\n")
 
 func _restart():
     set_process_input(true)