home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 October / usenetsourcesnewsgroupsinfomagicoctober1994disk2.iso / games / volume11 / reve / patch3f / patches03c
Text File  |  1991-01-03  |  48KB  |  1,422 lines
  1.  
  2. ------- main.c -------
  3. *** /tmp/da07594    Sun Dec  9 15:14:38 1990
  4. --- main.c    Sat Dec  8 19:41:09 1990
  5. ***************
  6. *** 25,37 ****
  7.   #include "reve.h"
  8.   #include "color.h"
  9.   #include "patchlevel.h"
  10. ! #ifdef SYSV
  11. ! #include <string.h>
  12. ! #include <sys/times.h>
  13. ! #else
  14. ! #include <strings.h>
  15. ! #include <sys/time.h>
  16. ! #endif /*SYSV*/
  17.   
  18.   #ifdef X11
  19.   #include <X11/Xos.h>
  20. --- 25,31 ----
  21.   #include "reve.h"
  22.   #include "color.h"
  23.   #include "patchlevel.h"
  24. ! #include <ctype.h>
  25.   
  26.   #ifdef X11
  27.   #include <X11/Xos.h>
  28. ***************
  29. *** 45,58 ****
  30.   #endif /*NO_TIMEVAL*/
  31.   
  32.   /* Text values for the cyclic buttons. */
  33. ! char *diff_values[] = { "1", "2", "3", "4", "5", "6", "7", "8", "9", NULL } ;
  34. ! char *notes_values[] = { "off", "on", NULL } ;
  35.   char *player_values[] = { "human", "computer", NULL } ;
  36.   
  37.   enum cantype cmode, last_cmode ;
  38.   enum disp_type dtype ;
  39.   enum dpy_type cur_dpyno ;
  40.   enum set_type direction ;   /* Incremental direction for cycle item. */
  41.   
  42.   int tx, ty, tw, th ;    /* Position and size of text field. */
  43.   
  44. --- 39,65 ----
  45.   #endif /*NO_TIMEVAL*/
  46.   
  47.   /* Text values for the cyclic buttons. */
  48. ! char *comp_plays[]    = { "white", "black", "neither", "both" } ;
  49. ! char *diff_values[]   = { "1", "2", "3", "4", "5", "6", "7", "8", "9", NULL } ;
  50. ! char *notes_values[]  = { "off", "on", NULL } ;
  51.   char *player_values[] = { "human", "computer", NULL } ;
  52.   
  53. + char *resources[] = {      /* Reve X resources read. */
  54. +   "animate",               /* Boolean: show animation. */
  55. +   "bestmove",              /* Boolean: show computer best move so far. */
  56. +   "difficulty",            /* Integer: difficulty level. */
  57. +   "last",                  /* Boolean: show last move (with a square). */
  58. +   "log",                   /* Boolean: write computer info to log file. */
  59. +   "notes",                 /* Boolean: show computer notes. */
  60. +   "number",                /* Boolean: show last move (number on stone). */
  61. +   "quick"                  /* Boolean: play quick game (don't flip stones). */
  62. + } ;
  63. + 
  64.   enum cantype cmode, last_cmode ;
  65.   enum disp_type dtype ;
  66.   enum dpy_type cur_dpyno ;
  67.   enum set_type direction ;   /* Incremental direction for cycle item. */
  68. + enum win_type curwin ;      /* Window the current event for in. */
  69.   
  70.   int tx, ty, tw, th ;    /* Position and size of text field. */
  71.   
  72. ***************
  73. *** 59,75 ****
  74.   int piece_x ;           /* Current X position of moving piece. */
  75.   int piece_y ;           /* Current Y position of moving piece */
  76.   
  77. - int animation ;         /* If set, show computer move glide and piece drag. */
  78.   int best_cmove ;        /* Best computer move so far. */
  79.   int bfont_height ;      /* Height in pixels for bold font. */
  80.   int but_inverted ;      /* Value of panel item inverted. */
  81.   int color ;             /* Current color value. */
  82.   int cur_ch ;            /* Current character pressed. */
  83.   int curx ;              /* Current mouse X position. */
  84.   int cury ;              /* Current mouse Y position. */
  85. - int do_bestmove ;       /* If set, continuously update computers best move. */
  86. - int do_last ;           /* If set, don't show last move. */
  87. - int do_number ;         /* If set, the last stone placed is numbered. */
  88.   int down ;              /* Indicates is a mouse button is down. */
  89.   int first_move = 0 ;    /* Set if computer plays first move. */
  90.   int iconic ;            /* Set if window is currently iconic. */
  91. --- 66,79 ----
  92.   int piece_x ;           /* Current X position of moving piece. */
  93.   int piece_y ;           /* Current Y position of moving piece */
  94.   
  95.   int best_cmove ;        /* Best computer move so far. */
  96.   int bfont_height ;      /* Height in pixels for bold font. */
  97.   int but_inverted ;      /* Value of panel item inverted. */
  98. + int cmove_depth ;       /* Depth of the current best computer move. */
  99.   int color ;             /* Current color value. */
  100.   int cur_ch ;            /* Current character pressed. */
  101.   int curx ;              /* Current mouse X position. */
  102.   int cury ;              /* Current mouse Y position. */
  103.   int down ;              /* Indicates is a mouse button is down. */
  104.   int first_move = 0 ;    /* Set if computer plays first move. */
  105.   int iconic ;            /* Set if window is currently iconic. */
  106. ***************
  107. *** 94,103 ****
  108.   int nfont_height ;      /* Height in pixels for normal font. */
  109.   int play_computer ;     /* Set if playing against the computer. */
  110.   int posspec ;           /* Set if -Wp or -g option is present (for X11) */
  111. ! int quickgame ;         /* If set, don't flash turning stones. */
  112.   int saveres = 0 ;       /* If set, save computer results to log file. */
  113.   int show_moves ;        /* If set, all possible moves are being shown. */
  114. - int show_notes ;        /* If set, display notes value from play_reve. */
  115.   int suggestion = -1 ;   /* Positive if a suggested move. */
  116.   int suggest_x ;         /* X position of suggested move. */
  117.   int suggest_y ;         /* Y position of suggested move. */
  118. --- 98,107 ----
  119.   int nfont_height ;      /* Height in pixels for normal font. */
  120.   int play_computer ;     /* Set if playing against the computer. */
  121.   int posspec ;           /* Set if -Wp or -g option is present (for X11) */
  122. ! int processing ;        /* If set, computer is procesing a move. */
  123. ! int props_showing ;     /* If set, the property window is visible. */
  124.   int saveres = 0 ;       /* If set, save computer results to log file. */
  125.   int show_moves ;        /* If set, all possible moves are being shown. */
  126.   int suggestion = -1 ;   /* Positive if a suggested move. */
  127.   int suggest_x ;         /* X position of suggested move. */
  128.   int suggest_y ;         /* Y position of suggested move. */
  129. ***************
  130. *** 127,186 ****
  131.   
  132.   BOARD moves[64] ;          /* Complete array of board moves. */
  133.   
  134. ! struct iteminfo items[MAXITEMS] = {                     /* Panel items. */
  135.   
  136. ! /*   type   x   y   width   height   text   value   function */
  137.   
  138. ! { P_BUTTON,  BBORDER + (0*(BWIDTH+BGAP)), BBORDER + (0*(BHEIGHT+BGAP)),
  139. !              BWIDTH, BHEIGHT, "load",     0, draw_textfield },
  140.   
  141. ! { P_BUTTON,  BBORDER + (1*(BWIDTH+BGAP)), BBORDER + (0*(BHEIGHT+BGAP)),
  142. !              BWIDTH, BHEIGHT, "moves?",   0, show_all_moves },
  143.   
  144. ! { P_BUTTON,  BBORDER + (2*(BWIDTH+BGAP)), BBORDER + (0*(BHEIGHT+BGAP)),
  145. !              BWIDTH, BHEIGHT, "new game", 0, new_game },
  146.   
  147. ! { P_BUTTON,  BBORDER + (3*(BWIDTH+BGAP)), BBORDER + (0*(BHEIGHT+BGAP)),
  148. !              BWIDTH, BHEIGHT, "save",     0, draw_textfield },
  149.   
  150. ! { P_BUTTON,  BBORDER + (4*(BWIDTH+BGAP)), BBORDER + (0*(BHEIGHT+BGAP)),
  151. !              BWIDTH, BHEIGHT, "suggest",  0, suggest },
  152.   
  153. ! { P_BUTTON,  BBORDER + (5*(BWIDTH+BGAP)), BBORDER + (0*(BHEIGHT+BGAP)),
  154. !              BWIDTH, BHEIGHT, "undo",     0, undo },
  155.   
  156. ! { P_BUTTON,  BBORDER + (0*(BWIDTH+BGAP)), BBORDER + (1*(BHEIGHT+BGAP)),
  157. !              BWIDTH, BHEIGHT, "iconify",  0, done },
  158.   
  159. ! { P_BUTTON,  -1,                          -1,   /* Not normally active. */
  160. !              BWIDTH, BHEIGHT, "cancel",  0, remove_textfield },
  161.   
  162. ! { P_BUTTON,  BBORDER + (5*(BWIDTH+BGAP)), BBORDER + (1*(BHEIGHT+BGAP)),
  163. !              BWIDTH, BHEIGHT, "quit",     0, quit },
  164.   
  165. ! { P_CYCLE,   BBORDER + (0*(BWIDTH+BGAP)), BBORDER + (2*(BHEIGHT+BGAP)),
  166. !              CWIDTH, CHEIGHT, "Black:", 0, init_player },
  167.   
  168. ! { P_CYCLE,   BBORDER + (3*(BWIDTH+BGAP)), BBORDER + (2*(BHEIGHT+BGAP)),
  169. !              CWIDTH, CHEIGHT, "White:", 1, init_player },
  170.   
  171. ! { P_CYCLE,   BBORDER + (0*(BWIDTH+BGAP)), BBORDER + (3*(BHEIGHT+BGAP)),
  172. !              CWIDTH, CHEIGHT, "Difficulty:", INIT_DEPTH, difficulty },
  173.   
  174. ! { P_CYCLE,   BBORDER + (3*(BWIDTH+BGAP)), BBORDER + (3*(BHEIGHT+BGAP)),
  175. !              CWIDTH, CHEIGHT, "Notes:",      FALSE,      init_notes },
  176.   
  177. ! { P_MESSAGE, BBORDER + (0*(BWIDTH+BGAP)), BBORDER + (4*(BHEIGHT+BGAP)),
  178. !              0, 0, "Use left mouse button to move", 0, NULL },
  179.   
  180. ! { P_MESSAGE, BBORDER + (0*(BWIDTH+BGAP)), BBORDER + (5*(BHEIGHT+BGAP)),
  181. !              0, 0, "",                                   0, NULL },
  182.   
  183. ! { P_MESSAGE, BBORDER + (0*(BWIDTH+BGAP)), BBORDER + (6*(BHEIGHT+BGAP)),
  184. !              0, 0, "White:  2, Black:  2",               0, NULL },
  185.   
  186. ! { P_MESSAGE, BBORDER + (3*(BWIDTH+BGAP)), BBORDER + (6*(BHEIGHT+BGAP)),
  187. !              0, 0, "",                                   0, NULL },
  188.   } ;
  189.   
  190.   char geometry[MAXDPY][MAXLINE] ;       /* X11 geometry information. */
  191. --- 131,376 ----
  192.   
  193.   BOARD moves[64] ;          /* Complete array of board moves. */
  194.   
  195. ! struct iteminfo items[MAXITEMS] = {   /* Panel items. */
  196.   
  197. ! /*  wtype     type    lx    ly           Main window items.
  198. !  *  label
  199. !  *  x         y
  200. !  *  width     height  text  value
  201. !  *  options   nopts
  202. !  *  function
  203. !  */
  204.   
  205. !   {                                   /* load button. */
  206. !     W_MAIN, P_BUTTON, 0, 0,
  207. !     "",
  208. !     BBORDER + (0*(BWIDTH+BGAP)), BBORDER + (0*(BHEIGHT+BGAP)),
  209. !     BWIDTH, BHEIGHT, "load", 0,
  210. !     (char **) NULL, 0,
  211. !     draw_textfield
  212. !   },
  213.   
  214. !   {                                   /* moves? button. */
  215. !     W_MAIN, P_BUTTON, 0, 0,
  216. !     "",
  217. !     BBORDER + (1*(BWIDTH+BGAP)), BBORDER + (0*(BHEIGHT+BGAP)),
  218. !     BWIDTH, BHEIGHT, "moves?", 0,
  219. !     (char **) NULL, 0,
  220. !     show_all_moves
  221. !   },
  222.   
  223. !   {                                   /* new game button. */
  224. !     W_MAIN, P_BUTTON, 0, 0,
  225. !     "",
  226. !     BBORDER + (2*(BWIDTH+BGAP)), BBORDER + (0*(BHEIGHT+BGAP)),
  227. !     BWIDTH, BHEIGHT, "new game", 0,
  228. !     (char **) NULL, 0,
  229. !     new_game
  230. !   },
  231.   
  232. !   {                                   /* save button. */
  233. !     W_MAIN, P_BUTTON, 0, 0,
  234. !     "",
  235. !     BBORDER + (3*(BWIDTH+BGAP)), BBORDER + (0*(BHEIGHT+BGAP)),
  236. !     BWIDTH, BHEIGHT, "save", 0,
  237. !     (char **) NULL, 0,
  238. !     draw_textfield
  239. !   },
  240. !   
  241. !   {                                   /* suggest button. */
  242. !     W_MAIN, P_BUTTON, 0, 0,
  243. !     "",
  244. !     BBORDER + (4*(BWIDTH+BGAP)), BBORDER + (0*(BHEIGHT+BGAP)),
  245. !     BWIDTH, BHEIGHT, "suggest", 0,
  246. !     (char **) NULL, 0,
  247. !     suggest
  248. !   },
  249. !   
  250. !   {                                   /* undo button. */
  251. !     W_MAIN, P_BUTTON, 0, 0,
  252. !     "",
  253. !     BBORDER + (5*(BWIDTH+BGAP)), BBORDER + (0*(BHEIGHT+BGAP)),
  254. !     BWIDTH, BHEIGHT, "undo", 0,
  255. !     (char **) NULL, 0,
  256. !     undo
  257. !   },
  258. !   
  259. !   {                                   /* props button. */
  260. !     W_MAIN, P_BUTTON, 0, 0,
  261. !     "",
  262. !     BBORDER + (0*(BWIDTH+BGAP)), BBORDER + (1*(BHEIGHT+BGAP)),
  263. !     BWIDTH, BHEIGHT, "props", 0,
  264. !     (char **) NULL, 0,
  265. !     do_props
  266. !   },
  267.   
  268. !   {                                   /* cancel button. */
  269. !     W_MAIN, P_BUTTON, 0, 0,
  270. !     "",
  271. !     -1, -1,                           /* Not normally active. */
  272. !     BWIDTH, BHEIGHT, "cancel", 0,
  273. !     (char **) NULL, 0,
  274. !     remove_textfield
  275. !   },
  276. !   
  277. !   {                                   /* quit button. */
  278. !     W_MAIN, P_BUTTON, 0, 0,
  279. !     "",
  280. !     BBORDER + (5*(BWIDTH+BGAP)), BBORDER + (1*(BHEIGHT+BGAP)),
  281. !     BWIDTH, BHEIGHT, "quit", 0,
  282. !     (char **) NULL, 0,
  283. !     quit
  284. !   },
  285. !   
  286. !   {                                   /* Black player message item. */
  287. !     W_MAIN, P_MESSAGE,
  288. !     BBORDER + (0*(BWIDTH+BGAP)), BBORDER + (2*(BHEIGHT+BGAP)),
  289. !     "Black:",
  290. !     BBORDER + (2*(BWIDTH+BGAP)), BBORDER + (2*(BHEIGHT+BGAP)),
  291. !     CWIDTH, CHEIGHT, "", 0,
  292. !     (char **) NULL, 0,
  293. !     NULL
  294. !   },
  295. !   
  296. !   {                                   /* White player message item. */
  297. !     W_MAIN, P_MESSAGE,
  298. !     BBORDER + (3*(BWIDTH+BGAP)), BBORDER + (2*(BHEIGHT+BGAP)),
  299. !     "White:",
  300. !     BBORDER + (5*(BWIDTH+BGAP)), BBORDER + (2*(BHEIGHT+BGAP)),
  301. !     CWIDTH, CHEIGHT, "", 1,
  302. !     (char **) NULL, 0,
  303. !     NULL
  304. !   },
  305.   
  306. !   {                                   /* Panel message item. */
  307. !     W_MAIN, P_MESSAGE, 0, 0,
  308. !     "",
  309. !     BBORDER + (0*(BWIDTH+BGAP)), BBORDER + (3*(BHEIGHT+BGAP)),
  310. !     0, 0, "Use left mouse button to move", 0,
  311. !     (char **) NULL, 0,
  312. !     NULL
  313. !   },
  314.   
  315. !   {                                   /* Notes message item. */
  316. !     W_MAIN, P_MESSAGE, 0, 0,
  317. !     "",
  318. !     BBORDER + (0*(BWIDTH+BGAP)), BBORDER + (4*(BHEIGHT+BGAP)),
  319. !     0, 0, "", 0,
  320. !     (char **) NULL, 0,
  321. !     NULL
  322. !   },
  323.   
  324. !   {                                   /* Score message item. */
  325. !     W_MAIN, P_MESSAGE, 0, 0,
  326. !     "",
  327. !     BBORDER + (0*(BWIDTH+BGAP)), BBORDER + (5*(BHEIGHT+BGAP)),
  328. !     0, 0, "White:  2, Black:  2", 0,
  329. !     (char **) NULL, 0,
  330. !     NULL
  331. !   },
  332.   
  333. !   {                                   /* Turn message item. */
  334. !     W_MAIN, P_MESSAGE, 0, 0,
  335. !     "",
  336. !     BBORDER + (3*(BWIDTH+BGAP)), BBORDER + (5*(BHEIGHT+BGAP)),
  337. !     0, 0, "", 0,
  338. !     (char **) NULL, 0,
  339. !     NULL
  340. !   },
  341.   
  342. ! /*  wtype     type                    Property window items.
  343. !  *  lx        ly
  344. !  *  label
  345. !  *  x         y
  346. !  *  width     height  text  value
  347. !  *  options   nopts
  348. !  *  function
  349. !  */
  350.   
  351. !   {                                   /* Computer plays choice item. */
  352. !     W_PROPS, P_CHOICE,
  353. !     BBORDER + (0*(BWIDTH+BGAP)), BBORDER + (0*(BHEIGHT+BGAP)),
  354. !     "Computer plays:",
  355. !     BBORDER + (2*(BWIDTH+BGAP)), BBORDER + (0*(BHEIGHT+BGAP)),
  356. !     0, 0, "", 0,
  357. !     (char **) comp_plays, 4,
  358. !     set_option
  359. !   },
  360.   
  361. !   {                                   /* Difficulty choice item. */
  362. !     W_PROPS, P_CHOICE,
  363. !     BBORDER + (0*(BWIDTH+BGAP)), BBORDER + (1*(BHEIGHT+BGAP)),
  364. !     "Difficulty:",
  365. !     BBORDER + (2*(BWIDTH+BGAP)), BBORDER + (1*(BHEIGHT+BGAP)),
  366. !     0, 0, "", 0,
  367. !     (char **) diff_values, 9,
  368. !     set_option
  369. !   },
  370.   
  371. !   {                                   /* Set search depth cycle item. */
  372. !     W_PROPS, P_CYCLE,
  373. !     BBORDER + (0*(BWIDTH+BGAP)), BBORDER + (2*(BHEIGHT+BGAP)),
  374. !     "Set search depth:",
  375. !     BBORDER + (2*(BWIDTH+BGAP)), BBORDER + (2*(BHEIGHT+BGAP)),
  376. !     0, 0, "", INIT_DEPTH,
  377. !     (char **) NULL, 0,
  378. !     set_option
  379. !   },
  380.   
  381. !   {                                   /* Options (Animate Move) item. */
  382. !     W_PROPS, P_TOGGLE,
  383. !     BBORDER + (0*(BWIDTH+BGAP)), BBORDER + (3*(BHEIGHT+BGAP)),
  384. !     "Options:",
  385. !     BBORDER + (2*(BWIDTH+BGAP)), BBORDER + (3*(BHEIGHT+BGAP)),
  386. !     TICKWIDTH, TICKHEIGHT, "Animate Move", 0,
  387. !     (char **) NULL, 0,
  388. !     set_option
  389. !   },
  390.   
  391. !   {                              /* Options (Show Current Best Move) item. */
  392. !     W_PROPS, P_TOGGLE, 0, 0,
  393. !     "",
  394. !     BBORDER + (2*(BWIDTH+BGAP)), BBORDER + (4*(BHEIGHT+BGAP)),
  395. !     TICKWIDTH, TICKHEIGHT, "Show Current Best Move", 0,
  396. !     (char **) NULL, 0,
  397. !     set_option
  398. !   },
  399.   
  400. !   {                                   /* Options (Show Last Move) item. */
  401. !     W_PROPS, P_TOGGLE, 0, 0,
  402. !     "",
  403. !     BBORDER + (2*(BWIDTH+BGAP)), BBORDER + (5*(BHEIGHT+BGAP)),
  404. !     TICKWIDTH, TICKHEIGHT, "Show Last Move", 0,
  405. !     (char **) NULL, 0,
  406. !     set_option
  407. !   },
  408.   
  409. !   {                              /* Options (Show Evaluation Info.) item. */
  410. !     W_PROPS, P_TOGGLE, 0, 0,
  411. !     "",
  412. !     BBORDER + (2*(BWIDTH+BGAP)), BBORDER + (6*(BHEIGHT+BGAP)),
  413. !     TICKWIDTH, TICKHEIGHT, "Show Evaluation Info.", 0,
  414. !     (char **) NULL, 0,
  415. !     set_option
  416. !   },
  417. ! 
  418. !   {                                   /* Options (Number Last Move) item. */
  419. !     W_PROPS, P_TOGGLE, 0, 0,
  420. !     "",
  421. !     BBORDER + (2*(BWIDTH+BGAP)), BBORDER + (7*(BHEIGHT+BGAP)),
  422. !     TICKWIDTH, TICKHEIGHT, "Number Last Move", 0,
  423. !     (char **) NULL, 0,
  424. !     set_option
  425. !   },
  426. ! 
  427. !   {                                   /* Options (Don't Show Flip) item. */
  428. !     W_PROPS, P_TOGGLE, 0, 0,
  429. !     "",
  430. !     BBORDER + (2*(BWIDTH+BGAP)), BBORDER + (8*(BHEIGHT+BGAP)),
  431. !     TICKWIDTH, TICKHEIGHT, "Don't Show Flip", 0,
  432. !     (char **) NULL, 0,
  433. !     set_option
  434. !   },
  435.   } ;
  436.   
  437.   char geometry[MAXDPY][MAXLINE] ;       /* X11 geometry information. */
  438. ***************
  439. *** 197,202 ****
  440. --- 387,393 ----
  441.   int damier[NIVEAUMAX][64] ;  /* Boards at different depth level */
  442.   int tacouleur, macouleur ;   /* Your and my colors during evaluation */
  443.   int mnb, profmax ;           /* Number of moves played, current max. depth */
  444. + int max_depth = 2 ;          /* Computer strategy - maximum depth. */
  445.   int vp0, vo0 ;               /* Current mobility components */
  446.   long c1, c2, c3 ;            /* Constants used in evaluation function */
  447.   long edges[6561] ;           /* Edges Stability Table */
  448. ***************
  449. *** 213,221 ****
  450. --- 404,419 ----
  451.     STRCPY(progname, argv[0]) ;   /* Save program name for later use. */
  452.     STRCPY(gamefile, "reve.game") ;
  453.     SPRINTF(line, " Reve.  V1.1.%1d", PATCHLEVEL) ;
  454. +   init_graphics(&argc, argv) ;
  455.     initialise() ;                /* Initialise variables used by reve. */
  456. +   load_resources() ;            /* Get resources from various places. */
  457. +   read_resources() ;            /* Read resources from merged database. */
  458.     get_options(argc, argv) ;     /* Read command line options. */
  459. + 
  460. + #ifndef XVIEW
  461.     init_edge_table(edgefile) ;   /* Load reve edge table values. */
  462. + #endif /*XVIEW*/
  463. + 
  464.     set_display_types() ;         /* Work out what displays to initialise. */
  465.     if (init_ws_type())           /* Determine window system type. */
  466.       {
  467. ***************
  468. *** 231,236 ****
  469. --- 429,448 ----
  470.   
  471.   
  472.   void
  473. + do_computer_move(player)
  474. + int player ;
  475. + {
  476. +   set_cursor(CANVASCUR) ;
  477. +   if (ANIMATION == TRUE) animate_move(move) ;
  478. +   if (best_cmove != -1 && DO_BESTMOVE == TRUE)
  479. +     draw_square(best_cmove, IS_OFF, 2) ;
  480. +   do_move(player) ;
  481. +   last_move = move ;
  482. +   cmode = (enum cantype) (OPPONENT(player) + 1) ;
  483. + }
  484. + 
  485. + 
  486. + void
  487.   generate_graphics(argc, argv, dpyno)
  488.   enum dpy_type dpyno ;
  489.   int argc ;
  490. ***************
  491. *** 241,255 ****
  492.     make_frame(argc, argv) ;      /* Create reve window/icon. */
  493.     make_canvas() ;               /* Create drawing canvas. */
  494.     init_fonts() ;                /* Load normal and bold fonts. */
  495. -   create_menu(BLACK_PLAYS, player_values) ;
  496. -   create_menu(WHITE_PLAYS, player_values) ;
  497. -   create_menu(DIFFICULTY,  diff_values) ;
  498. -   create_menu(NOTES,       notes_values) ;
  499.     initboard() ;
  500.     set_cursor(CANVASCUR) ;
  501.   }
  502.   
  503.   
  504.   void
  505.   get_options(argc, argv)   /* Read and process command line options. */
  506.   int argc ;
  507. --- 453,492 ----
  508.     make_frame(argc, argv) ;      /* Create reve window/icon. */
  509.     make_canvas() ;               /* Create drawing canvas. */
  510.     init_fonts() ;                /* Load normal and bold fonts. */
  511.     initboard() ;
  512.     set_cursor(CANVASCUR) ;
  513.   }
  514.   
  515.   
  516. + get_bool_resource(rtype, boolval)   /* Get boolean resource from the server. */
  517. + enum res_type rtype ;
  518. + int *boolval ;
  519. + {
  520. +   char *val, tempstr[MAXLINE] ;
  521. +   int n ;
  522. + 
  523. +   if ((val = get_resource(rtype)) == NULL) return(0) ;
  524. +   STRCPY(tempstr, val) ;
  525. +   for (n = 0; n < strlen(tempstr); n++)
  526. +     if (isupper(tempstr[n])) tempstr[n] = tolower(tempstr[n]) ;
  527. +   if (EQUAL(tempstr, "true")) *boolval = TRUE ;
  528. +   else                        *boolval = FALSE ;
  529. +   return(1) ;
  530. + }
  531. + 
  532. + 
  533. + get_int_resource(rtype, intval)   /* Get integer resource from the server. */
  534. + enum res_type rtype ;
  535. + int *intval ;
  536. + {
  537. +   char *val ;
  538. + 
  539. +   if ((val = get_resource(rtype)) == NULL) return(0) ;
  540. +   *intval = atoi(val) ;
  541. +   return(1) ;
  542. + }
  543. + 
  544. + 
  545.   void
  546.   get_options(argc, argv)   /* Read and process command line options. */
  547.   int argc ;
  548. ***************
  549. *** 265,273 ****
  550.           switch (argv[0][1])
  551.             {
  552.               case 'a' : /* Allow computer glide and piece dragging. */
  553. !                        if (EQUAL(argv[0], "-animate")) animation = TRUE ;
  554.                          break ;
  555. !             case 'b' : if (EQUAL(argv[0], "-bestmove")) do_bestmove = TRUE ;
  556.                          else if (EQUAL(argv[0], "-black"))
  557.                            {
  558.                              isblack = 1 ;
  559. --- 502,510 ----
  560.           switch (argv[0][1])
  561.             {
  562.               case 'a' : /* Allow computer glide and piece dragging. */
  563. !                        if (EQUAL(argv[0], "-animate")) ANIMATION = TRUE ;
  564.                          break ;
  565. !             case 'b' : if (EQUAL(argv[0], "-bestmove")) DO_BESTMOVE = TRUE ;
  566.                          else if (EQUAL(argv[0], "-black"))
  567.                            {
  568.                              isblack = 1 ;
  569. ***************
  570. *** 284,290 ****
  571.                          getparam(next, argv, "-d needs difficulty") ;
  572.                          level = atoi(next) ;
  573.                          if (level < 1 || level > MAXDIFF) level = INIT_DEPTH ;
  574. !                        items[(int) DIFFICULTY].value = level - 1 ;
  575.                          break ;
  576.               case 'e' : INC ;
  577.                          getparam(edgefile, argv, "-e needs an edgetable file") ;
  578. --- 521,527 ----
  579.                          getparam(next, argv, "-d needs difficulty") ;
  580.                          level = atoi(next) ;
  581.                          if (level < 1 || level > MAXDIFF) level = INIT_DEPTH ;
  582. !                        items[(int) DIFF_CHOICE].value = level - 1 ;
  583.                          break ;
  584.               case 'e' : INC ;
  585.                          getparam(edgefile, argv, "-e needs an edgetable file") ;
  586. ***************
  587. *** 295,301 ****
  588.                          break ;
  589.               case 'i' : inv_video = 1 ;       /* Display in inverse video. */
  590.                          break ;
  591. !             case 'l' :      if (EQUAL(argv[0], "-last")) do_last = TRUE ;
  592.                          else if (EQUAL(argv[0], "-load"))
  593.                            {
  594.                              INC ;             /* Reve game file to load. */
  595. --- 532,539 ----
  596.                          break ;
  597.               case 'i' : inv_video = 1 ;       /* Display in inverse video. */
  598.                          break ;
  599. !             case 'l' :      if (EQUAL(argv[0], "-last")) DO_LAST = TRUE ;
  600. !                        else if (EQUAL(argv[0], "-log"))  saveres = TRUE ;
  601.                          else if (EQUAL(argv[0], "-load"))
  602.                            {
  603.                              INC ;             /* Reve game file to load. */
  604. ***************
  605. *** 306,322 ****
  606.               case 'm' : monochrome = 1 ;      /* Force display to mono. */
  607.                          for (i = 0; i < MAXDPY; i++) iscolor[i] = 0 ;
  608.                          break ;
  609. !             case 'n' : if (EQUAL(argv[0], "-notes"))
  610. !                          {
  611. !                            show_notes = TRUE ;
  612. !                            items[(int) NOTES].value = 1 ;
  613. !                          }
  614. !                        else if (EQUAL(argv[0], "-number")) do_number = TRUE ;
  615.                          break ;
  616. !             case 'q' : if (EQUAL(argv[0], "-quick")) quickgame = TRUE ;
  617.                          break ;
  618. -             case 'r' : saveres = 1 ;       /* Save computer results to file. */
  619. -                        break ;
  620.               case '?' :
  621.               case 'v' : usage() ;
  622.   
  623. --- 544,554 ----
  624.               case 'm' : monochrome = 1 ;      /* Force display to mono. */
  625.                          for (i = 0; i < MAXDPY; i++) iscolor[i] = 0 ;
  626.                          break ;
  627. !             case 'n' :      if (EQUAL(argv[0], "-notes")) SHOW_NOTES = TRUE ;
  628. !                        else if (EQUAL(argv[0], "-number")) DO_NUMBER = TRUE ;
  629.                          break ;
  630. !             case 'q' : if (EQUAL(argv[0], "-quick")) QUICKGAME = TRUE ;
  631.                          break ;
  632.               case '?' :
  633.               case 'v' : usage() ;
  634.   
  635. ***************
  636. *** 387,392 ****
  637. --- 619,636 ----
  638.   }
  639.   
  640.   
  641. + get_str_resource(rtype, strval)   /* Get a string resource from the server. */
  642. + enum res_type rtype ;
  643. + char *strval ;
  644. + {
  645. +   char *val ;
  646. + 
  647. +   if ((val = get_resource(rtype)) == NULL) return(0) ;
  648. +   STRCPY(strval, val) ;
  649. +   return(1) ;
  650. + }
  651. + 
  652. + 
  653.   void
  654.   getparam(s, argv, errmes)
  655.   char *s, *argv[], *errmes ;
  656. ***************
  657. *** 407,418 ****
  658.     int adjust, d, i, n, x, y ;
  659.    
  660.     d = (int) cur_dpyno ;
  661. !   color_area(0, 0, TOTAL_WIDTH, TOTAL_HEIGHT, C_WHITE) ;
  662.     if (iscolor[d])
  663.       {
  664. !       color_area(0, 0, TOTAL_WIDTH, CY, C_BEIGE) ;
  665. !       color_area(0, CY, TOTAL_WIDTH, TOTAL_WIDTH, C_DBROWN) ;
  666. !       color_area(0 + BBORDER, CY + BBORDER, BOARD_SIZE * CELL_SIZE,
  667.                    BOARD_SIZE * CELL_SIZE, C_LBROWN) ;
  668.       }
  669.     make_panel() ;                /* Create panel and panel items. */
  670. --- 651,662 ----
  671.     int adjust, d, i, n, x, y ;
  672.    
  673.     d = (int) cur_dpyno ;
  674. !   color_area(W_MAIN, 0, 0, TOTAL_WIDTH, TOTAL_HEIGHT, C_WHITE) ;
  675.     if (iscolor[d])
  676.       {
  677. !       color_area(W_MAIN, 0, 0, TOTAL_WIDTH, CY, C_BEIGE) ;
  678. !       color_area(W_MAIN, 0, CY, TOTAL_WIDTH, TOTAL_WIDTH, C_DBROWN) ;
  679. !       color_area(W_MAIN, 0 + BBORDER, CY + BBORDER, BOARD_SIZE * CELL_SIZE,
  680.                    BOARD_SIZE * CELL_SIZE, C_LBROWN) ;
  681.       }
  682.     make_panel() ;                /* Create panel and panel items. */
  683. ***************
  684. *** 426,435 ****
  685.         if (n == 0 || n == BOARD_SIZE) color = C_BLACK ;
  686.         if (color == C_LGREY) adjust = 1 ;
  687.         else adjust = 0 ;
  688. !       draw_line((n*CELL_SIZE)+BBORDER, CY+BBORDER+adjust,   /* Vertical. */
  689. !                 (n*CELL_SIZE)+BBORDER,
  690.                    CY+BBORDER+(BOARD_SIZE*CELL_SIZE)-adjust, RSRC, color) ;
  691. !       draw_line(BBORDER+adjust, CY+BBORDER+(n*CELL_SIZE),   /* Horizontal. */
  692.                   BBORDER+(BOARD_SIZE*CELL_SIZE)-adjust,
  693.                   CY+BBORDER+(n*CELL_SIZE), RSRC, color) ;
  694.       }
  695. --- 670,680 ----
  696.         if (n == 0 || n == BOARD_SIZE) color = C_BLACK ;
  697.         if (color == C_LGREY) adjust = 1 ;
  698.         else adjust = 0 ;
  699. !       draw_line(W_MAIN, (n*CELL_SIZE)+BBORDER,              /* Vertical. */
  700. !                 CY+BBORDER+adjust, (n*CELL_SIZE)+BBORDER,
  701.                    CY+BBORDER+(BOARD_SIZE*CELL_SIZE)-adjust, RSRC, color) ;
  702. !       draw_line(W_MAIN, BBORDER+adjust,                     /* Horizontal. */
  703. !                 CY+BBORDER+(n*CELL_SIZE),
  704.                   BBORDER+(BOARD_SIZE*CELL_SIZE)-adjust,
  705.                   CY+BBORDER+(n*CELL_SIZE), RSRC, color) ;
  706.       }
  707. ***************
  708. *** 439,460 ****
  709.       {
  710.         color = (iscolor[d]) ? C_WHITE : C_BLACK ;
  711.         SPRINTF(s1, "%c", 'a' + i) ;
  712. !       draw_text(BBORDER + (i * CELL_SIZE) + (CELL_SIZE / 2) - 2,
  713.                   CY + BBORDER - 4, BFONT, color, s1) ;
  714. !       draw_text(BBORDER + (i * CELL_SIZE) + (CELL_SIZE / 2) - 2,
  715.                   CY + (2 * BBORDER) + (BOARD_SIZE * CELL_SIZE) - 4,
  716.                   BFONT, color, s1) ;
  717.         SPRINTF(sa, "%c", '1' + i) ;
  718. !       draw_text(BBORDER / 2 - 2, CY + BBORDER + (i * CELL_SIZE) +
  719.                   (CELL_SIZE / 2) + 2, BFONT, color, sa) ;
  720. !       draw_text(BBORDER + (BOARD_SIZE * CELL_SIZE) + (BBORDER / 2) - 2,
  721.                   CY + BBORDER + (i * CELL_SIZE) + (CELL_SIZE / 2) + 2,
  722.                   BFONT, color, sa) ;
  723.       }
  724.     batch(IS_OFF) ;
  725. -   show_last(last_move, IS_ON) ;
  726. -   show_number(last_move, IS_ON) ;
  727. -   show_suggestion() ;
  728.     batch(IS_ON) ;
  729.     FOR_BOARD(i)
  730.       if (board.square[i])
  731. --- 684,702 ----
  732.       {
  733.         color = (iscolor[d]) ? C_WHITE : C_BLACK ;
  734.         SPRINTF(s1, "%c", 'a' + i) ;
  735. !       draw_text(W_MAIN, BBORDER + (i * CELL_SIZE) + (CELL_SIZE / 2) - 2,
  736.                   CY + BBORDER - 4, BFONT, color, s1) ;
  737. !       draw_text(W_MAIN, BBORDER + (i * CELL_SIZE) + (CELL_SIZE / 2) - 2,
  738.                   CY + (2 * BBORDER) + (BOARD_SIZE * CELL_SIZE) - 4,
  739.                   BFONT, color, s1) ;
  740.         SPRINTF(sa, "%c", '1' + i) ;
  741. !       draw_text(W_MAIN, BBORDER / 2 - 2, CY + BBORDER + (i * CELL_SIZE) +
  742.                   (CELL_SIZE / 2) + 2, BFONT, color, sa) ;
  743. !       draw_text(W_MAIN, BBORDER + (BOARD_SIZE * CELL_SIZE) + (BBORDER / 2) - 2,
  744.                   CY + BBORDER + (i * CELL_SIZE) + (CELL_SIZE / 2) + 2,
  745.                   BFONT, color, sa) ;
  746.       }
  747.     batch(IS_OFF) ;
  748.     batch(IS_ON) ;
  749.     FOR_BOARD(i)
  750.       if (board.square[i])
  751. ***************
  752. *** 462,470 ****
  753.           get_xy(i, &x, &y) ;
  754.           draw_piece(board.square[i], x, CY+y, RSRC) ;
  755.         }
  756. !   batch(IS_OFF) ;
  757.     set_score() ;
  758.     message(TURN_MES, "Black to move.") ;
  759.   
  760.     if (loadgame)
  761.       {
  762. --- 704,715 ----
  763.           get_xy(i, &x, &y) ;
  764.           draw_piece(board.square[i], x, CY+y, RSRC) ;
  765.         }
  766. !   if (DO_LAST) show_last(last_move, IS_ON) ;
  767. !   if (DO_NUMBER) show_number(last_move, 60 - board.moves_left, IS_ON) ;
  768. !   show_suggestion() ;
  769.     set_score() ;
  770.     message(TURN_MES, "Black to move.") ;
  771. +   batch(IS_OFF) ;
  772.   
  773.     if (loadgame)
  774.       {
  775. ***************
  776. *** 490,510 ****
  777.     last_move     = -1 ;
  778.     last_outline  = -1 ;
  779.     next_player   = BLACK ;
  780. !   animation     = FALSE ;
  781.     best_cmove    = -1 ;
  782.     but_inverted  = -1 ;
  783. !   do_bestmove   = FALSE ;
  784. !   do_last       = FALSE ;
  785. !   do_number     = FALSE ;
  786. !   quickgame     = FALSE ;
  787.     validkey      = 0 ;
  788.     cmode         = BLACK_START ;
  789.     show_moves    = FALSE ;
  790. !   show_notes    = FALSE ;
  791.     isblack       = 0 ;
  792.     iswhite       = 0 ;
  793.     level         = INIT_DEPTH ;
  794. !   items[(int) DIFFICULTY].value = level - 1 ;
  795.   
  796.     black_dpy = NULL ;              /* X11 black piece display information. */
  797.     white_dpy = NULL ;              /* X11 white piece display information. */
  798. --- 735,757 ----
  799.     last_move     = -1 ;
  800.     last_outline  = -1 ;
  801.     next_player   = BLACK ;
  802. !   ANIMATION     = FALSE ;
  803.     best_cmove    = -1 ;
  804.     but_inverted  = -1 ;
  805. !   DO_BESTMOVE   = FALSE ;
  806. !   DO_LAST       = FALSE ;
  807. !   DO_NUMBER     = FALSE ;
  808. !   processing    = FALSE ;             /* No computer move initially. */
  809. !   props_showing = FALSE ;
  810. !   QUICKGAME     = FALSE ;
  811.     validkey      = 0 ;
  812.     cmode         = BLACK_START ;
  813.     show_moves    = FALSE ;
  814. !   SHOW_NOTES    = FALSE ;
  815.     isblack       = 0 ;
  816.     iswhite       = 0 ;
  817.     level         = INIT_DEPTH ;
  818. !   items[(int) DIFF_CHOICE].value = level - 1 ;
  819.   
  820.     black_dpy = NULL ;              /* X11 black piece display information. */
  821.     white_dpy = NULL ;              /* X11 white piece display information. */
  822. ***************
  823. *** 515,572 ****
  824.   
  825.   
  826.   void
  827. ! init_edge_table(edgefile)     /* Load reve edge table values. */
  828. ! char *edgefile ;
  829.   {
  830. !   char buf[MAXLINE], *getenv(), name[MAXLINE], *paths, *ptr ;
  831. !   int i, line ;
  832. !   FILE *fp = NULL ;
  833.   
  834. !   i = 0 ;
  835. !   if ((fp = fopen(edgefile, "r")) == NULL)
  836. !     {
  837. !       paths = getenv("PATH") ;
  838. !       if ((ptr = paths) && edgefile[0] != '/')
  839. !         for (;;)
  840. !           if (*ptr == ':' || *ptr == 0)
  841. !             {
  842. !               if (*ptr == 0) break ;
  843. !               name[i++] = '/' ;
  844. !               name[i] = 0 ;
  845. !               STRCAT(name, edgefile) ;
  846. !               if ((fp = fopen(name, "r")) != NULL) break ;
  847. !               if (*ptr == '\0') break ;
  848. !               ptr++ ;
  849. !               i = 0 ;
  850. !             }
  851. !           else name[i++] = *ptr++ ;
  852. !     }
  853.   
  854. !   if (fp == NULL)
  855.       {
  856. !       FPRINTF(stderr, "Cannot open Edge Stability Table file\n") ;
  857. !       exit(1) ;
  858.       }
  859. !   line = 0 ;
  860. !   while (fgets(buf, MAXLINE, fp) != NULL)
  861. !     {
  862. !       line++ ;
  863. !       if (buf[0] == '\n' || buf[0] == '#') continue ;
  864. !       if ((ptr = index(buf, '[')) == NULL)
  865. !         {
  866. !           FPRINTF(stderr, "Cannot read edge table file at line %d\n", line) ;
  867. !           exit(1) ;
  868. !         }
  869. !       SSCANF(ptr+1, "%d", &i) ;
  870. !       if ((ptr = index(buf, '=')) == NULL)
  871. !         {
  872. !           FPRINTF(stderr, "Cannot read edge table file at line %d\n", line) ;
  873. !           exit(1) ;
  874. !         }
  875. !       SSCANF(ptr+1, "%ld", &edges[i]) ;
  876. !     }
  877. !   FCLOSE(fp) ;
  878. !   for (i = 0 ; i < 3281; i++) edges[6560 - i] = - edges[i] ;
  879.   }
  880.   
  881.   
  882. --- 762,786 ----
  883.   
  884.   
  885.   void
  886. ! read_resources()            /* Read all possible resources from database. */
  887.   {
  888. !   int boolval, intval ;
  889.   
  890. !   if (get_bool_resource(R_ANIMATE,  &boolval)) ANIMATION   = boolval ;
  891. !   if (get_bool_resource(R_BESTMOVE, &boolval)) DO_BESTMOVE = boolval ;
  892.   
  893. !   if (get_int_resource(R_DIFFICULTY, &intval))
  894.       {
  895. !       level = intval ;
  896. !       if (level < 1 || level > MAXDIFF) level = INIT_DEPTH ;
  897. !       items[(int) DIFF_CHOICE].value = level - 1 ;
  898.       }
  899. ! 
  900. !   if (get_bool_resource(R_LAST,   &boolval)) DO_LAST = boolval ;
  901. !   if (get_bool_resource(R_LOG,    &boolval)) saveres = boolval ;
  902. !   if (get_bool_resource(R_NOTES,  &boolval)) SHOW_NOTES = boolval ;
  903. !   if (get_bool_resource(R_NUMBER, &boolval)) DO_NUMBER = boolval ;
  904. !   if (get_bool_resource(R_QUICK,  &boolval)) QUICKGAME = boolval ;
  905.   }
  906.   
  907.   
  908. ***************
  909. *** 593,598 ****
  910. --- 807,814 ----
  911.   void
  912.   set_display_types()
  913.   {
  914. +   int val ;
  915. + 
  916.          if (isblack && iswhite) play_computer = 0 ;
  917.          if (isblack && iswhite) dtype = XBOTH ;
  918.     else if (isblack)            dtype = XBLACK ;
  919. ***************
  920. *** 625,632 ****
  921.          if (dtype == XBLACK)                 isblack = 1 ;
  922.     else if (dtype == XWHITE)                 iswhite = first_move = 1 ;
  923.     else if (dtype == XTWO || dtype == XBOTH) isblack = iswhite    = 1 ;
  924. !   items[(int) BLACK_PLAYS].value = (isblack == 0) ;
  925. !   items[(int) WHITE_PLAYS].value = (iswhite == 0) ;
  926.   }
  927.   
  928.   
  929. --- 841,854 ----
  930.          if (dtype == XBLACK)                 isblack = 1 ;
  931.     else if (dtype == XWHITE)                 iswhite = first_move = 1 ;
  932.     else if (dtype == XTWO || dtype == XBOTH) isblack = iswhite    = 1 ;
  933. ! 
  934. !   val = (isblack == 0) ;
  935. !   items[(int) BLACK_PLAYS].value = val ;
  936. !   STRCPY(items[(int) BLACK_PLAYS].text, player_values[val]) ;
  937. ! 
  938. !   val = (iswhite == 0) ;
  939. !   items[(int) WHITE_PLAYS].value = val ;
  940. !   STRCPY(items[(int) WHITE_PLAYS].text, player_values[val]) ;
  941.   }
  942.   
  943.   
  944. ***************
  945. *** 638,651 ****
  946.     move = TRUE ;            /* Make sure the computer clock is decremented. */
  947.     best_cmove = -1 ;
  948.     message(EVAL_MES, "") ;
  949.     play_reve(board.square, player, level, &move, ¬e) ;
  950. !   set_cursor(CANVASCUR) ;
  951. !   if (animation == TRUE) animate_move(move) ;
  952. !   if (best_cmove != -1 && do_bestmove == TRUE)
  953. !     draw_square(best_cmove, IS_OFF, 2) ;
  954. !   do_move(player) ;
  955. !   last_move = move ;
  956. !   cmode = (enum cantype) (OPPONENT(player) + 1) ;
  957.   }
  958.   
  959.   
  960. --- 860,871 ----
  961.     move = TRUE ;            /* Make sure the computer clock is decremented. */
  962.     best_cmove = -1 ;
  963.     message(EVAL_MES, "") ;
  964. + #ifdef XVIEW
  965. +   write_to_reve(M_MOVE, board.square, player, level, &move, ¬e) ;
  966. + #else
  967.     play_reve(board.square, player, level, &move, ¬e) ;
  968. !   do_computer_move(player) ;
  969. ! #endif /*XVIEW*/
  970.   }
  971.   
  972.   
  973.  
  974. ------- procs.c -------
  975. *** /tmp/da07597    Sun Dec  9 15:14:39 1990
  976. --- procs.c    Sat Dec  8 19:41:37 1990
  977. ***************
  978. *** 29,37 ****
  979.   
  980.   
  981.   void
  982. ! difficulty()
  983.   {
  984. !   level = next_setting(DIFFICULTY, diff_values) + 1 ;
  985.   }
  986.   
  987.   
  988. --- 29,39 ----
  989.   
  990.   
  991.   void
  992. ! do_props()
  993.   {
  994. !   props_showing = !props_showing ;
  995. !   if (props_showing == TRUE) open_frame(W_PROPS) ;
  996. !   else                       close_frame(W_PROPS) ;
  997.   }
  998.   
  999.   
  1000. ***************
  1001. *** 48,60 ****
  1002.     if (state == LEFT_DOWN)
  1003.       {
  1004.         draw_outline(cy * BOARD_SIZE + cx, IS_ON) ;
  1005. !       if (animation == TRUE)
  1006.           draw_piece(next_player, piece_x, piece_y, RINV) ;
  1007.         cmode = (enum cantype) ((int) cmode - 1) ;
  1008.       }
  1009.     else
  1010.       {
  1011. !       if (animation == TRUE)
  1012.           draw_piece(next_player, piece_x, piece_y, RINV) ;
  1013.         draw_outline(last_outline, IS_OFF) ;
  1014.         move = cy * BOARD_SIZE + cx ;
  1015. --- 50,62 ----
  1016.     if (state == LEFT_DOWN)
  1017.       {
  1018.         draw_outline(cy * BOARD_SIZE + cx, IS_ON) ;
  1019. !       if (ANIMATION == TRUE)
  1020.           draw_piece(next_player, piece_x, piece_y, RINV) ;
  1021.         cmode = (enum cantype) ((int) cmode - 1) ;
  1022.       }
  1023.     else
  1024.       {
  1025. !       if (ANIMATION == TRUE)
  1026.           draw_piece(next_player, piece_x, piece_y, RINV) ;
  1027.         draw_outline(last_outline, IS_OFF) ;
  1028.         move = cy * BOARD_SIZE + cx ;
  1029. ***************
  1030. *** 64,126 ****
  1031.   
  1032.   
  1033.   void
  1034. ! done()
  1035.   {
  1036. !   iconic = 1 ;
  1037. !   close_frame() ;
  1038. ! }
  1039.   
  1040. ! 
  1041. ! void
  1042. ! init_notes()
  1043. ! {
  1044. !   show_notes = next_setting(NOTES, notes_values) ;
  1045. !   if (show_notes == FALSE) message(EVAL_MES, "") ;
  1046. ! }
  1047. ! 
  1048. ! 
  1049. ! void
  1050. ! init_player()
  1051. ! {
  1052. !   enum panel_type item, other ;
  1053. !   int curi, curo ;
  1054. ! 
  1055. ! /*  XXX: Currently computer vs computer is not implemented, because of the
  1056. !  *       inability to break out of it, once started, with some of the
  1057. !  *       graphics versions. If the user has asked for this, then force it
  1058. !  *       to toggle the other player, so this situation can't happen.
  1059. !  */
  1060. ! 
  1061. !   if (curx < (BBORDER + (3*(BWIDTH+BGAP))))
  1062.       {
  1063. !       item = BLACK_PLAYS ;
  1064. !       other = WHITE_PLAYS ;
  1065.       }
  1066. -   else
  1067. -     {
  1068. -       item = WHITE_PLAYS ;
  1069. -       other = BLACK_PLAYS ;
  1070. -     }
  1071. -   curo = items[(int) other].value ;
  1072. -   curi = next_setting(item, player_values) ;
  1073. -   if (curi == COMPUTER && curo == COMPUTER)
  1074. -     {
  1075. -       curi = HUMAN ;
  1076. -       set_cycle(item, player_values[curi]) ;
  1077. -       items[(int) item].value = curi ;
  1078. -       message(PANEL_MES, "Computer can't play both players.") ;
  1079. -     }
  1080. -   if (curi == HUMAN    && curo == COMPUTER)
  1081. -     dtype = (item == BLACK_PLAYS) ? XBLACK : XWHITE ;
  1082. -   else if (curi == COMPUTER && curo == HUMAN)
  1083. -     dtype = (item == BLACK_PLAYS) ? XWHITE : XBLACK ;
  1084. -   else if (curi == HUMAN    && curo == HUMAN)
  1085. -     dtype = (dtype == XTWO) ? XTWO : XBOTH ; 
  1086.   
  1087. !   if (curi == COMPUTER)
  1088. !     if ((item == BLACK_PLAYS && cmode == BLACK_START) ||
  1089. !         (item == WHITE_PLAYS && cmode == WHITE_START))
  1090. !       computer_move(next_player) ;
  1091.   }
  1092.   
  1093.   
  1094. --- 66,95 ----
  1095.   
  1096.   
  1097.   void
  1098. ! do_suggest(player, suggestion, note, state)
  1099. ! int player, suggestion, note ;
  1100. ! enum bltype state ;
  1101.   {
  1102. !   set_cursor(CANVASCUR) ;
  1103.   
  1104. !   if (suggestion == -1) return ;
  1105. !   if (best_cmove != -1 && DO_BESTMOVE == TRUE)
  1106.       {
  1107. !       draw_square(best_cmove, IS_OFF, 2) ;
  1108. !       if (DO_NUMBER) show_number(best_cmove, cmove_depth, IS_OFF) ;
  1109.       }
  1110.   
  1111. !   suggest_x = BBORDER + ((suggestion & 7)  + 1) * CELL_SIZE - CELL_SIZE / 2 ;
  1112. !   suggest_y = BBORDER + ((suggestion >> 3) + 1) * CELL_SIZE - CELL_SIZE / 2 ;
  1113. !   if (state == IS_OFF)
  1114. !     color = (iscolor[(int) cur_dpyno]) ? C_LBROWN : C_WHITE ;
  1115. !   else color = C_BLACK ;
  1116. ! 
  1117. !   draw_line(W_MAIN, suggest_x-5, CY+suggest_y-5,
  1118. !                     suggest_x+5, CY+suggest_y+5, RSRC, color) ;
  1119. !   draw_line(W_MAIN, suggest_x-5, CY+suggest_y+5,
  1120. !                     suggest_x+5, CY+suggest_y-5, RSRC, color) ;
  1121. !   if (SHOW_NOTES && state == IS_ON) set_eval(player, suggestion, note) ;
  1122.   }
  1123.   
  1124.   
  1125. ***************
  1126. *** 160,199 ****
  1127.     init_canvas() ;
  1128.     message(EVAL_MES, "") ;
  1129.     message(PANEL_MES, "Use left mouse button to move") ;
  1130. !   draw_button(NEW_GAME_BUT, C_LGREY, BUT_NORMAL) ;
  1131.   }
  1132.   
  1133.   
  1134. ! next_setting(item, choices)
  1135. ! enum panel_type item ;
  1136. ! char *choices[] ;
  1137.   {
  1138. !   switch (direction)
  1139.       {
  1140. !       case INCREMENT : if (choices[++item_value] != NULL)
  1141. !                          items[(int) item].value++ ;
  1142. !                        else items[(int) item].value = item_value = 0 ;
  1143. !                        break ;
  1144. !       case DECREMENT : if (--item_value == -1)
  1145. !                          {
  1146. !                            while (choices[++item_value] != NULL) continue ;
  1147. !                            item_value-- ;
  1148. !                            items[(int) item].value = item_value ;
  1149. !                          }
  1150. !                        else items[(int) item].value-- ;
  1151. !                        break ;
  1152. !       case NONE      : /* Handled elsewhere. */ ;
  1153.       }
  1154. !   set_cycle(item, choices[item_value]) ;
  1155. !   return(items[(int) item].value) ;
  1156.   }
  1157.   
  1158.   
  1159.   void
  1160. ! quit()
  1161.   {
  1162. !   destroy_frame() ;
  1163. !   exit(0) ;
  1164.   }
  1165.   
  1166.   
  1167. --- 129,258 ----
  1168.     init_canvas() ;
  1169.     message(EVAL_MES, "") ;
  1170.     message(PANEL_MES, "Use left mouse button to move") ;
  1171. !   draw_button(W_MAIN, NEW_GAME_BUT, C_LGREY, BUT_NORMAL) ;
  1172.   }
  1173.   
  1174.   
  1175. ! void
  1176. ! quit()
  1177.   {
  1178. !   destroy_frame() ;
  1179. !   exit(0) ;
  1180. ! }
  1181. ! 
  1182. ! 
  1183. ! void
  1184. ! set_computer(val)
  1185. ! int val ;
  1186. ! {
  1187. !   int color, curi ;
  1188. ! 
  1189. !   if (val == CP_WHITE)
  1190.       {
  1191. !       dtype = XBLACK ;
  1192. !       play_computer = TRUE ;
  1193. !       items[(int) BLACK_PLAYS].value = HUMAN ;
  1194. !       STRCPY(items[(int) BLACK_PLAYS].text, player_values[HUMAN]) ;
  1195. !       items[(int) WHITE_PLAYS].value = COMPUTER ;
  1196. !       STRCPY(items[(int) WHITE_PLAYS].text, player_values[COMPUTER]) ;
  1197.       }
  1198. !   else if (val == CP_BLACK)
  1199. !     {
  1200. !       dtype = XWHITE ;
  1201. !       play_computer = TRUE ;
  1202. !       items[(int) BLACK_PLAYS].value = COMPUTER ;
  1203. !       STRCPY(items[(int) BLACK_PLAYS].text, player_values[COMPUTER]) ;
  1204. !       items[(int) WHITE_PLAYS].value = HUMAN ;
  1205. !       STRCPY(items[(int) WHITE_PLAYS].text, player_values[HUMAN]) ;
  1206. !     }
  1207. !   else if (val == CP_NEITHER)
  1208. !     {
  1209. !       dtype = XTWO ;
  1210. !       play_computer = FALSE ;
  1211. !       items[(int) BLACK_PLAYS].value = HUMAN ;
  1212. !       STRCPY(items[(int) BLACK_PLAYS].text, player_values[HUMAN]) ;
  1213. !       items[(int) WHITE_PLAYS].value = HUMAN ;
  1214. !       STRCPY(items[(int) WHITE_PLAYS].text, player_values[HUMAN]) ; 
  1215. !     }
  1216. ! 
  1217. !   color = (iscolor[(int) cur_dpyno]) ? C_BEIGE : C_WHITE ;
  1218. !   draw_choice(W_PROPS, COMP_CHOICE, color) ;
  1219. ! 
  1220. !   val = items[(int) BLACK_PLAYS].value ;
  1221. !   val = items[(int) WHITE_PLAYS].value ;
  1222. ! 
  1223. !   if (next_player == BLACK) curi = items[(int) BLACK_PLAYS].value ;
  1224. !   else                      curi = items[(int) WHITE_PLAYS].value ;
  1225. !   if (curi == COMPUTER)
  1226. !     if ((next_player == BLACK && cmode == BLACK_START) ||
  1227. !         (next_player == WHITE && cmode == WHITE_START))
  1228. !       computer_move(next_player) ;
  1229.   }
  1230.   
  1231.   
  1232.   void
  1233. ! set_option()
  1234.   {
  1235. !   char str[4] ;
  1236. !   int color, d, maxw, n, val ;
  1237. ! 
  1238. !   d = (int) cur_dpyno ;
  1239. !   switch (itemno)
  1240. !     {
  1241. !       case COMP_CHOICE : maxw = items[itemno].width / items[itemno].nopts ;
  1242. !                          val = (curx - items[itemno].x) / maxw ;
  1243. !                          if (val != CP_BOTH)
  1244. !                            {
  1245. !                              items[itemno].value = val ;
  1246. !                              set_computer(val) ;
  1247. !                            }
  1248. !                          else message(PANEL_MES,
  1249. !                                "Computer plays both is not implemented yet.") ;
  1250. !                          break ;
  1251. ! 
  1252. !       case DIFF_CHOICE : maxw = items[itemno].width / items[itemno].nopts ;
  1253. !                          val = (curx - items[itemno].x) / maxw ;
  1254. !                          level = val + 1 ;
  1255. !                          items[itemno].value = val ;
  1256. !                          color = (iscolor[d]) ? C_BEIGE : C_WHITE ;
  1257. !                          draw_choice(W_PROPS, DIFF_CHOICE, color) ;
  1258. !                          break ;
  1259. ! 
  1260. !       case MAX_DEPTH   : val = items[itemno].value ;
  1261. !                          if (direction == INCREMENT && val < MAX_PROFMAX)
  1262. !                            items[itemno].value++ ;
  1263. !                          else if (direction == DECREMENT && val > INIT_DEPTH)
  1264. !                            items[itemno].value-- ;
  1265. !                          SPRINTF(str, "%d", items[itemno].value) ;
  1266. !                          color = (iscolor[d]) ? C_LGREY : C_WHITE ;
  1267. !                          set_cycle(W_PROPS, MAX_DEPTH, str) ;
  1268. !                          profmax = items[itemno].value ;
  1269. !                          level = 1 ;
  1270. !                          break ;
  1271. ! 
  1272. !       case OPT_ANIM    : ANIMATION   = !ANIMATION ;
  1273. !                          break ;
  1274. ! 
  1275. !       case OPT_BEST    : DO_BESTMOVE = !DO_BESTMOVE ;
  1276. !                          break ;
  1277. ! 
  1278. !       case OPT_LAST    : DO_LAST     = !DO_LAST ;
  1279. !                          n = 63 - board.moves_left ;
  1280. !                          show_last(moves[n].move, DO_LAST) ;
  1281. !                          break ;
  1282. ! 
  1283. !       case OPT_EVAL    : SHOW_NOTES  = !SHOW_NOTES ;
  1284. !                          if (!SHOW_NOTES) message(EVAL_MES, "") ;
  1285. !                          break ;
  1286. ! 
  1287. !       case OPT_NUM     : DO_NUMBER   = !DO_NUMBER ;
  1288. !                          n = 63 - board.moves_left ;
  1289. !                          show_number(moves[n].move, 60 - board.moves_left,
  1290. !                                      DO_NUMBER, DO_NUMBER) ;
  1291. !                          break ;
  1292. ! 
  1293. !       case OPT_FLIP    : QUICKGAME   = !QUICKGAME ;
  1294. !     }
  1295.   }
  1296.   
  1297.   
  1298. ***************
  1299. *** 212,229 ****
  1300.     long note ;
  1301.   
  1302.     if (cmode == GAME_OVER) return ;
  1303.     if (cmode == WHITE_START) player = WHITE ;
  1304.     else                      player = BLACK ;
  1305.     suggestion = FALSE ;   /* Make sure the computer clock isn't decremented. */
  1306.     play_reve(&board.square[0], player, level, &suggestion, ¬e) ;
  1307. ! 
  1308. !   suggest_x = BBORDER + ((suggestion & 7)  + 1) * CELL_SIZE - CELL_SIZE / 2 ;
  1309. !   suggest_y = BBORDER + ((suggestion >> 3) + 1) * CELL_SIZE - CELL_SIZE / 2 ;
  1310. !   draw_line(suggest_x-5, CY+suggest_y-5,
  1311. !             suggest_x+5, CY+suggest_y+5, RSRC, C_BLACK) ;
  1312. !   draw_line(suggest_x-5, CY+suggest_y+5,
  1313. !             suggest_x+5, CY+suggest_y-5, RSRC, C_BLACK) ;
  1314. !   if (show_notes) set_eval(player, suggestion, note) ;
  1315.   }
  1316.   
  1317.   
  1318. --- 271,286 ----
  1319.     long note ;
  1320.   
  1321.     if (cmode == GAME_OVER) return ;
  1322. +   set_cursor(HOURGLASS) ;
  1323.     if (cmode == WHITE_START) player = WHITE ;
  1324.     else                      player = BLACK ;
  1325.     suggestion = FALSE ;   /* Make sure the computer clock isn't decremented. */
  1326. + #ifdef XVIEW
  1327. +   write_to_reve(M_SUGGESTION, board.square, player, level, &move, ¬e) ;
  1328. + #else
  1329.     play_reve(&board.square[0], player, level, &suggestion, ¬e) ;
  1330. !   do_suggest(player, suggestion, note, IS_ON) ;
  1331. ! #endif /*XVIEW*/
  1332.   }
  1333.   
  1334.   
  1335. ***************
  1336. *** 252,266 ****
  1337.   undo_move(player)
  1338.   int player ;
  1339.   {
  1340. !   int i, n, x, y ;
  1341.   
  1342. !   n = 62 - board.moves_left ;
  1343. !   while (moves[n-1].player == player) n-- ;
  1344.   
  1345. !   if (n >= 3)
  1346.       {
  1347. !       show_last(last_move, IS_OFF) ;
  1348. !       show_number(last_move, IS_OFF) ;
  1349.         FOR_BOARD(i)
  1350.           {
  1351.             if (moves[n].square[i] != board.square[i])
  1352. --- 309,325 ----
  1353.   undo_move(player)
  1354.   int player ;
  1355.   {
  1356. !   int i, limit, n, x, y ;
  1357.   
  1358. !   n = 63 - board.moves_left ;
  1359. !   while (moves[n].player != player) n-- ;
  1360.   
  1361. !   limit = (items[(int) BLACK_PLAYS].value == COMPUTER) ? 4 : 3 ;
  1362. !   if (n >= limit)
  1363.       {
  1364. !       if (DO_LAST) show_last(last_move, IS_OFF) ;
  1365. !       if (DO_NUMBER) show_number(last_move, 60 - board.moves_left, IS_OFF) ;
  1366. !       do_suggest(player, suggestion, note, IS_OFF) ;
  1367.         FOR_BOARD(i)
  1368.           {
  1369.             if (moves[n].square[i] != board.square[i])
  1370. ***************
  1371. *** 267,273 ****
  1372.               {
  1373.                 get_xy(i, &x, &y) ;
  1374.                 if (moves[n].square[i] == FREE)
  1375. !                 color_area(x, CY+y, PSIZE, PSIZE,
  1376.                              (iscolor[(int) cur_dpyno]) ? C_LBROWN : C_WHITE) ;
  1377.                 else draw_piece(moves[n].square[i], x, CY+y, RSRC) ;
  1378.               }
  1379. --- 326,332 ----
  1380.               {
  1381.                 get_xy(i, &x, &y) ;
  1382.                 if (moves[n].square[i] == FREE)
  1383. !                 color_area(W_MAIN, x, CY+y, PSIZE, PSIZE,
  1384.                              (iscolor[(int) cur_dpyno]) ? C_LBROWN : C_WHITE) ;
  1385.                 else draw_piece(moves[n].square[i], x, CY+y, RSRC) ;
  1386.               }
  1387. ***************
  1388. *** 290,295 ****
  1389. --- 349,358 ----
  1390.   
  1391.         timeleft = board.timeleft ;
  1392.   
  1393. + #ifdef XVIEW
  1394. +       reset_time(timeleft) ;
  1395. + #endif /*XVIEW*/
  1396. + 
  1397.         if (OPPONENT(player) == BLACK) cmode = BLACK_START ;
  1398.         else                           cmode = WHITE_START ;
  1399.         message(PANEL_MES, "") ;
  1400. ***************
  1401. *** 296,304 ****
  1402.   
  1403.         if (n > 3)
  1404.           {
  1405. !           show_last(last_move, IS_ON) ;
  1406. !           show_number(last_move, IS_ON) ;
  1407. !           if (show_notes) set_eval(board.player, board.move, board.note) ;
  1408.           }
  1409.         else message(EVAL_MES, "") ;
  1410.         next_player = OPPONENT(board.player) ;
  1411. --- 359,367 ----
  1412.   
  1413.         if (n > 3)
  1414.           {
  1415. !           if (DO_LAST) show_last(last_move, IS_ON) ;
  1416. !           if (DO_NUMBER) show_number(last_move, 60 - board.moves_left, IS_ON) ;
  1417. !           if (SHOW_NOTES) set_eval(board.player, board.move, board.note) ;
  1418.           }
  1419.         else message(EVAL_MES, "") ;
  1420.         next_player = OPPONENT(board.player) ;
  1421.  
  1422.