SHARE
TWEET

AutoHotKey Tetris Bot evaluation function

a guest May 14th, 2014 196 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. ; tries to evaluate the quality of a playfield , small numbers (variable c) mean few holes and a nice surface
  2. ; field is a 18 x 10 matrix, field[1,j] notes the bottom row, field[i,1] notes the left-most column
  3. ; field[i,j] = 0 -> empty cell in row i and column j , field[i,j] = 1 -> filled cell in row i and column j
  4. penalty2( field )
  5. {
  6.         ; surf is an array of length 10, a[i] represents the height of the i-th line, a[i]=0 means bottom
  7.         ; otherwise field(a[j],j) = 1 and field(a[j]+i,j) = 0 for every i > 0  
  8.         surf := getSurface( field )
  9.  
  10.         ; x1,y1 are the coordinates of the highest hole, x2,y2 are the coordinates of the second highest hole
  11.         ; hole = filled cell with empty cell below , holes corresponds to the number of holes
  12.         holes := 0, x1 := 0, y1 := 0, x2:= 0, y2 := 0
  13.         recalculate(field, surf, holes, x1, y1, x2, y2 )        
  14.         ;MsgBox % holes . " " . x1 . " " . y1 . " " . x2 . " " . y2
  15.  
  16.         return penalty( surf, holes, x1, y1, x2, y2 )  
  17. }
  18.  
  19.  
  20. ; calculates the number of holes and the coordinates of the 2 highest holes
  21. recalculate( field, surf, ByRef holes, ByRef x1, ByRef y1, ByRef x2, ByRef y2 )
  22. {
  23.         ; hole = filled cell with empty cell below     
  24.        
  25.         ;surf := getSurface( field )   
  26.         ;x1 := 0, y1 := 0 ; x,y coordinate of highest hole
  27.         ;x2 := 0, y2 := 0 ; x,y coordinate of second highest hole
  28.         ;holes := 0    
  29.        
  30.         j := 0
  31.         while ( ++j <= 10 )
  32.         {      
  33.                 i := 0
  34.                 while ( ++i < surf[j] )
  35.                 {
  36.                         if ( field[i,j] = 0 )
  37.                         {
  38.                                 ; hole found, count it as 2 if connected to a hole on the left and right, 3 if unconnected
  39.                                 ; add 0.5 if 2 fields deep, or deepness-1.5 if deeper
  40.                                 connected := 0
  41.                                 deepness := 0
  42.                                 while ( field[i,j] = 0 )
  43.                                 {
  44.                                         deepness += 1                          
  45.                                         if ( j > 1 && i < surf[j-1] && field[i,j-1] = 0 )
  46.                                                         connected += 0.5 ; every connection is counted double, thus halve it
  47.                                         if ( j < 10 && i < surf[j+1] && field[i,j+1] = 0 ) ; or else if?
  48.                                                 connected += 0.5
  49.                                         i := i + 1     
  50.                                 }
  51.                                 holes += 3
  52.                                 holes -= connected
  53.                                 if ( deepness > 2 )
  54.                                         holes += ( deepness - 1.5 )
  55.                                 else if ( deepness = 2 )
  56.                                         holes += 0.5                   
  57.                                 ; highest 2 holes are stored in x1,y1 resp x2,y2
  58.                                 if ( i > y1 )
  59.                                 {
  60.                                         x2 := x1, y2 := y1
  61.                                         x1 := j, y1 := i
  62.                                 }
  63.                                 else if ( i > y2 )
  64.                                 {
  65.                                         x2 := j, y2 := i
  66.                                 }
  67.                         }
  68.                 }
  69.         }      
  70. }
  71.  
  72.  
  73. ; a is an array which stands for the height of the surface in the corresponding column, columns are numbered from 1 to 10
  74. penalty( a, holes, x1, y1, x2, y2 )
  75. {
  76.         ;if ( holes - (holes * 10) // 10 != 0 )
  77.         ;{
  78.         ;       MsgBox % "#holes not integer: " . holes . " " . x1 . " " . y1 . " " . x2 . " " . y2 . "`n" . ArrayToStr(a)
  79.         ;}
  80.        
  81.         c := 0 ; returned penalty      
  82.         ;MsgBox % "surface: " . arrayToStr(a) , q := 0
  83.        
  84.         ; ###################### punish holes #######################
  85.         ; hole = filled cell with empty cell below
  86.  
  87.         ; punish number of holes
  88.         c += 4 * holes
  89.         ;MsgBox % c . " (+" . c-q . ") after counting holes"    , q := c
  90.        
  91.         ; punish if highest hole is deeply covered
  92.         if ( y2 > 0 )
  93.         {
  94.                 if ( y1 > y2 )
  95.                         c += 3 * min(a[x1]-y1,3) + 1 * min( max(a[x2],a[x1])-y1 , 4 )
  96.                 else
  97.                         c += 2 * min(a[x1]-y1,3) + 2 * min(a[x2]-y2,3)
  98.         }
  99.         else if ( y1 > 0 )
  100.         {
  101.                 c += 4 * min(a[x1]-y1,3)
  102.         }
  103.         ;MsgBox % c . " (+" . c-q . ") after knowing how deep to dig"   , q := c
  104.        
  105.         ; preperation: punish if surface near highest hole isn't flat
  106.         c1 := 0
  107.         if ( y1 > 0 )
  108.         {
  109.                 if ( x1 = 1 )
  110.                 {
  111.                         d := ABS( a[x1+1] - a[x1] )
  112.                         if ( a[x1] > a[x1+1] )
  113.                                 d -= 1
  114.                         if ( d > 1 )
  115.                                 c1 := 6
  116.                         else if ( d = 1 )
  117.                                 c1 := 2
  118.                 }
  119.                 else if ( x1 = 10 )
  120.                 {
  121.                         d := ABS( a[x1-1] - a[x1] )
  122.                         if ( a[x1] > a[x1-1] )
  123.                                 d -= 1
  124.                         if ( d > 1 )
  125.                                 c1 := 6
  126.                         else if ( d = 1 )
  127.                                 c1 := 2                        
  128.                 }
  129.                 else
  130.                 {
  131.                         d1 := ABS( a[x1-1] - a[x1] )                           
  132.                         d2 := ABS( a[x1+1] - a[x1] )
  133.                         if ( d1 < d2 )
  134.                         {
  135.                                 ; assure that d1 >= d2
  136.                                 d := d1
  137.                                 d1 := d2
  138.                                 d2 := d                        
  139.                         }
  140.                         if ( d2 > 1 )
  141.                                 c1 := 6
  142.                         else if ( d1 > 1 && d2 = 1 )
  143.                                 c1 := 4
  144.                         else if ( d1 > 1 && d2 = 0 )
  145.                                 c1 := 2
  146.                         else if ( d2 = 1 )
  147.                         {
  148.                                 if ( a[x1-1] < a[x1] && a[x1+1] < a[x1] )
  149.                                         c2 := 3
  150.                                 else
  151.                                         c2 := 2
  152.                         }
  153.                         else if ( d1 = 1 )
  154.                                 c1 := 1
  155.                 }      
  156.         }
  157.         c2 := 0
  158.         if ( y2 > 0 )
  159.         {
  160.                 ; same code as above
  161.                 if ( x2 = 1 )
  162.                 {
  163.                         d := ABS( a[x2+1] - a[x2] )
  164.                         if ( d > 1 )
  165.                                 c2 := 6
  166.                         else if ( d = 1 )
  167.                                 c2 := 2
  168.                 }
  169.                 else if ( x2 = 10 )
  170.                 {
  171.                         d := ABS( a[x2-1] - a[x2] )
  172.                         if ( d > 1 )
  173.                                 c2 := 6
  174.                         else if ( d = 1 )
  175.                                 c2 := 2                        
  176.                 }
  177.                
  178.                 else
  179.                 {
  180.                         d1 := ABS( a[x2-1] - a[x2] )                           
  181.                         d2 := ABS( a[x2+1] - a[x2] )
  182.                         if ( d1 < d2 )
  183.                         {
  184.                                 ; assure that d1 >= d2
  185.                                 d := d1
  186.                                 d1 := d2
  187.                                 d2 := d                        
  188.                         }
  189.                         if ( d2 > 1 )
  190.                                 c2 := 6
  191.                         else if ( d1 > 1 && d2 = 1 )
  192.                                 c2 := 4
  193.                         else if ( d1 > 1 && d2 = 0 )
  194.                                 c2 := 2
  195.                         else if ( d2 = 1 )
  196.                         {
  197.                                 if ( a[x2-1] < a[x2] && a[x2+1] < a[x2] )
  198.                                         c2 := 3
  199.                                 else
  200.                                         c2 := 2
  201.                         }
  202.                         else if ( d1 = 1 )
  203.                                 c2 := 1
  204.                 }                      
  205.         }
  206.         ; execution: punish if surface near highest hole isn't flat            
  207.         if ( y2 > 0 )
  208.         {
  209.                 if ( y1 > y2 )
  210.                         c += 0.8 * c1 + 0.2 * c2
  211.                 else
  212.                         c += 0.5 * c1 + 0.5 * c2
  213.         }
  214.         else if ( y1 > 0 )
  215.         {
  216.                 c += c1
  217.         }      
  218.                
  219.         ;MsgBox % c . " (+" . c-q . ") after checking surface near holes"       , q := c
  220.         ; ###################### evaluate surface #######################
  221.  
  222.         o := 0, s := 0, z := 0 ; number of spots for O, S, Z pieces
  223.        
  224.         min := 18, max := 0, sum := 0
  225.         i:= 0
  226.         while ( ++i <= 10 )
  227.         {
  228.                 sum += a[i]
  229.                 if ( min > a[i] )
  230.                         min := a[i]
  231.                 if ( max < a[i] )
  232.                         max := a[i]            
  233.         }
  234.         c += 0.1 * sum ; too many filled cells penalty
  235.        
  236.         if ( max = 18 )
  237.                 c += 10
  238.         else if ( max = 17 )
  239.                 c += 5  ; too high penalty
  240.        
  241.         if ( max - min > 7 )
  242.                 c += 0.1*( max - min - 7 )*( max - min - 6 ) ; too big global height difference penalty
  243.        
  244.         c += ( 1.5*a[4] + 1.5*a[5] + 1.5*a[6] + 1.5*a[7] - 2*a[1] - 2*a[10] - a[2] - a[9] ) / 10 ; hill in the middle penalty
  245.        
  246.         d := 0 ; number of wells
  247.         if ( a[1] < a[2]+2 )   
  248.                 d += 1
  249.         if ( a[9]+2 > a[10] )
  250.                 d += 1
  251.        
  252.         ;if ( a[1] < a[2]+2 && a[9]+2 > a[10] )
  253.         ;       c += 3 ; 2 wells penalty
  254.         ;else if ( a[1] <= a[2]+2 && a[9]+2 >= a[10] )
  255.         ;       c += 1
  256.        
  257.         i := 0
  258.         while ( ++i <= 8 )
  259.         {
  260.                 if ( Abs( a[i+1] - a[i] ) > 2 && Abs( a[i+2] - a[i+1] ) > 2 )
  261.                 {
  262.                         if ( a[i] < a[i+1] && a[i+1] > a[i+2] )
  263.                                 c += 2 ; obelisc penalty
  264.                         else if ( a[i] > a[i+1] && a[i+1] < a[i+2] )
  265.                         {
  266.                                 c += 1 ; trench penalty
  267.                                 d += 1                         
  268.                         }
  269.                         else
  270.                                 c += 1 ; cliff penalty
  271.                 }
  272.         }
  273.        
  274.         if ( d = 1 )
  275.                 c += 2
  276.         else if ( d = 2 )
  277.                 c += 5
  278.         else if ( d > 2 )
  279.                 c += 5*d - 5 ; too many wells penalty
  280.  
  281.         i := 0
  282.         while ( ++i <= 9 )
  283.         {
  284.                 d := Abs( a[i+1] - a[i] )
  285.                 if ( d > 2 )
  286.                         c += d - 1 + (d-1)//2 ; local height difference penalty
  287.                 else if ( a[i+1] = a[i]-2 )
  288.                         c += 1
  289.                 else if ( a[i+1] = a[i]+2 )
  290.                         c += 1 
  291.                 else if ( a[i+1] = a[i]-1 )
  292.                         s += 1
  293.                 else if ( a[i+1] = a[i]+1 )
  294.                         z += 1
  295.                 else ; a[i] = a[i+1]
  296.                 {
  297.                         o += 1
  298.                         if ( i+2 <= 10 && a[i+2] = a[i]+1 )
  299.                                 s += 1
  300.                         if ( i-1 >= 1 && a[i-1] = a[i]+1 )
  301.                                 z += 1
  302.                 }                      
  303.         }
  304.                
  305.         if ( o = 0 )
  306.                 c += 5 ; no O spot penalty
  307.         else if ( o = 1 )
  308.                 c += 2 ; just one O spot penalty
  309.         else if ( o = 2 )
  310.                 c += 1 ; just two O spots penalty
  311.         else if ( o = 3 )
  312.                 c += 0.5 ; just three O spots penalty
  313.         if ( s = 0 )
  314.                 c += 4 ; no S spot penalty
  315.         else if ( s = 1 )
  316.                 c += 1 ; just one S spot penalty               
  317.         if ( z = 0 )
  318.                 c += 4 ; no Z spot penalty
  319.         else if ( z = 1 )
  320.                 c += 1 ; just one Z spot penalty
  321.  
  322.         w := 0 ; number of white chess fields
  323.        
  324.         i := 0
  325.         while ( ++i <= 10 )
  326.         {
  327.                 w += Mod( i+a[i] , 2 )
  328.         }
  329.         if ( Abs( w - 5 ) >= 2 )
  330.                 c += 1 + 7 * ( Abs( w - 5 ) - 2 ) ; bad T placement penalty
  331.        
  332.         i := 0
  333.         while ( ++i <= 6 )
  334.         {
  335.                 w := 0
  336.                 w += Mod( i + a[i] , 2 )
  337.                 w += Mod( i+1 + a[i+1] , 2 )
  338.                 w += Mod( i+2 + a[i+2] , 2 )           
  339.                 w += Mod( i+3 + a[i+3] , 2 )           
  340.                 w += Mod( i+4 + a[i+4] , 2 )
  341.                 if ( w = 0 || w = 5 )
  342.                         c += 2 ; local imbalance penalty
  343.                 else if ( w = 1 || w = 4 )
  344.                         c += 1
  345.         }
  346.         w := Mod( 1 + a[1] , 2 )
  347.         w += Mod( 2 + a[2] , 2 )
  348.         w += Mod( 3 + a[3] , 2 )
  349.         w += Mod( 4 + a[4] , 2 )
  350.         if ( w = 0 || w = 4 )
  351.                 c += 1 ; left side imbalance penalty
  352.         w := Mod( 7 + a[7] , 2 )
  353.         w += Mod( 8 + a[8] , 2 )
  354.         w += Mod( 9 + a[9] , 2 )
  355.         w += Mod( 10 + a[10] , 2 )
  356.         if ( w = 0 || w = 4 )
  357.                 c += 1 ; right side imbalance penalty
  358.  
  359.         ;aaMsgBox % c . " (+" . c-q . ") after parity"  , q := c
  360.         return c
  361. }
RAW Paste Data
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy. OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!
 
Top