Add -q option, document score computation

bot.py

@@ -24,6 +24,9 @@ def save_screenshot(win):
 
 
 if __name__ == '__main__':
+    import sys
+    verbose = '-q' not in sys.argv[1:]
+
     try:
         win = get_exapunks_window()
         focus_window(win)
@@ -32,54 +35,61 @@ if __name__ == '__main__':
 
         solutions = deque([], maxlen=3)
 
+        def vprint(*args, **kwargs):
+            if verbose:
+                print(*args, **kwargs)
+
+        def vprint_state(state):
+            if verbose:
+                state.print()
+
         while True:
             try:
                 board = screenshot_board(win)
 
                 state = State.detect(board)
-                print('\033c', end='')
-                print('parsed:')
-                state.print()
-                print()
+                vprint('\033c', 'parsed:', sep='')
+                vprint_state(state)
+                vprint()
 
                 start = time.time()
                 solution = state.solve()
                 end = time.time()
-                print('thought for', round((end - start) * 1000, 1), 'milliseconds')
+                vprint('thought for', round((end - start) * 1000, 1), 'milliseconds')
             except (TypeError, AssertionError):
-                print('\rerror during parsing, wait for a bit...', end='')
-                time.sleep(0.05)
+                vprint('\rerror during parsing, wait for a bit...', end='')
+                time.sleep(0.050)
                 continue
             except error.BadMatch:
-                print('\rEXAPUNKS window lost, wait for a bit...', end='')
-                time.sleep(0.5)
+                vprint('\rEXAPUNKS window lost, wait for a bit...', end='')
+                time.sleep(0.500)
                 continue
 
             if len(solutions) == 3 and solution.loops(solutions.popleft()):
-                print('\rloop detected, wait for a bit...', end='')
+                vprint('\rloop detected, wait for a bit...', end='')
                 time.sleep(0.03)
             elif solution.moves:
-                print('moves:', solution.keys())
-                print('     score:', solution.score)
+                vprint('moves:', solution.keys())
+                vprint('     score:', solution.score)
                 if solutions:
-                    print('prev score:', solutions[-1].score)
-                print()
+                    vprint('prev score:', solutions[-1].score)
+                vprint()
 
-                print('target after moves:')
-                solution.newstate.print()
+                vprint('target after moves:')
+                vprint_state(solution.newstate)
 
                 press_keys(win, solution.keys())
 
                 keys_delay = len(solution.moves) * 2 * KEY_DELAY
                 moves_delay = max(0, solution.delay() - keys_delay)
-                print('wait for',  moves_delay, 'ms')
+                vprint('wait for',  moves_delay, 'ms')
                 time.sleep(moves_delay / 1000)
             elif state.nrows() - 2 <= MAX_SPEED_ROWS:
-                print('no moves, speed up')
+                vprint('no moves, speed up')
                 press_keys(win, 'l')
-                time.sleep(0.03)
+                time.sleep(0.030)
             else:
-                print('no moves')
+                vprint('no moves')
 
             solutions.append(solution)
     except KeyboardInterrupt:

strategy.py

@@ -25,7 +25,7 @@ POINTS_DEPTH = 3
 FRAG_DEPTH = 5
 DEFRAG_PRIO = 4
 COLSIZE_PRIO = 5
-COLSIZE_PANIC = 7
+COLSIZE_PANIC = 8
 COLSIZE_MAX = 9
 BOMB_POINTS = 1
 MIN_ROWS = 2
@@ -90,21 +90,30 @@ class State:
     def score(self, points, moves, prev):
         prev_colsize = prev.nrows() - 2
 
-        #if prev_colsize >= COLSIZE_PANIC:
-        #    holes = self.holes()
-        #    frag = self.fragmentation()
-        #    return holes, moves_delay(moves), -points, frag
-        if prev_colsize >= COLSIZE_PRIO:
-            holes = self.holes()
-            frag = self.fragmentation()
-            return -points, holes, frag, moves_delay(moves)
-        elif prev_colsize >= DEFRAG_PRIO:
-            holes = self.holes()
-            frag = self.fragmentation()
+        delay = moves_delay(moves)
+
+        # Don't care about defragging for few rows, just score points quickly.
+        # This saves computation time which in turn makes for nice combos when
+        # the bot speeds around throwing blocks on top of each other.
+        if prev_colsize < DEFRAG_PRIO:
+            return -points, delay
+
+        holes = self.holes()
+        frag = self.fragmentation()
+
+        # When rows start stacking up, start defragmenting colors to make
+        # opportunities for scoring points.
+        if prev_colsize < COLSIZE_PRIO:
+            return -points, frag, holes, delay
+
+        # When they stack higher, start moving blocks down into holes before
+        # continuing to defragment.
+        if prev_colsize < COLSIZE_PANIC:
             panic = int(self.causes_panic())
-            return -points, panic, frag, holes, moves_delay(moves)
-        else:
-            return -points, moves_delay(moves)
+            return panic, -points, holes, frag, delay
+
+        # Column heights are getting out of hand, just move shit DOWN.
+        return holes, delay, -points, frag
 
     def solutions(self):
         for moves in self.gen_moves():