home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 January / usenetsourcesnewsgroupsinfomagicjanuary1994.iso / sources / games / volume15 / scrabble2 / patch1 / patches01
Text File  |  1993-01-27  |  23KB  |  827 lines
  1. *** cmove.c.orig    Sun Jul 26 11:20:23 1992
  2. --- cmove.c    Mon Oct 26 08:17:37 1992
  3. ***************
  4. *** 231,237 ****
  5. --- 231,241 ----
  6.                           tile++;
  7.                       if( blank > oldbl && tile > 0 ) {
  8.                           oldbl = blank;
  9. + #ifdef DBLSIZE_BOARD
  10. +                         move( BOARD_UY + sy - 1, BOARD_LX + sx * 2 - 2 );
  11. + #else
  12.                           move( BOARD_UY + sy - 1, BOARD_LX + sx - 1 );
  13. + #endif
  14.                           refresh();
  15.                           try_tiles( sx, sy, blank, dir );
  16.                       }
  17. *** misc.c.orig    Tue Sep 22 11:21:51 1992
  18. --- misc.c    Mon Oct 26 08:17:38 1992
  19. ***************
  20. *** 61,68 ****
  21.               }
  22.           }
  23.           if( rlen > tlen ) {
  24.               tlen = rlen;
  25. -             wlen[tlen] = wr;
  26.           }
  27.           strcpy( &words[pt], inp );
  28.           wptr[wr++] = pt;
  29. --- 61,68 ----
  30.               }
  31.           }
  32.           if( rlen > tlen ) {
  33. +             for( i = tlen + 1; i <= rlen; i++ ) wlen[i] = wr;
  34.               tlen = rlen;
  35.           }
  36.           strcpy( &words[pt], inp );
  37.           wptr[wr++] = pt;
  38. ***************
  39. *** 69,76 ****
  40.           pt += rlen + 1;
  41.           strcpy( tinp, inp );
  42.       }
  43.       dict_size = pt;
  44. !     wlen[16] = wr;
  45.       fclose( fp );
  46.   }
  47.   
  48. --- 69,78 ----
  49.           pt += rlen + 1;
  50.           strcpy( tinp, inp );
  51.       }
  52. +     words[pt] = '\0';
  53. +     wptr[wr] = pt;
  54.       dict_size = pt;
  55. !     for( i = tlen + 1; i < 17; i++ ) wlen[i] = wr;
  56.       fclose( fp );
  57.   }
  58.   
  59. ***************
  60. *** 111,119 ****
  61.   print_board() {
  62.       int i, j;
  63.   
  64.       for( i = 1; i < 16; i++ ) {
  65. -         move( BOARD_UY + i - 1, BOARD_LX );
  66.           for( j = 1; j < 16; j++ ) {
  67.               if( board[i][j] >= 'A' ) standout();
  68.               if( ( i == b1y && j == b1x ) || ( i == b2y && j == b2x ) )
  69.                   addch( board[i][j] - 'A' + 'a' );
  70. --- 113,126 ----
  71.   print_board() {
  72.       int i, j;
  73.   
  74. +     clear_rect( BOARD_UY, BOARD_LX, BOARD_LY, BOARD_RX );
  75.       for( i = 1; i < 16; i++ ) {
  76.           for( j = 1; j < 16; j++ ) {
  77. + #ifdef DBLSIZE_BOARD
  78. +             move( BOARD_UY + i - 1, BOARD_LX + j * 2 - 2 );
  79. + #else
  80. +             move( BOARD_UY + i - 1, BOARD_LX + j - 1 );
  81. + #endif
  82.               if( board[i][j] >= 'A' ) standout();
  83.               if( ( i == b1y && j == b1x ) || ( i == b2y && j == b2x ) )
  84.                   addch( board[i][j] - 'A' + 'a' );
  85. ***************
  86. *** 129,143 ****
  87.       int i, j;
  88.   
  89.       clear_rect( TILE_RACKS_Y, TILE_RACKS_X,
  90. !                   TILE_RACKS_Y + 7, TILE_RACKS_X + 24 );
  91.       for( i = 0; i < players; i++ ) {
  92.           move( TILE_RACKS_Y + i * 3, TILE_RACKS_X - 4 );
  93.           if( plr_skills[i] != 0 ) printw( "(%d)", plr_skills[i] );
  94. !         move( TILE_RACKS_Y + i * 3, TILE_RACKS_X );
  95.           if( i == human_player )
  96. !             printw( "Your tiles:" );
  97.           else
  98. !             printw( "%s tiles:", you[i] );
  99.           for( j = 0; j < 7; j++ ) {
  100.               addch( ' ' );
  101.               if( plr_tiles[i][j] > 0 ) {
  102. --- 136,150 ----
  103.       int i, j;
  104.   
  105.       clear_rect( TILE_RACKS_Y, TILE_RACKS_X,
  106. !                   TILE_RACKS_Y + 7, TILE_RACKS_X + 19 );
  107.       for( i = 0; i < players; i++ ) {
  108.           move( TILE_RACKS_Y + i * 3, TILE_RACKS_X - 4 );
  109.           if( plr_skills[i] != 0 ) printw( "(%d)", plr_skills[i] );
  110. !         move( TILE_RACKS_Y + i * 3, TILE_RACKS_X + 1 );
  111.           if( i == human_player )
  112. !             printw( " You:" );
  113.           else
  114. !             printw( "%s:", you[i] );
  115.           for( j = 0; j < 7; j++ ) {
  116.               addch( ' ' );
  117.               if( plr_tiles[i][j] > 0 ) {
  118. ***************
  119. *** 150,156 ****
  120.   #endif
  121.               } else addch( ' ' );
  122.           }
  123. !         move( TILE_RACKS_Y + i * 3 + 1, TILE_RACKS_X + 5 );
  124.           printw( "Score: %3d", plr_scores[i] );
  125.       }
  126.       move( TILE_RACKS_Y + 12, TILE_RACKS_X - 2 );
  127. --- 157,163 ----
  128.   #endif
  129.               } else addch( ' ' );
  130.           }
  131. !         move( TILE_RACKS_Y + i * 3 + 1, TILE_RACKS_X );
  132.           printw( "Score: %3d", plr_scores[i] );
  133.       }
  134.       move( TILE_RACKS_Y + 12, TILE_RACKS_X - 2 );
  135. ***************
  136. *** 157,169 ****
  137.       i = 0;
  138.       if( b1x != 0 ) i++;
  139.       if( b2x != 0 ) i++;
  140. !     printw( "Blank tiles placed so far: %d", i );
  141.       if( b1x != 0 ) {
  142. !         move( TILE_RACKS_Y + 13, TILE_RACKS_X + 3 );
  143.           printw( "Row %2d, Column %2d (%c)", b1y, b1x, board[b1y][b1x] );
  144.       }
  145.       if( b2x != 0 ) {
  146. !         move( TILE_RACKS_Y + 14, TILE_RACKS_X + 3 );
  147.           printw( "Row %2d, Column %2d (%c)", b2y, b2x, board[b2y][b2x] );
  148.       }
  149.       move( TILE_RACKS_Y + human_player * 3, TILE_RACKS_X - 1 );
  150. --- 164,176 ----
  151.       i = 0;
  152.       if( b1x != 0 ) i++;
  153.       if( b2x != 0 ) i++;
  154. !     printw( "Blank tiles placed: %d", i );
  155.       if( b1x != 0 ) {
  156. !         move( TILE_RACKS_Y + 13, TILE_RACKS_X - 1 );
  157.           printw( "Row %2d, Column %2d (%c)", b1y, b1x, board[b1y][b1x] );
  158.       }
  159.       if( b2x != 0 ) {
  160. !         move( TILE_RACKS_Y + 14, TILE_RACKS_X - 1 );
  161.           printw( "Row %2d, Column %2d (%c)", b2y, b2x, board[b2y][b2x] );
  162.       }
  163.       move( TILE_RACKS_Y + human_player * 3, TILE_RACKS_X - 1 );
  164. ***************
  165. *** 187,201 ****
  166.               break;
  167.       }
  168.       tiles_left[i]--;
  169. !     print_tiles_left( tleft - 1 );
  170.       return( i == 26 ? CH_BL : i + 'A' );
  171.   }
  172.   
  173. ! print_tiles_left( t )
  174. !   int t;
  175. ! {
  176.       move( TILES_LEFT_Y, TILES_LEFT_X );
  177. !     printw( "Tiles left to draw: %3d", t );
  178.   }
  179.   
  180.   char get_key() {
  181. --- 194,241 ----
  182.               break;
  183.       }
  184.       tiles_left[i]--;
  185. !     print_tiles_left();
  186.       return( i == 26 ? CH_BL : i + 'A' );
  187.   }
  188.   
  189. ! print_tiles_left() {
  190. !     int i, tleft;
  191. ! 
  192. !     tleft = 0;
  193. !     for( i = 0; i < 27; i++ )
  194. !         tleft += tiles_left[i];
  195. ! 
  196.       move( TILES_LEFT_Y, TILES_LEFT_X );
  197. !     printw( "Tiles left to draw: %3d", tleft );
  198. ! }
  199. ! 
  200. ! print_passed_turns() {
  201. !     if( game_done == 0 ) clear_rect( 1, 50, 1, 79 );
  202. !     else {
  203. !         move( 1, 63 );
  204. !         printw( "Passed turns:  %d", game_done );
  205. !     }
  206. !     refresh();
  207. ! }
  208. ! 
  209. ! print_whos_move( plr ) {
  210. !     clear_turn();
  211. !     printw( "*** %s turn to play  ", your[plr] );
  212. ! }
  213. ! 
  214. ! print_version() {
  215. !     clear();
  216. !     printw( "*** SCRABBLE 1.30 ***\n\n" );
  217. ! }
  218. ! 
  219. ! screen_redraw() {
  220. !     print_version();
  221. !     print_info();
  222. !     print_board();
  223. !     print_tiles_left( tiles_left );
  224. !     print_passed_turns();
  225. !     print_tiles();
  226. !     print_whos_move( human_player );
  227.   }
  228.   
  229.   char get_key() {
  230. *** pmove.c.orig    Wed Aug 19 11:58:07 1992
  231. --- pmove.c    Mon Oct 26 08:17:39 1992
  232. ***************
  233. *** 12,22 ****
  234.       char c;
  235.       int xpos, ypos, done;
  236.   
  237. !     xpos = BOARD_LX;
  238. !     ypos = BOARD_UY;
  239.       for( ;; ) {
  240.           clear_prompt();
  241. !         printw( "  Use the 'hjkl' keys to move the cursor.\n" );
  242.           printw( "  Press <RETURN> on an empty square to start placing tiles on the board.\n" );
  243.           printw( "  Press <SPACE> to rearrange your tiles.\n" );
  244.           printw( "  Press '.' to use your turn to draw new tiles.\n" );
  245. --- 12,22 ----
  246.       char c;
  247.       int xpos, ypos, done;
  248.   
  249. !     xpos = 1;
  250. !     ypos = 1;
  251.       for( ;; ) {
  252.           clear_prompt();
  253. !         printw( "  Use the 'hjkl' keys to move the cursor, and control-L to refresh the screen.\n" );
  254.           printw( "  Press <RETURN> on an empty square to start placing tiles on the board.\n" );
  255.           printw( "  Press <SPACE> to rearrange your tiles.\n" );
  256.           printw( "  Press '.' to use your turn to draw new tiles.\n" );
  257. ***************
  258. *** 23,47 ****
  259.           refresh();
  260.           done = 0;
  261.           do {
  262. !             move( ypos, xpos );
  263.               refresh();
  264.               c = get_key();
  265.               switch( c ) {
  266.                 case 'H':
  267. !                 if( xpos > BOARD_LX ) xpos--;
  268.                   break;
  269.                 case 'L':
  270. !                 if( xpos < BOARD_RX ) xpos++;
  271.                   break;
  272.                 case 'J':
  273. !                 if( ypos < BOARD_LY ) ypos++;
  274.                   break;
  275.                 case 'K':
  276. !                 if( ypos > BOARD_UY ) ypos--;
  277.                   break;
  278.                 case '\n':
  279. !                 if( board[ypos - BOARD_UY + 1][xpos - BOARD_LX + 1] < 'A' )
  280. !                     done = place_tiles( xpos, ypos );
  281.                   break;
  282.                 case ' ':
  283.                   done = rearrange_tiles();
  284. --- 23,50 ----
  285.           refresh();
  286.           done = 0;
  287.           do {
  288. ! #ifdef DBLSIZE_BOARD
  289. !             move( BOARD_UY + ypos - 1, BOARD_LX + xpos * 2 - 2 );
  290. ! #else
  291. !             move( BOARD_UY + ypos - 1, BOARD_LX + xpos - 1 );
  292. ! #endif
  293.               refresh();
  294.               c = get_key();
  295.               switch( c ) {
  296.                 case 'H':
  297. !                 if( xpos > 1 ) xpos--;
  298.                   break;
  299.                 case 'L':
  300. !                 if( xpos < 15 ) xpos++;
  301.                   break;
  302.                 case 'J':
  303. !                 if( ypos < 15 ) ypos++;
  304.                   break;
  305.                 case 'K':
  306. !                 if( ypos > 1 ) ypos--;
  307.                   break;
  308.                 case '\n':
  309. !                 if( board[ypos][xpos] < 'A' ) done = place_tiles( xpos, ypos );
  310.                   break;
  311.                 case ' ':
  312.                   done = rearrange_tiles();
  313. ***************
  314. *** 49,54 ****
  315. --- 52,61 ----
  316.                 case '.':
  317.                   done = draw_new_tiles();
  318.                   break;
  319. +               case ' ':
  320. +                 screen_redraw();
  321. +                 done = -1;
  322. +                 break;
  323.               }
  324.           } while( done == 0 );
  325.           if( done == 1 ) break;
  326. ***************
  327. *** 83,89 ****
  328.       show_instructions();
  329.       placed = 0;
  330.       for( ;; ) {
  331. !         move( ypos, xpos );
  332.           refresh();
  333.           c = get_key();
  334.           if( c == '-' || c == 127 || c == 8 ) {
  335. --- 90,100 ----
  336.       show_instructions();
  337.       placed = 0;
  338.       for( ;; ) {
  339. ! #ifdef DBLSIZE_BOARD
  340. !         move( BOARD_UY + ypos - 1, BOARD_LX + xpos * 2 - 2 );
  341. ! #else
  342. !         move( BOARD_UY + ypos - 1, BOARD_LX + xpos - 1 );
  343. ! #endif
  344.           refresh();
  345.           c = get_key();
  346.           if( c == '-' || c == 127 || c == 8 ) {
  347. ***************
  348. *** 92,99 ****
  349.               do {
  350.                   xpos -= xinc;
  351.                   ypos -= yinc;
  352. !             } while( board[ypos - BOARD_UY + 1][xpos - BOARD_LX + 1] >= 'A' );
  353. !             move( ypos, xpos );
  354.               addch( newlet[placed].oldlet );
  355.               plr_tiles[human_player][newlet[placed].tilepos]
  356.                 = newlet[placed].letter;
  357. --- 103,114 ----
  358.               do {
  359.                   xpos -= xinc;
  360.                   ypos -= yinc;
  361. !             } while( board[ypos][xpos] >= 'A' );
  362. ! #ifdef DBLSIZE_BOARD
  363. !             move( BOARD_UY + ypos - 1, BOARD_LX + xpos * 2 - 2 );
  364. ! #else
  365. !             move( BOARD_UY + ypos - 1, BOARD_LX + xpos - 1 );
  366. ! #endif
  367.               addch( newlet[placed].oldlet );
  368.               plr_tiles[human_player][newlet[placed].tilepos]
  369.                 = newlet[placed].letter;
  370. ***************
  371. *** 103,110 ****
  372.                   do {
  373.                       xpos -= xinc;
  374.                       ypos -= yinc;
  375. !                 } while( board[ypos - BOARD_UY + 1][xpos - BOARD_LX + 1] >= 'A' );
  376. !                 move( ypos, xpos );
  377.                   addch( newlet[placed].oldlet );
  378.                   plr_tiles[human_player][newlet[placed].tilepos]
  379.                     = newlet[placed].letter;
  380. --- 118,129 ----
  381.                   do {
  382.                       xpos -= xinc;
  383.                       ypos -= yinc;
  384. !                 } while( board[ypos][xpos] >= 'A' );
  385. ! #ifdef DBLSIZE_BOARD
  386. !                 move( BOARD_UY + ypos - 1, BOARD_LX + xpos * 2 - 2 );
  387. ! #else
  388. !                 move( BOARD_UY + ypos - 1, BOARD_LX + xpos - 1 );
  389. ! #endif
  390.                   addch( newlet[placed].oldlet );
  391.                   plr_tiles[human_player][newlet[placed].tilepos]
  392.                     = newlet[placed].letter;
  393. ***************
  394. *** 191,197 ****
  395.               } else press_return();
  396.               show_instructions();
  397.           } else {
  398. !             if( xpos > BOARD_RX || ypos > BOARD_LY ) continue;
  399.               tile = -1;
  400.               for( i = 0; i < 7; i++ ) {
  401.                   if( c == plr_tiles[human_player][i] ) tile = i;
  402. --- 210,216 ----
  403.               } else press_return();
  404.               show_instructions();
  405.           } else {
  406. !             if( xpos > 15 || ypos > 15 ) continue;
  407.               tile = -1;
  408.               for( i = 0; i < 7; i++ ) {
  409.                   if( c == plr_tiles[human_player][i] ) tile = i;
  410. ***************
  411. *** 203,212 ****
  412.                   newlet[placed].blankchar = c;
  413.               newlet[placed].letter = plr_tiles[human_player][tile];
  414.               plr_tiles[human_player][tile] = 0;
  415. !             newlet[placed].x = xpos - BOARD_LX + 1;
  416. !             newlet[placed].y = ypos - BOARD_UY + 1;
  417. !             newlet[placed].oldlet =
  418. !               board[ypos - BOARD_UY + 1][xpos - BOARD_LX + 1];
  419.               if( newlet[placed].oldlet == CH_DW ) newlet[placed].oldlet = 'o';
  420.               newlet[placed].tilepos = tile;
  421.               addch( newlet[placed].letter );
  422. --- 222,230 ----
  423.                   newlet[placed].blankchar = c;
  424.               newlet[placed].letter = plr_tiles[human_player][tile];
  425.               plr_tiles[human_player][tile] = 0;
  426. !             newlet[placed].x = xpos;
  427. !             newlet[placed].y = ypos;
  428. !             newlet[placed].oldlet = board[ypos][xpos];
  429.               if( newlet[placed].oldlet == CH_DW ) newlet[placed].oldlet = 'o';
  430.               newlet[placed].tilepos = tile;
  431.               addch( newlet[placed].letter );
  432. ***************
  433. *** 213,220 ****
  434.               do {
  435.                   xpos += xinc;
  436.                   ypos += yinc;
  437. !             } while( board[ypos - BOARD_UY + 1][xpos - BOARD_LX + 1] >= 'A'
  438. !               && xpos <= BOARD_RX && ypos <= BOARD_LY );
  439.               print_tiles();
  440.               placed++;
  441.           }
  442. --- 231,237 ----
  443.               do {
  444.                   xpos += xinc;
  445.                   ypos += yinc;
  446. !             } while( board[ypos][xpos] >= 'A' && xpos <= 15 && ypos <= 15 );
  447.               print_tiles();
  448.               placed++;
  449.           }
  450. *** score.c.orig    Tue Aug  4 11:26:00 1992
  451. --- score.c    Mon Oct 26 08:17:42 1992
  452. ***************
  453. *** 98,103 ****
  454. --- 98,104 ----
  455.   
  456.       f = wlen[strlen( word )];
  457.       l = wlen[strlen( word ) + 1] - 1;
  458. +     if( f > l ) return( 0 );
  459.       found = 0;
  460.       do {
  461.           m = ( f + l ) / 2;
  462. ***************
  463. *** 143,148 ****
  464. --- 144,150 ----
  465.           }
  466.           printw( "%s  ", word );
  467.           score += new_words[i].score;
  468. +         xloc += strlen( word ) + 2;
  469.           if( bin_search( word ) == 0 ) {
  470.               ind[illword++] = i;
  471.           }
  472. ***************
  473. *** 156,163 ****
  474.           }
  475.           for( i = 0; i < illword; i++ ) {
  476.               clear_rect( 21, 0, 22, 79 );
  477.               printw( "  %s is not in the computer's dictionary.\n",
  478. !               &(new_words[i].letters[0]) );
  479.               printw( "  Is it a valid Scrabble word (y/n)? " );
  480.               refresh();
  481.               do {
  482. --- 158,166 ----
  483.           }
  484.           for( i = 0; i < illword; i++ ) {
  485.               clear_rect( 21, 0, 22, 79 );
  486. +             j = ind[i];
  487.               printw( "  %s is not in the computer's dictionary.\n",
  488. !               &(new_words[j].letters[0]) );
  489.               printw( "  Is it a valid Scrabble word (y/n)? " );
  490.               refresh();
  491.               do {
  492. ***************
  493. *** 166,174 ****
  494.               if( c == 'N' ) break;
  495.               clear_rect( 21, 0, 22, 79 );
  496.               printw( "  Inserting %s into the dictionary...",
  497. !               &(new_words[i].letters[0]) );
  498.               refresh();
  499. !             add_dict( &(new_words[i].letters[0]) );
  500.               dict_changed = 1;
  501.           }
  502.           clear_rect( 21, 0, 22, 79 );
  503. --- 169,177 ----
  504.               if( c == 'N' ) break;
  505.               clear_rect( 21, 0, 22, 79 );
  506.               printw( "  Inserting %s into the dictionary...",
  507. !               &(new_words[j].letters[0]) );
  508.               refresh();
  509. !             add_dict( &(new_words[j].letters[0]) );
  510.               dict_changed = 1;
  511.           }
  512.           clear_rect( 21, 0, 22, 79 );
  513. ***************
  514. *** 246,258 ****
  515.       for( p1 = wlen[l];
  516.             p1 < wlen[l + 1] && strcmp( word, &(words[wptr[p1]]) ) > 0;
  517.             p1++ );
  518. !     for( p2 = dict_size - 1; p2 >= wptr[p1]; p2-- ) words[p2 + l + 1] = words[p2];
  519. !     for( p2 = wlen[16]; p2 > p1; p2-- ) wptr[p2] = wptr[p2 - 1] + l + 1;
  520.       for( i = l + 1; i < 17; i++ ) wlen[i]++;
  521.       strcpy( &(words[wptr[p1]]), word );
  522.       dict_size += l + 1;
  523.   /*    printw( "\n  " );
  524. !     for( p2 = p1 - 2; p2 < p1 + 3; p2++ )
  525.           printw( "%s  ", &(words[wptr[p2]]) );
  526.       printw( "%s  %s", &(words[wptr[wlen[8]]]), &(words[wptr[wlen[16] - 1]]) );
  527.       press_return(); */
  528. --- 249,261 ----
  529.       for( p1 = wlen[l];
  530.             p1 < wlen[l + 1] && strcmp( word, &(words[wptr[p1]]) ) > 0;
  531.             p1++ );
  532. !     for( p2 = dict_size; p2 >= wptr[p1]; p2-- ) words[p2 + l + 1] = words[p2];
  533. !     for( p2 = wlen[16] + 1; p2 > p1; p2-- ) wptr[p2] = wptr[p2 - 1] + l + 1;
  534.       for( i = l + 1; i < 17; i++ ) wlen[i]++;
  535.       strcpy( &(words[wptr[p1]]), word );
  536.       dict_size += l + 1;
  537.   /*    printw( "\n  " );
  538. !     for( p2 = ( p1 - 2 >= 0 ? p1 - 2 : 0 ); p2 < p1 + 3 && p2 <= wlen[16]; p2++ )
  539.           printw( "%s  ", &(words[wptr[p2]]) );
  540.       printw( "%s  %s", &(words[wptr[wlen[8]]]), &(words[wptr[wlen[16] - 1]]) );
  541.       press_return(); */
  542. *** scrab.h.orig    Tue Sep 15 13:42:33 1992
  543. --- scrab.h    Mon Oct 26 08:17:45 1992
  544. ***************
  545. *** 19,35 ****
  546.   #define CH_BL            '*'
  547.   #define CH_IT            '_'
  548.   
  549. - #define BOARD_UY        2
  550. - #define BOARD_LY        16
  551. - #define BOARD_LX        34
  552. - #define BOARD_RX        48
  553.   #define INFO_Y            2
  554.   #define INFO_X            0
  555.   #define TILE_RACKS_Y    2
  556. ! #define TILE_RACKS_X    54
  557.   #define TILES_LEFT_Y    0
  558.   #define TILES_LEFT_X    57
  559.   /* #define PRINT_CPU_TILES */
  560.   
  561.   #define DICT_FILE        "scrabbledict"
  562.   
  563. --- 19,45 ----
  564.   #define CH_BL            '*'
  565.   #define CH_IT            '_'
  566.   
  567.   #define INFO_Y            2
  568.   #define INFO_X            0
  569.   #define TILE_RACKS_Y    2
  570. ! #define TILE_RACKS_X    59
  571.   #define TILES_LEFT_Y    0
  572.   #define TILES_LEFT_X    57
  573. + 
  574.   /* #define PRINT_CPU_TILES */
  575. + /* #define DBLSIZE_BOARD */
  576. + 
  577. + #ifdef  DBLSIZE_BOARD
  578. + #define BOARD_UY        2
  579. + #define BOARD_LY        16
  580. + #define BOARD_LX        25
  581. + #define BOARD_RX        53
  582. + #else
  583. + #define BOARD_UY        2
  584. + #define BOARD_LY        16
  585. + #define BOARD_LX        32
  586. + #define BOARD_RX        46
  587. + #endif
  588.   
  589.   #define DICT_FILE        "scrabbledict"
  590.   
  591. *** scrabble.6.orig    Wed Sep 16 12:46:16 1992
  592. --- scrabble.6    Mon Oct 26 08:17:46 1992
  593. ***************
  594. *** 1,5 ****
  595. ! .\" @(#)scrabble.6 1.02 92/09/16 JAC
  596. ! .TH SCRABBLE 6 "16 September 1992"
  597.   .SH NAME
  598.   scrabble \- play the Scrabble(TM) board game
  599.   .SH SYNOPSIS
  600. --- 1,5 ----
  601. ! .\" @(#)scrabble.6 1.03 92/09/16 JAC
  602. ! .TH SCRABBLE 6 "5 October 1992"
  603.   .SH NAME
  604.   scrabble \- play the Scrabble(TM) board game
  605.   .SH SYNOPSIS
  606. ***************
  607. *** 7,13 ****
  608.   .SH DESCRIPTION
  609.   .LP
  610.   .B scrabble
  611. ! is a computer version of the Selchow & Righter board game, Scrabble.
  612.   Only one human player plays; the user may select the number of
  613.   computer opponents, from one to three.
  614.   .SH BASIC SCRABBLE RULES
  615. --- 7,13 ----
  616.   .SH DESCRIPTION
  617.   .LP
  618.   .B scrabble
  619. ! is a computer version of the Milton Bradley board game, Scrabble.
  620.   Only one human player plays; the user may select the number of
  621.   computer opponents, from one to three.
  622.   .SH BASIC SCRABBLE RULES
  623. ***************
  624. *** 241,246 ****
  625. --- 241,250 ----
  626.   l
  627.   Moves the cursor right.  If the cursor is on the right edge
  628.   of the board, this key has no effect.
  629. + .TP
  630. + ^L
  631. + Redraws the screen.  This is provided in case the screen
  632. + should somehow become corrupted.
  633.   .TP
  634.   RETURN
  635.   Starts placing tiles on the board.  If the cursor is over
  636. *** smain.c.orig    Tue Sep 15 13:45:37 1992
  637. --- smain.c    Mon Oct 26 08:17:43 1992
  638. ***************
  639. *** 76,96 ****
  640.       move( INFO_Y + 5, INFO_X + 2 );
  641.       printw( "%c: Blank tile", CH_BL );
  642.       move( INFO_Y + 7, INFO_X );
  643. !     printw( "Tile values & distributions:" );
  644.       move( INFO_Y + 8, INFO_X + 2 );
  645. !     printw( "A-1, 9  H-4, 2  O-1, 8  V-4, 2" );
  646.       move( INFO_Y + 9, INFO_X + 2 );
  647. !     printw( "B-3, 2  I-1, 9  P-3, 2  W-4, 2" );
  648.       move( INFO_Y +10, INFO_X + 2 );
  649. !     printw( "C-3, 2  J-8, 1  Q10, 1  X-8, 1" );
  650.       move( INFO_Y +11, INFO_X + 2 );
  651. !     printw( "D-2, 4  K-5, 1  R-1, 6  Y-4, 2" );
  652. !     move( INFO_Y +12, INFO_X + 2 );
  653. !     printw( "E-1,12  L-1, 4  S-1, 4  Z10, 1" );
  654.       move( INFO_Y +13, INFO_X + 2 );
  655. !     printw( "F-4, 2  M-3, 2  T-1, 6  %c-0, 2", CH_BL );
  656.       move( INFO_Y +14, INFO_X + 2 );
  657. !     printw( "G-2, 3  N-1, 6  U-1, 4" );
  658.       refresh();
  659.   }
  660.   
  661. --- 76,96 ----
  662.       move( INFO_Y + 5, INFO_X + 2 );
  663.       printw( "%c: Blank tile", CH_BL );
  664.       move( INFO_Y + 7, INFO_X );
  665. !     printw( "Tile distribs & values:" );
  666.       move( INFO_Y + 8, INFO_X + 2 );
  667. !     printw( "9A1  2H4  8O1  2V4" );
  668.       move( INFO_Y + 9, INFO_X + 2 );
  669. !     printw( "2B3  9I1  2P3  2W4" );
  670.       move( INFO_Y +10, INFO_X + 2 );
  671. !     printw( "2C3  1J8  1Q10 1X8" );
  672.       move( INFO_Y +11, INFO_X + 2 );
  673. !     printw( "4D2  1K5  6R1  2Y4" );
  674. !     move( INFO_Y +12, INFO_X + 1 );
  675. !     printw( "12E1  4L1  4S1  1Z10" );
  676.       move( INFO_Y +13, INFO_X + 2 );
  677. !     printw( "2F4  2M3  6T1  2%c0", CH_BL );
  678.       move( INFO_Y +14, INFO_X + 2 );
  679. !     printw( "3G2  6N1  4U1" );
  680.       refresh();
  681.   }
  682.   
  683. ***************
  684. *** 144,150 ****
  685.           if( j == 4 ) strcpy( cs, "fourth" );
  686.           printw( "\n  You will play %s.", cs );
  687.           human_player = j - 1;
  688. !         print_tiles_left( 100 );
  689.           press_return();
  690.           clear_prompt();
  691.           refresh();
  692. --- 144,150 ----
  693.           if( j == 4 ) strcpy( cs, "fourth" );
  694.           printw( "\n  You will play %s.", cs );
  695.           human_player = j - 1;
  696. !         print_tiles_left();
  697.           press_return();
  698.           clear_prompt();
  699.           refresh();
  700. ***************
  701. *** 300,313 ****
  702.       int i;
  703.   
  704.       set_up_window();
  705. !     clear();
  706. !     printw( "*** SCRABBLE 1.21 ***\n\n" );
  707.   
  708.       read_words();
  709.       dict_changed = 0;
  710.   
  711. !     clear();
  712. !     printw( "*** SCRABBLE 1.21 ***\n\n" );
  713.   
  714.       init_board();
  715.       seed_random();
  716. --- 300,311 ----
  717.       int i;
  718.   
  719.       set_up_window();
  720. !     print_version();
  721.   
  722.       read_words();
  723.       dict_changed = 0;
  724.   
  725. !     print_version();
  726.   
  727.       init_board();
  728.       seed_random();
  729. ***************
  730. *** 319,326 ****
  731.       abort = 0;
  732.       do {
  733.           for( plr = 0; plr < players; plr++ ) {
  734. !             clear_turn();
  735. !             printw( "*** %s turn to play  ", your[plr] );
  736.               if( plr == human_player ) {
  737.                   player_move();
  738.               } else {
  739. --- 317,323 ----
  740.       abort = 0;
  741.       do {
  742.           for( plr = 0; plr < players; plr++ ) {
  743. !             print_whos_move( plr );
  744.               if( plr == human_player ) {
  745.                   player_move();
  746.               } else {
  747. ***************
  748. *** 327,338 ****
  749.                   computer_move( plr );
  750.               }
  751.               if( abort != 0 ) break;
  752. !             if( game_done == 0 ) clear_rect( 1, 50, 1, 79 );
  753. !             else {
  754. !                 move( 1, 64 );
  755. !                 printw( "Passed turns:  %d", game_done );
  756. !             }
  757. !             refresh();
  758.               if( game_done == players ) break;
  759.               for( i = 0; i < 7; i++ )
  760.                   if( plr_tiles[plr][i] != 0 ) break;
  761. --- 324,330 ----
  762.                   computer_move( plr );
  763.               }
  764.               if( abort != 0 ) break;
  765. !             print_passed_turns();
  766.               if( game_done == players ) break;
  767.               for( i = 0; i < 7; i++ )
  768.                   if( plr_tiles[plr][i] != 0 ) break;
  769. *** /dev/null    Mon Oct 26 08:10:12 1992
  770. --- CHANGES    Mon Oct 26 08:19:02 1992
  771. ***************
  772. *** 0 ****
  773. --- 1,53 ----
  774. + Here is a list of people who suggested changes to scrabble, followed by my
  775. + responses to them
  776. + 
  777. + 
  778. + 1.   alainc%tollys.UUCP%bnrmtl.UUCP@Larry.McRCIM.McGill.EDU (Alain Caron)
  779. +    was trying to get scrabble to work with a french dictionary, and there were
  780. +    bugs in the dictionary insertion routine.  They have now been fixed.
  781. +    These bugs were quite serious.
  782. + 
  783. + 2.   "Bradley D. Keister" <keister@poincare.phys.cmu.edu> noticed some problems
  784. +    once with how scrabble was displayed on his screen.  As well, Nick Sayer
  785. +    <mrapple@quack.sac.ca.us> recommended that a redraw screen key be added.
  786. + 
  787. +    Now, the screen may be redrawn by pressing ctrl-L when it is the human
  788. +    player's turn.  It may only be used when moving around the board with the
  789. +    'hjkl' keys; if you are placing tiles or anything else, you must press ESC
  790. +    before pressing ctrl-L.  As well, it cannot be redrawn when the computer
  791. +    players are playing.  The justification for this is that, the computer play-
  792. +    ers don't actually care about the screen layout when they're playing a move
  793. +    whereas the human player does.  Thus, it seemed acceptable that only during
  794. +    the human player's turn may the screen be redrawn.
  795. + 
  796. + 3.   wixer!cb@cs.utexas.edu (Cyberspace Buddha) recommended the use of the
  797. +    Official Scrabble Players' Dictionary with scrabble.  He tells me a copy
  798. +    may be obtained from 
  799. + 
  800. +     Christopher Hall
  801. +     P.O. Box 26025
  802. +     Austin, Tx 78755-0025
  803. + 
  804. +     FidoNet    : 1:382/29.4
  805. +     CompuServe  : 72150,752
  806. + 
  807. + 4.   Nick Sayer <mrapple@quack.sac.ca.us> recommended that the board width be
  808. +    doubled, partly to make the board look more square, and partly to allow
  809. +    reverse-video to be displayed on "magic-cookie" type terminals.
  810. + 
  811. +    Now, the file scrab.h has a preprocessor directive which may be uncommented:
  812. + 
  813. +    /* #define DBLSIZE_BOARD */
  814. + 
  815. +    If this directive is uncommented, the board width doubles.  Otherwise, it
  816. +    remains as narrow as in V1.21.  I prefer the narrow board, myself.
  817. + 
  818. + 5.   sthomas@serene.clipper.ingr.com (Steve Thomas) points out that, in fact,
  819. +    Selchow and Righter no longer own the rights to scrabble.  Depending on the
  820. +    country, the rights are now owned by Milton Bradley or JW Spear & Sons.
  821. + 
  822. +    As well, Steve had a number of good suggestions for improving the computer
  823. +    players' speed.  He recommended a form of rack management, and he directed
  824. +    me to an article by Appel & Jacobson about how to improve the computer.  I
  825. +    have not implemented his suggestions yet.  Maybe later...
  826. + 
  827.