home *** CD-ROM | disk | FTP | other *** search
/ Hacker Chronicles 2 / HACKER2.BIN / 642.DIST.C < prev    next >
C/C++ Source or Header  |  1989-03-05  |  4KB  |  109 lines
  1. #include <stdio.h>
  2. #include "cell.h"
  3.  
  4. int GetApxDist( int, int, int, int );
  5. int CalcDist( int, int, int );
  6.  
  7. int GetApxDist ( r1, c1, r2, c2 ) /* calculate approximate distance */
  8.     int r1, c1, r2, c2;
  9.     {
  10.     register int d1, d2; /* row and column deltas */
  11.     int d0; /* temporary variable for swapping d1 and d2 */
  12.  
  13.     /* NOTE: the -25 used below is because we are not going from the   */
  14.     /* center of (r1,c1) to the center of (r2,c2), we are going from   */
  15.     /* the edge of a hole at (r1,c1) to the edge of a hole at (r2,c2). */
  16.     /* holes are 25 mils in diameter (12.5 mils in radius), so we back */
  17.     /* off by 2 radii.                           */
  18.     if ((d1 = r1-r2) < 0) /* get absolute row delta */
  19.         d1 = -d1;
  20.     if ((d2 = c1-c2) < 0) /* get absolute column delta */
  21.         d2 = -d2;
  22.     if (!d1) /* in same row? */
  23.         return( (d2*50)-25 ); /* 50 mils per cell */
  24.     if (!d2) /* in same column? */
  25.         return( (d1*50)-25 ); /* 50 mils per cell */
  26.     if (d1 > d2) { /* get smaller into d1 */
  27.         d0 = d1;
  28.         d1 = d2;
  29.         d2 = d0;
  30.         }
  31.     d2 -= d1; /* get non-diagonal part of approximate "route" */
  32.     return( (d1*71)+(d2*50)-25 ); /* 71 mils diagonally per cell */
  33.     }
  34.  
  35. /* distance to go thru a cell */
  36. static int dist[10][10] = { /* OT=Otherside, OR=Origin (source) cell */
  37.      /* N, NE,  E, SE,  S, SW,  W, NW,   OT, OR */
  38. /* N  */ { 50, 60, 35, 60, 99, 60, 35, 60,   12, 12 },
  39. /* NE */ { 60, 71, 60, 71, 60, 99, 60, 71,   23, 23 },
  40. /* E  */ { 35, 60, 50, 60, 35, 60, 99, 60,   12, 12 },
  41. /* SE */ { 60, 71, 60, 71, 60, 71, 60, 99,   23, 23 },
  42. /* S  */ { 99, 60, 35, 60, 50, 60, 35, 60,   12, 12 },
  43. /* SW */ { 60, 99, 60, 71, 60, 71, 60, 71,   23, 23 },
  44. /* W  */ { 35, 60, 99, 60, 35, 60, 50, 60,   12, 12 },
  45. /* NW */ { 60, 71, 60, 99, 60, 71, 60, 71,   23, 23 },
  46.  
  47. /* OT */ { 12, 23, 12, 23, 12, 23, 12, 23,   99, 99 },
  48. /* OR */ { 99, 99, 99, 99, 99, 99, 99, 99,   99, 99 }
  49.     };
  50.  
  51. /* distance around (circular) segment of hole */
  52. static int circ[10][10] = { /* OT=Otherside, OR=Origin (source) cell */
  53.      /* N, NE,  E, SE,  S, SW,  W, NW,   OT, OR */
  54. /* N  */ { 39, 29, 20, 10,  0, 10, 20, 29,   99, 0 },
  55. /* NE */ { 29, 39, 29, 20, 10,  0, 10, 20,   99, 0 },
  56. /* E  */ { 20, 29, 39, 29, 20, 10,  0, 10,   99, 0 },
  57. /* SE */ { 10, 20, 29, 39, 29, 20, 10,  0,   99, 0 },
  58. /* S  */ {  0, 10, 20, 29, 39, 29, 20, 10,   99, 0 },
  59. /* SW */ { 10,  0, 10, 20, 29, 39, 29, 20,   99, 0 },
  60. /* W  */ { 20, 10,  0, 10, 20, 29, 39, 29,   99, 0 },
  61. /* NW */ { 29, 20, 10,  0, 10, 20, 29, 39,   99, 0 },
  62.  
  63. /* OT */ { 99, 99, 99, 99, 99, 99, 99, 99,   99, 0 },
  64. /* OR */ { 99, 99, 99, 99, 99, 99, 99, 99,   99, 0 }
  65.     };
  66.  
  67. /* penalty for extraneous holes and corners, scaled by sharpness of turn */
  68. static int penalty[10][10] = { /* OT=Otherside, OR=Origin (source) cell */
  69.      /* N, NE,  E, SE,  S, SW,  W, NW,   OT, OR */
  70. /* N  */ {  0,  5, 10, 15, 20, 15, 10,  5,   50, 0 },
  71. /* NE */ {  5,  0,  5, 10, 15, 20, 15, 10,   50, 0 },
  72. /* E  */ { 10,  5,  0,  5, 10, 15, 20, 15,   50, 0 },
  73. /* SE */ { 15, 10,  5,  0,  5, 10, 15, 20,   50, 0 },
  74. /* S  */ { 20, 15, 10,  5,  0,  5, 10, 15,   50, 0 },
  75. /* SW */ { 15, 20, 15, 10,  5,  0,  5, 10,   50, 0 },
  76. /* W  */ { 10, 15, 20, 15, 10,  5,  0,  5,   50, 0 },
  77. /* NW */ {  5, 10, 15, 20, 15, 10,  5,  0,   50, 0 },
  78.  
  79. /* OT */ { 50, 50, 50, 50, 50, 50, 50, 50,  100, 0 },
  80. /* OR */ {  0,  0,  0,  0,  0,  0,  0,  0,    0, 0 }
  81.     };
  82.  
  83. /*
  84. ** x is the direction to enter the cell of interest.
  85. ** y is the direction to exit the cell of interest.
  86. ** z is the direction to really exit the cell, if y=FROM_OTHERSIDE.
  87. **
  88. ** return the distance of the trace through the cell of interest.
  89. ** the calculation is driven by the tables above.
  90. */
  91.  
  92. int CalcDist ( x, y, z ) /* calculate distance of a trace through a cell */
  93.     int x, y, z;
  94.     {
  95.     int adjust;
  96.  
  97.     adjust = 0; /* set if hole is encountered */
  98.     if (x == EMPTY)
  99.         x = 10;
  100.     if (y == EMPTY)
  101.         y = 10;
  102.     else if (y == FROM_OTHERSIDE) {
  103.         if (z == EMPTY)
  104.             z = 10;
  105.         adjust = circ[x-1][z-1] + penalty[x-1][z-1];
  106.         }
  107.     return( dist[x-1][y-1] + penalty[x-1][y-1] + adjust );
  108.     }
  109.