refactor: make level metadata easier to read

danielzting · danielzting · commit 7cdc05f99d1c · 2020-08-18T13:13:56.000-05:00
Instead of keeping them in constants, ComparisonSort now extracts them
from its own source code.
diff --git a/levels/bogo_sort.gd b/levels/bogo_sort.gd
@@ -1,14 +1,14 @@
-class_name BogoSort
-extends ComparisonSort
+"""
+BOGOSORT
 
-const NAME = "BOGOSORT"
-const ABOUT = """
 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
+
 func _init(array).(array):
     pass
 
diff --git a/levels/bubble_sort.gd b/levels/bubble_sort.gd
@@ -1,19 +1,19 @@
-class_name BubbleSort
-extends ComparisonSort
+"""
+BUBBLE SORT
 
-const NAME = "BUBBLE SORT"
-const ABOUT = """
 Bubble sort iterates through the array and looks at each pair of
 elements, swapping them if they are out of order. When it has gone
 through the entire array without swapping a single pair, it has
 finished. Though simple to understand, bubble sort is hopelessly
 inefficient on all but the smallest of arrays.
-"""
-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 ACTIONS = {
     "SWAP": "Left",
     "CONTINUE": "Right",
diff --git a/levels/cocktail_sort.gd b/levels/cocktail_sort.gd
@@ -1,16 +1,16 @@
-class_name CocktailSort
-extends ComparisonSort
+"""
+COCKTAIL SORT
 
-const NAME = "COCKTAIL SORT"
-const ABOUT = """
 Cocktail shaker sort is a variation of bubble sort that
 alternates going backwards and forwards.
-"""
-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 ACTIONS = {
     "SWAP": "Left",
     "CONTINUE": "Right",
diff --git a/levels/comb_sort.gd b/levels/comb_sort.gd
@@ -1,15 +1,15 @@
-class_name CombSort
-extends ComparisonSort
+"""
+COMB SORT
 
-const NAME = "COMB SORT"
-const ABOUT = """
 Comb sort is a variant of bubble sort that operates on gapped arrays.
-"""
-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 SHRINK_FACTOR = 1.3
 const ACTIONS = {
     "SWAP": "Left",
diff --git a/levels/comparison_sort.gd b/levels/comparison_sort.gd
@@ -11,9 +11,13 @@ const EFFECTS = {
 }
 
 const DISABLE_TIME = 1.0
+var NAME = _get_header().split("  ")[0]
+var DESCRIPTION = _get_header().split("  ")[1]
+var CONTROLS = _get_header().split("  ")[2]
 
 var array: ArrayModel
 var moves = 0
+var test = _get_header().split("  ")[0]
 
 var _timer = Timer.new()
 
@@ -26,6 +30,9 @@ 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)
 
diff --git a/levels/insertion_sort.gd b/levels/insertion_sort.gd
@@ -1,20 +1,20 @@
-class_name InsertionSort
-extends ComparisonSort
+"""
+INSERTION SORT
 
-const NAME = "INSERTION SORT"
-const ABOUT = """
 Insertion sort goes through the array and inserts each
 element into its correct position. It is most similar to how most people
 would sort a deck of cards. It is also slow on large arrays but it is
 one of the faster quadratic algorithms. It is often used to sort smaller
 subarrays in hybrid sorting algorithms.
-"""
-const CONTROLS = """
+
 Hit LEFT ARROW to swap the two highlighted elements as long as they are
 out of order. When this is no longer the case, hit RIGHT ARROW to
 advance.
 """
 
+class_name InsertionSort
+extends ComparisonSort
+
 const ACTIONS = {
     "SWAP": "Left",
     "CONTINUE": "Right",
diff --git a/levels/merge_sort.gd b/levels/merge_sort.gd
@@ -1,20 +1,20 @@
-class_name MergeSort
-extends ComparisonSort
+"""
+MERGE SORT
 
-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.
 """
 
+class_name MergeSort
+extends ComparisonSort
+
 const ACTIONS = {
     "LEFT": "Left",
     "RIGHT": "Right",
diff --git a/levels/quick_sort.gd b/levels/quick_sort.gd
@@ -1,22 +1,22 @@
-class_name QuickSort
-extends ComparisonSort
+"""
+QUICKSORT
 
-const NAME = "QUICKSORT"
-const ABOUT = """
 Quicksort designates the last element as the pivot and puts everything
 less than the pivot before it and everything greater after it. This
 partitioning is done by iterating through the array while keeping track
 of a pointer initially set to the first element. Every time an element
 less than the pivot is encountered, it is swapped with the pointed
 element and the pointer moves forward. At the end, the pointer and pivot
 are swapped, and the process is repeated on the left and right halves.
-"""
-const CONTROLS = """
+
 If the highlighted element is less than the pivot or the pivot has been
 reached, press LEFT ARROW to swap it with the pointer. Otherwise, press
 RIGHT ARROW to move on.
 """
 
+class_name QuickSort
+extends ComparisonSort
+
 const ACTIONS = {
     "SWAP": "Left",
     "CONTINUE": "Right",
diff --git a/levels/selection_sort.gd b/levels/selection_sort.gd
@@ -1,20 +1,21 @@
-class_name SelectionSort
-extends ComparisonSort
+"""
+SELECTION SORT
 
-const NAME = "SELECTION SORT"
-const ABOUT = """
 Selection sort incrementally builds a sorted array by repeatedly looking
 for the smallest element and swapping it onto the end of the sorted
 portion of the array, which initially starts with size zero but grows
 after each round. It is faster than an unoptimized bubble sort but
 slower than insertion sort.
-"""
-const CONTROLS = """
+
 Keep on hitting RIGHT ARROW until you encounter an element that is
 smaller than the left highlighted element, then hit LEFT ARROW and
 repeat.
 """
 
+
+class_name SelectionSort
+extends ComparisonSort
+
 const ACTIONS = {
     "SWAP": "Left",
     "CONTINUE": "Right",
diff --git a/levels/shell_sort.gd b/levels/shell_sort.gd
@@ -1,17 +1,16 @@
-class_name ShellSort
-extends ComparisonSort
+"""
+SHELL SORT
 
-const NAME = "SHELL SORT"
-const ABOUT = """
 Shell sort is a variation of insertion sort that sorts arrays separated
 by gaps.
-"""
-const CONTROLS = """
+
 Hit LEFT ARROW to swap the two highlighted elements as long as they are
 out of order. When this is no longer the case, hit RIGHT ARROW to
-advance.
 """
 
+class_name ShellSort
+extends ComparisonSort
+
 const ACTIONS = {
     "SWAP": "Left",
     "CONTINUE": "Right",
diff --git a/scenes/levels.tscn b/scenes/levels.tscn
@@ -83,7 +83,7 @@ margin_right = 889.0
 margin_bottom = 198.0
 custom_constants/separation = 50
 
-[node name="About" type="Label" parent="LevelSelect/Preview/InfoBorder/Info"]
+[node name="Description" type="Label" parent="LevelSelect/Preview/InfoBorder/Info"]
 margin_right = 546.0
 margin_bottom = 178.0
 size_flags_horizontal = 3
diff --git a/scripts/levels.gd b/scripts/levels.gd
@@ -23,7 +23,7 @@ func _ready():
     var scores = $LevelsBorder/Levels/LevelsContainer/Scores
     for level in LEVELS:
         var button = Button.new()
-        button.text = level.NAME
+        button.text = level.new(ArrayModel.new()).NAME
         button.align = Button.ALIGN_LEFT
         button.connect("focus_entered", self, "_on_Button_focus_entered")
         button.connect("pressed", self, "_on_Button_pressed", [level])
@@ -74,8 +74,8 @@ func _on_Button_focus_entered(size=_level.array.size):
         $Timer.start()
         set_process_input(true)
     _level = _get_level(get_focus_owner().text).new(ArrayModel.new(size))
-    $Preview/InfoBorder/Info/About.text = _cleanup(_level.ABOUT)
-    $Preview/InfoBorder/Info/Controls.text = _cleanup(_level.CONTROLS)
+    $Preview/InfoBorder/Info/Description.text = _level.DESCRIPTION
+    $Preview/InfoBorder/Info/Controls.text = _level.CONTROLS
     # Start over when simulation is finished
     _level.connect("done", self, "_on_Button_focus_entered")
     # Replace old display with new
@@ -101,11 +101,8 @@ func _on_Button_pressed(level):
 
 func _get_level(name):
     for level in LEVELS:
-        if level.NAME == name:
+        if level.new(ArrayModel.new()).NAME == name:
             return level
 
 func _on_Timer_timeout():
     _level.next(null)
-
-func _cleanup(string):
-    return string.strip_edges().replace("\n", " ")
diff --git a/scripts/play.gd b/scripts/play.gd
@@ -5,7 +5,7 @@ var _level = GlobalScene.get_param(
     "level", preload("res://scripts/levels.gd").LEVELS[0])
 
 func _ready():
-    $HUDBorder/HUD/Level.text = _level.NAME
+    $HUDBorder/HUD/Level.text = _level.new(ArrayModel.new()).NAME
 
 func _process(delta):
     if _start_time >= 0:
@@ -56,7 +56,7 @@ func _on_Level_done(level):
     $HUDBorder/HUD.add_child(tier)
     restart.grab_focus()
     var save = GlobalScene.read_save()
-    var name = _level.NAME
+    var name = level.NAME
     var size = str(GlobalScene.get_param("size", ArrayModel.DEFAULT_SIZE))
     if not name in save:
         save[name] = {}
