Implement scoring

Author: dwayne

herbert/level.py

@@ -47,23 +47,13 @@ def fromfile(cls, file, *, nrows=25, ncols=25):
 
         field = field[:-1]
 
-        line = file.readline(5)
-        if line.endswith('\n'):
-            line = line[:-1]
+        points = _readint(file, 7, cls.NUMBER_PATTERN, 1, 1000000, nrows + 1, newline=True)
+        max_bytes = _readint(file, 4, cls.NUMBER_PATTERN, 1, 1000, nrows + 2)
 
-        match = cls.NUMBER_PATTERN.fullmatch(line)
-        error = ValueError('expected a positive integer in the range [1, 1000) at line %d: %s' % (nrows + 1, line))
+        return cls(field, points, max_bytes, nrows, ncols)
 
-        if match:
-            max_bytes = int(line)
-            if max_bytes < 1 or max_bytes >= 1000:
-                raise error
-        else:
-            raise error
-
-        return cls(field, max_bytes, nrows, ncols)
-
-    def __init__(self, field, max_bytes, nrows, ncols):
+    def __init__(self, field, points, max_bytes, nrows, ncols):
+        self.points = points
         self.max_bytes = max_bytes
         self.nrows = nrows
         self.ncols = ncols
@@ -154,6 +144,28 @@ def _parse(self, field):
         self.inaccessible_spots = inaccessible_spots
 
 
+def _readint(file, size, pattern, lo, hi, row, newline=False):
+    line = file.readline(size)
+    error = ValueError('expected a positive integer in the range [%d, %d) at line %d: %s' % (lo, hi, row, line))
+
+    if line.endswith('\n'):
+        line = line[:-1]
+    elif newline:
+        raise error
+
+    match = pattern.fullmatch(line)
+
+    if match:
+        result = int(line)
+
+        if result < lo or result >= hi:
+            raise error
+
+        return result
+
+    raise error
+
+
 def _extend_horizontally(grid, hseen, row, col, nrows, ncols):
     len = 0
     hseen.add((row, col))
@@ -270,6 +282,7 @@ def __init__(self, level, robot, gray_buttons, white_buttons):
         self.robot = robot
         self.gray_buttons = gray_buttons
         self.white_buttons = white_buttons
+        self.total_buttons = len(white_buttons)
         self.npressed = 0       # the number of white buttons pressed
         self.max_npressed = 0   # the maximum number of white buttons pressed
         self.completed = False  # True iff all the white buttons have been pressed
@@ -290,11 +303,42 @@ def step(self, command):
                     if self.npressed > self.max_npressed:
                         self.max_npressed = self.npressed
 
-                    if not self.completed and self.white_buttons and self.npressed == len(self.white_buttons):
+                    if not self.completed and self.white_buttons and self.npressed == self.total_buttons:
                         self.completed = True
         elif command == 'l':
             self.robot.turn_left()
         elif command == 'r':
             self.robot.turn_right()
         else:
             raise ValueError('not a command: %s' % command)
+
+    def score(self, bytes):
+        return calculate_score(self.level.points, self.level.max_bytes, self.total_buttons, self.npressed, bytes)
+
+
+def calculate_score(points, max_bytes, total_buttons, buttons, bytes):
+    """Calculates the score for a level.
+
+    points: the points assigned for solving the level (based on difficulty)
+    max_bytes: the maximum number of bytes for the level
+    total_buttons: the number of white buttons on the level
+    buttons: the number of white buttons pressed
+    bytes: the number of bytes actually used
+    """
+
+    if buttons == total_buttons and bytes <= max_bytes:
+        # level solved
+        return (points * max_bytes) // bytes
+
+    # level unsolved
+    assert buttons < total_buttons or bytes > max_bytes
+
+    points_per_button = 0
+
+    if bytes <= max_bytes:
+        points_per_button = points // (2 * total_buttons)
+
+    if max_bytes < bytes <= 2*max_bytes:
+        points_per_button = points * (2*max_bytes - bytes) // (2 * max_bytes * total_buttons)
+
+    return buttons * points_per_button

tests/test_level.py

@@ -20,6 +20,7 @@ def setUp(self):
         file.write('..*u*..\n')
         file.write('..***..\n')
         file.write('.......\n')
+        file.write('1000\n')
 
     def tearDown(self):
         self.file.close()
@@ -32,6 +33,7 @@ def test_when_file_ends_with_a_newline(self):
 
         self.assertEqual(level.nrows, 13)
         self.assertEqual(level.ncols, 7)
+        self.assertEqual(level.points, 1000)
         self.assertEqual(level.max_bytes, 10)
         self.assertEqual(level.robot, (10, 3, 'u'))
 
@@ -61,6 +63,7 @@ def test_when_file_does_not_end_with_a_newline(self):
 
         level = Level.fromfile(self.file, nrows=13, ncols=7)
 
+        self.assertEqual(level.points, 1000)
         self.assertEqual(level.max_bytes, 10)
 
 
@@ -114,43 +117,64 @@ def test_when_line_too_long(self):
         with self.assertRaisesRegex(ValueError, 'line 2 is not 1 character long'):
             Level.fromfile(self.file, nrows=3, ncols=1)
 
-    def test_when_max_bytes_non_positive(self):
-        self.file.write('.\n0')
+    def test_when_points_non_positive(self):
+        self.file.write('.\n0\n1')
         self.file.seek(0)
 
         with self.assertRaisesRegex(ValueError, 'expected a positive integer .* at line 2: 0'):
             Level.fromfile(self.file, nrows=1, ncols=1)
 
+    def test_when_points_too_large(self):
+        self.file.write('.\n1000000\n1')
+        self.file.seek(0)
+
+        with self.assertRaisesRegex(ValueError, 'expected a positive integer in the range \[1, 1000000\) at line 2: 1000000'):
+            Level.fromfile(self.file, nrows=1, ncols=1)
+
+    def test_when_points_not_a_number(self):
+        self.file.write('.\na\n1')
+        self.file.seek(0)
+
+        with self.assertRaisesRegex(ValueError, 'expected a positive integer .* at line 2: a'):
+            Level.fromfile(self.file, nrows=1, ncols=1)
+
+    def test_when_max_bytes_non_positive(self):
+        self.file.write('.\n1\n0')
+        self.file.seek(0)
+
+        with self.assertRaisesRegex(ValueError, 'expected a positive integer .* at line 3: 0'):
+            Level.fromfile(self.file, nrows=1, ncols=1)
+
     def test_when_max_bytes_too_large(self):
-        self.file.write('.\n1000')
+        self.file.write('.\n1\n1000')
         self.file.seek(0)
 
-        with self.assertRaisesRegex(ValueError, 'expected a positive integer in the range \[1, 1000\) at line 2: 1000'):
+        with self.assertRaisesRegex(ValueError, 'expected a positive integer in the range \[1, 1000\) at line 3: 1000'):
             Level.fromfile(self.file, nrows=1, ncols=1)
 
     def test_when_max_bytes_not_a_number(self):
-        self.file.write('.\na')
+        self.file.write('.\n1\na')
         self.file.seek(0)
 
-        with self.assertRaisesRegex(ValueError, 'expected a positive integer .* at line 2: a'):
+        with self.assertRaisesRegex(ValueError, 'expected a positive integer .* at line 3: a'):
             Level.fromfile(self.file, nrows=1, ncols=1)
 
     def test_when_too_many_robots(self):
-        self.file.write('.u.\n..d\n5')
+        self.file.write('.u.\n..d\n1\n1')
         self.file.seek(0)
 
         with self.assertRaisesRegex(ValueError, 'too many robots, .* \(2, 3\)'):
             Level.fromfile(self.file, nrows=2, ncols=3)
 
     def test_when_improper_wall(self):
-        self.file.write('..**.*.\n1')
+        self.file.write('..**.*.\n1\n1')
         self.file.seek(0)
 
         with self.assertRaisesRegex(ValueError, 'improper wall at \(1, 6\)'):
             Level.fromfile(self.file, nrows=1, ncols=7)
 
     def test_when_no_robot(self):
-        self.file.write('..****.\n1')
+        self.file.write('..****.\n1\n1')
         self.file.seek(0)
 
         with self.assertRaisesRegex(ValueError, 'no robot found'):

tests/test_runtime_environment.py

@@ -12,6 +12,7 @@ def setUp(self):
         file.write('.*r.w.g.w.\n')
         file.write('.***......\n')
         file.write('..........\n')
+        file.write('50\n')
         file.write('11')
         file.seek(0)
 
@@ -131,3 +132,34 @@ def test_sslsrssssrsrss(self):
         self.assertFalse(self.re.white_buttons[(2, 8)].pressed)
         self.assertEqual(self.re.max_npressed, 2)
         self.assertTrue(self.re.completed)
+
+
+class ScoreTestCase(unittest.TestCase):
+    def test_example1(self):
+        file = io.StringIO()
+        file.write('.r.wwwwwwwwwwwwwwwwwwww.\n')
+        file.write('100\n')
+        file.write('10\n')
+        file.seek(0)
+
+        level = Level.fromfile(file, nrows=1, ncols=24)
+        re = level()
+
+        for _ in range(25):
+            re.step('s')
+
+        # points = 100
+        # max_bytes = 10
+        # total_buttons = 20
+        # buttons = 20
+
+        # bytes = 10
+        self.assertEqual(re.score(10), 100)
+
+        # bytes = 5
+        self.assertEqual(re.score(5), 200)
+
+        # bytes = 15
+        self.assertEqual(re.score(15), 20)
+
+        file.close()

tests/test_scoring.py

@@ -0,0 +1,34 @@
+import unittest
+
+from herbert.level import calculate_score
+
+
+class ScoringTestCase(unittest.TestCase):
+    def setUp(self):
+        self.points = 1000
+        self.max_bytes = 20
+        self.total_buttons = 50
+
+    def test_example1(self):
+        buttons = 50
+        bytes = 20
+
+        self.assertEqual(calculate_score(self.points, self.max_bytes, self.total_buttons, buttons, bytes), 1000)
+
+    def test_example2(self):
+        buttons = 25
+        bytes = 20
+
+        self.assertEqual(calculate_score(self.points, self.max_bytes, self.total_buttons, buttons, bytes), 250)
+
+    def test_example3(self):
+        buttons = 50
+        bytes = 30
+
+        self.assertEqual(calculate_score(self.points, self.max_bytes, self.total_buttons, buttons, bytes), 250)
+
+    def test_example4(self):
+        buttons = 50
+        bytes = 10
+
+        self.assertEqual(calculate_score(self.points, self.max_bytes, self.total_buttons, buttons, bytes), 2000)