modified: Game solvers/asciiplanes-player.sf -- some optimizations

Author: trizen

Game solvers/asciiplanes-player.sf

@@ -45,6 +45,7 @@ var simulate   = false
 var hit_char   = HIT
 var miss_char  = AIR
 var head_char  = HEAD
+var seed       = 0
 
 func usage {
     print <<"EOT"
@@ -58,6 +59,7 @@ main:
         --miss=s    : character used when a plane is missed (default: "#{miss_char}")
         --colors!   : use ANSI colors (requires Term::ANSIColor) (default: #{use_colors})
         --simulate! : run a random simulation (default: #{simulate})
+        --seed=i    : run with a given pseudorandom seed value > 0 (default: #{seed})
 
 help:
         --help      : print this message and exit
@@ -85,6 +87,7 @@ if (ARGV) {
     getopt.GetOptions(
          'board-size|size=i' => func(_,v) { BOARD_SIZE = Num(v)  },
          'planes-num=i'      => func(_,v) { PLANES_NUM = Num(v)  },
+         'seed=i'            => func(_,v) { seed       = Num(v)  },
          'hit-char=s'        => func(_,v) { hit_char   = Str(v)  },
          'miss-char=s'       => func(_,v) { miss_char  = Str(v)  },
          'wrap!'             => func(_,v) { wrap_plane = Bool(v) },
@@ -95,6 +98,11 @@ if (ARGV) {
     )
 }
 
+if (seed) {
+    iseed(seed)
+    Perl.eval("srand(#{seed})")
+}
+
 #---------------------------------------------------------------
 
 func pointers(board, x, y, indices) {
@@ -241,24 +249,24 @@ func create_planes(play_board) {
 func guess(info_board, play_board, plane_count) {
 
     var count = 0
-    var sampled = Set()
     var max_tries = BOARD_SIZE*BOARD_SIZE
+    var indices = PAIR_INDICES.shuffle
 
     while (count != (PLANES_NUM - plane_count)) {
 
         #var x = irand(1, BOARD_SIZE)-1
         #var y = irand(1, BOARD_SIZE)-1
 
-        var (x,y) = (PAIR_INDICES.shuffle.first_by {|idx|
-            (play_board[idx[0]][idx[1]] == BLANK) && (info_board[idx[0]][idx[1]] == BLANK) && !sampled.has(idx)
-        } \\ return nil)...
+        var (x,y) = (indices.pop_rand \\ return nil)...
+        loop {
+            (play_board[x][y] == BLANK) && (info_board[x][y] == BLANK) && break
+            (x,y) = (indices.pop_rand \\ return nil)...
+        }
 
         if (--max_tries <= 0) {
             return nil
         }
 
-        sampled << [x,y]
-
         var good_directions = DIRECTIONS.grep {|dir|
             var plane = pointers(info_board, x, y, dir)
             plane && plane.none { *_ == AIR }
@@ -362,10 +370,24 @@ func solve(callback) {
             var all_dead = true
             var new_info = false
 
-            get_head_positions(play_board).shuffle.each_2d {|i,j|
+            var head_pos = get_head_positions(play_board).shuffle
+
+            head_pos = head_pos.grep_2d {|x,y| info_board[x][y] == BLANK }.map_2d {|x,y|
+                [x, y, DIRECTIONS.first_by {|d|
+                    (pointers(play_board, x, y, d).count_by { *_ == HIT } == 7) &&
+                    (pointers(info_board, x, y, d).none { *_ == AIR })
+                }]
+            }
+
+            # Prefer the planes with the most hits
+            head_pos = head_pos.sort_by {|p|
+                pointers(info_board, p[0], p[1], p[2]).count_by { *_ == HIT }
+            }.flip
+
+            head_pos.each_2d {|i,j|
 
-                if (info_board[i][j] == HEAD) {
-                    next    # already destroyed
+                if (info_board[i][j] != BLANK) {
+                    next
                 }
 
                 all_dead  = false
@@ -381,10 +403,11 @@ func solve(callback) {
                 if (score == HEAD) {
                     new_info = true
                     boards = make_play_boards(info_board)
+                    next
                 }
                 elsif (score == AIR) {
                     new_info = true
-                    boards = boards.grep { valid_assignment(.head, info_board) }
+                    boards = boards.grep { valid_assignment(.head, info_board) }.flip
                 }
 
                 break