home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 January / usenetsourcesnewsgroupsinfomagicjanuary1994.iso / sources / games / volume13 / okbridge / part05 / display.c next >
C/C++ Source or Header  |  1992-01-12  |  17KB  |  653 lines
  1. /* display.c -- Display functions for netbridge program.
  2.  ! 
  3.  ! Copyright (C) 1990,1991 by Matthew Clegg
  4.  ! 
  5.  ! This program may be copied and distributed freely.  Please do not
  6.  ! charge money for this program or for any program derived from it.
  7.  ! If you modify this program, then include a notice stating plainly
  8.  ! that your program is derived from the okbridge program and is not
  9.  ! the same as the official okbridge program.
  10.  !
  11.  ! I welcome any suggestions for improvement to okbridge, and 
  12.  ! I would be especially happy to receive improved source code.
  13.  ! If you have comments or suggestions, or if you would like to
  14.  ! join the okbridge mailing list, then write to
  15.  !
  16.  !   mclegg@cs.ucsd.edu
  17.  !
  18. */
  19.  
  20. #include <stdio.h>
  21. #include <string.h>
  22.  
  23. #include "globals.h"
  24. #include "terminal.h"
  25.  
  26. typedef int window[4];
  27.  
  28. /* Conceptually, we think of the screen as being divided into a number
  29.    of windows, where each window describes one particular type of activity
  30.    or aspect of the game.  Therefore, we make the following definitions,
  31.    although these are only guidelines for operation of the display.
  32.  
  33. Name of
  34. Window               Ymin    Xmin    Height    Width
  35. -------             ----    ----    ----    ----            */
  36. window title          = { 1,    1,    6,    25};
  37. window top_hand      = { 2,    30,    4,    26};
  38. window scores         = { 1,    59,    6,    26};
  39. window left_hand     = { 8,    6,    6,    18};
  40. window playing_board = { 5,    27,    9,    26};
  41. window bidding_board = { 5,    1,    9,    58};
  42. window right_hand    = { 8,    56,    6,    23};
  43. window input         = { 13,    1,    6,    26};
  44. window status         = { 18,    1,    1,    78};
  45. window bottom_hand   = { 13,    30,    4,    26};
  46. window help         = { 13,    53,    6,    26};
  47. window converse         = { 19,    1,    6,    78};
  48.  
  49. #define XMIN(w)        w[1]
  50. #define YMIN(w)         w[0]
  51. #define XMAX(w)        (w[1] + w[3] - 1)
  52. #define YMAX(w)        (w[0] + w[2] - 1)
  53. #define HEIGHT(w)    w[2]
  54. #define WIDTH(w)    w[3]
  55.  
  56. static int PLAYERHAND_X [4];
  57. static int PLAYERHAND_Y [4]; 
  58. static int CARDPOS_X    [4];
  59. static int CARDPOS_Y    [4];
  60. static char *position_names [4];
  61. static int comments_suspended = 0;
  62.  
  63. static char line_buf [81];
  64. static char status_message_buf[81];
  65.  
  66. static underline (ymin, xmin, length)
  67.        int ymin, xmin, length;
  68. /* Prints a line of hyphens BELOW the field beginning at (ymin,xmin),
  69.  *  of given length.
  70.  */
  71. {
  72.     int i;
  73.  
  74.     for (i = 0; i < length; i++)
  75.         line_buf[i] = '-';
  76.     line_buf[length] = '\0';
  77.     print (ymin+1, xmin, line_buf);
  78. };
  79.  
  80. static clear_screen_area (ymin, xmin, height, width)
  81.        int ymin, xmin, height, width;
  82. {
  83.     int i;
  84.  
  85.     for (i = 0; i < width; i++) line_buf[i] = ' ';
  86.     line_buf[width] = '\0';
  87.     for (i = 0; i < height; i++) print (ymin+i, xmin, line_buf);
  88. };
  89.  
  90. Reset_Display ()
  91. /* Redraws the main features of the screen.  Used in the process
  92.  * of doing a 'refresh'.
  93.  */
  94. {
  95.     int i;
  96.     char program_name[20];
  97.  
  98.     sprintf (program_name, "OKBRIDGE %s%s", major_revision_level,
  99.          minor_revision_level);
  100.     clear_screen ();
  101.  
  102.     /* Display the title of the program: */
  103.     print (YMIN(title), XMIN(title),  program_name);
  104. /*    print (YMIN(title)+1, XMIN(title), "MTC    JUNE 90"); */
  105.  
  106.     /* Setup the scoreboard: */
  107.     if (side_of(local_player) == SIDE_NS) {
  108.       print (YMIN(scores), XMIN(scores) + 8,   "   WE");
  109.       print (YMIN(scores), XMIN(scores) + 16,  " THEY");
  110.     } else {
  111.       print (YMIN(scores), XMIN(scores) + 16,  "   WE");
  112.       print (YMIN(scores), XMIN(scores) + 8,   " THEY");
  113.     };
  114.     underline (YMIN(scores), XMIN(scores) + 8, 5);
  115.     underline (YMIN(scores), XMIN(scores) + 16, 5);
  116.     print (YMIN(scores)+2, XMIN(scores), "TRICKS");
  117.     print (YMIN(scores)+3, XMIN(scores), "VUL");
  118.  
  119.     switch (scoring_mode) {
  120.       case RUBBER_SCORING:
  121.           print (YMIN(scores)+4, XMIN(scores), "ABOVE");
  122.           print (YMIN(scores)+5, XMIN(scores), "BELOW");
  123.           print (YMIN(title)+1,  XMIN(title),  "HAND");
  124.         break;
  125.       case CHICAGO_SCORING:
  126.           print (YMIN(scores)+4, XMIN(scores), "TOTAL");
  127.           print (YMIN(scores)+5, XMIN(scores), "PART");
  128.           print (YMIN(title)+1,  XMIN(title),  "HAND");
  129.         break;
  130.       case DUPLICATE_SCORING:
  131.       case EMAIL_SCORING:
  132.           print (YMIN(scores)+4, XMIN(scores), "TOTAL");
  133.           print (YMIN(scores)+5, XMIN(scores), "PREV");
  134.           print (YMIN(title)+1,  XMIN(title),  "BOARD");
  135.         break;
  136.       case IMP_SCORING:
  137.           print (YMIN(scores)+4, XMIN(scores), "TOTAL");
  138.           print (YMIN(scores)+5, XMIN(scores), "IMP");
  139.           print (YMIN(title)+1,  XMIN(title),  "BOARD");
  140.         break;
  141.     };
  142.     sprintf (program_name, "%d", current_deal_no);
  143.     print (YMIN(title)+1, XMIN(title)+6, program_name);
  144.  
  145.     /* Setup the input area: */
  146.     print (TALK_ROW, TALK_COL, "TALK");
  147.  
  148.  
  149.     /* Setup the conversational area: */
  150.     for (i = 0; i <= XMAX(converse); i++) line_buf[i] = '-';
  151.     line_buf[XMAX(converse)+1] = '\0';
  152.     print (YMIN(converse), XMIN(converse), line_buf);
  153.     for (i = YMIN(converse)+1; i <= YMAX(converse); i++) {
  154.         print (i, XMIN(converse), "|");
  155.         print (i, XMAX(converse)+1, "|");
  156.     };
  157. };
  158.  
  159. Initialize_Display ()
  160. /* Should be called once when the program starts up. */
  161. { 
  162. /*    Initialize_Terminal (); */ 
  163.     Reset_Display ();
  164.  
  165.     PLAYERHAND_X [local_player] = XMIN(bottom_hand);
  166.     PLAYERHAND_Y [local_player] = YMIN(bottom_hand);
  167.     PLAYERHAND_X [player_next[local_player]] = XMIN(left_hand);
  168.     PLAYERHAND_Y [player_next[local_player]] = YMIN(left_hand);
  169.     PLAYERHAND_X [player_partner[local_player]] = XMIN(top_hand);
  170.     PLAYERHAND_Y [player_partner[local_player]] = YMIN(top_hand);
  171.     PLAYERHAND_X [player_prev[local_player]] = XMIN(right_hand);
  172.     PLAYERHAND_Y [player_prev[local_player]] = YMIN(right_hand);
  173.  
  174.     CARDPOS_Y[local_player] = YMAX(playing_board) - 2;
  175.     CARDPOS_X[local_player] = (XMAX(playing_board) + 
  176.                    XMIN(playing_board))/2;
  177.     CARDPOS_Y[player_next[local_player]] = (YMAX(playing_board) + 
  178.                         YMIN(playing_board))/2;
  179.     CARDPOS_X[player_next[local_player]] = XMIN(playing_board) + 3;
  180.     CARDPOS_Y[player_partner[local_player]] = YMIN(playing_board) + 2;
  181.     CARDPOS_X[player_partner[local_player]] = (XMAX(playing_board) + 
  182.                            XMIN(playing_board))/2;
  183.     CARDPOS_Y[player_prev[local_player]] = (YMAX(playing_board) + 
  184.                         YMIN(playing_board))/2;
  185.     CARDPOS_X[player_prev[local_player]] = XMAX(playing_board) - 4;
  186.  
  187.     position_names[0] = player_names [local_player];
  188.     position_names[1] = player_names [player_next[local_player]];
  189.     position_names[2] = player_names [player_partner[local_player]];
  190.     position_names[3] = player_names [player_prev[local_player]];
  191.  
  192.     status_message_buf[0] = '\0';
  193.  
  194. };
  195.  
  196. Refresh_Display ()
  197. /* Resets the terminal display and redraws everything. */
  198. {
  199.     int i, j, p;
  200.  
  201.     Reset_Display ();
  202.     Display_Tricks_Taken ();
  203.     Display_Above_Line_Points ();
  204.     Display_Below_Line_Points ();
  205.     Display_Vulnerabilities ();
  206.     Refresh_Player_Comments ();
  207.     if (game_mode == STARTUP_MODE) {
  208.         ;
  209.     } else if (game_mode == BIDDING_MODE) {
  210.         Display_Bidding_Board ();
  211.         Display_Hand_for_Bidding (local_player);
  212.         p = dealer;
  213.         for (i = 0; i < no_bids; i++) {
  214.             Display_Bid (i/4 + 1, p);
  215.             p = player_next [p];
  216.         };
  217.                 Display_Bidder (p);
  218.         print (PLAY_ROW, PLAY_COL, "BID ");
  219.     } else if (game_mode == PLAYING_MODE) {
  220.         Display_Contract (); 
  221.         Display_Playing_Board ();
  222.         Display_Hand (local_player);
  223.         if ((trick > 1) || (no_plays > 0))
  224.           Display_Hand (dummy);
  225.         if (local_player == dummy)
  226.           Display_Hand (declarer);
  227. #ifdef LOOPBACK_MODE
  228.         Display_Hand (player_next[local_player]);    /* DBG */
  229.         Display_Hand (player_partner[local_player]);    /* DBG */
  230.         Display_Hand (player_prev[local_player]);    /* DBG */
  231. #endif
  232. #ifdef TWOPLAYER_MODE
  233.         Display_Hand (player_partner[local_player]);
  234. #endif
  235.  
  236.         p = leader;
  237.         for (i = 0; i < no_plays; i++) {
  238.             Display_Play (p, plays[p]);
  239.             p = player_next[p];
  240.         };
  241.                 Display_Player (p);
  242.         print (PLAY_ROW, PLAY_COL, "PLAY");
  243.           } else if (game_mode == REVIEW_MODE) {
  244.         Display_Contract (); 
  245.         Display_Playing_Board ();
  246.         Display_Player (-1);
  247.         Display_Below_Line_Points ();
  248.         Display_Above_Line_Points ();
  249.         for (i = 0; i < 4; i++)
  250.           Display_Hand (i);
  251. /*
  252.         Display_Status 
  253.           ("REVIEW OF THE HAND -- PRESS RETURN ON A BLANK LINE TO PROCEED");
  254. */
  255.           };
  256.     Refresh_Status_Display ();
  257.  
  258. };
  259.  
  260.  
  261.  
  262. Display_Tricks_Taken ()
  263. {
  264.     sprintf (line_buf,"%5d   %5d",tricks[SIDE_NS], tricks[SIDE_EW]);
  265.     print (YMIN(scores)+2,XMIN(scores)+8, line_buf);
  266. };
  267.  
  268. Display_Above_Line_Points ()
  269. {
  270.     sprintf (line_buf,"%5d   %5d",above_line[SIDE_NS],
  271.         above_line[SIDE_EW]);
  272.     print (YMIN(scores)+4,XMIN(scores)+8, line_buf);
  273. };
  274.  
  275. Display_Below_Line_Points ()
  276. {
  277.   sprintf (line_buf,"%5d   %5d",below_line[SIDE_NS],
  278.        below_line[SIDE_EW]);
  279.   print (YMIN(scores)+5,XMIN(scores)+8, line_buf);
  280. };
  281.  
  282. Display_Vulnerabilities   ()
  283. {
  284.     char *nsv, *ewv;
  285.  
  286.     if (vulnerable[SIDE_NS]) nsv = "  YES";
  287.     else              nsv = "   NO";
  288.     if (vulnerable[SIDE_EW]) ewv = "  YES";
  289.     else              ewv = "   NO";
  290.     sprintf (line_buf, "%s   %s",nsv,ewv);
  291.     print (YMIN(scores)+3, XMIN(scores)+8, line_buf);
  292. };
  293.  
  294. Clear_Bidding_Board ()
  295. {
  296.     int x, y, h, w;
  297.  
  298.     x = XMIN(bidding_board);
  299.     y = YMIN(bidding_board);
  300.     h = HEIGHT(bidding_board);
  301.     w = WIDTH(bidding_board);
  302.     clear_screen_area (y, x, h, w);
  303.     clear_screen_area (PLAY_ROW, 1, 1, 10);
  304.  
  305. };
  306.  
  307. Display_Bidding_Board ()
  308. /* The bidding display is given as four columns, similar to that found
  309.    in many bridge books.  At the top of each column is printed the
  310.    corresponding input parameter string to identify the bidder. */
  311. {
  312.     int i;
  313.     char *first, *second, *third, *fourth, board_no_buf[10];
  314.  
  315.     Clear_Bidding_Board ();
  316.  
  317.     first  = player_names [PLAYER_NORTH];
  318.     second = player_names [player_next[PLAYER_NORTH]];
  319.     third  = player_names [player_partner[PLAYER_NORTH]];
  320.     fourth = player_names [player_prev[PLAYER_NORTH]];
  321.  
  322.     print(YMIN(bidding_board), XMIN(bidding_board)+05, first);
  323.     print(YMIN(bidding_board), XMIN(bidding_board)+15, second);
  324.     print(YMIN(bidding_board), XMIN(bidding_board)+25, third);
  325.     print(YMIN(bidding_board), XMIN(bidding_board)+35, fourth);
  326.  
  327.     underline(YMIN(bidding_board),XMIN(bidding_board)+05,strlen(first));
  328.     underline(YMIN(bidding_board),XMIN(bidding_board)+15,strlen(second));
  329.     underline(YMIN(bidding_board),XMIN(bidding_board)+25,strlen(third));
  330.     underline(YMIN(bidding_board),XMIN(bidding_board)+35,strlen(fourth));
  331.  
  332.     sprintf (board_no_buf, "%d", current_deal_no);
  333.     print (YMIN(title)+1, XMIN(title)+6, board_no_buf);
  334.  
  335. };
  336.  
  337. static Display_suit (y, x, cards)
  338.      int y, x; suit_type cards;
  339. /* Displays the cards in a given suit held by a player.  As input,
  340.  * cards[] is an array of 13 elements, where cards[i] is TRUE if the
  341.  * player holds the given card.  Displays the cards as a string on
  342.  * the terminal, beginning at coordinates <y,x>.
  343.  */
  344. {
  345.     int i;
  346.  
  347.     for (i = 12; i >= 0; i--)
  348.         if (cards[i])
  349.             print (y, x++, rank_names[i]);
  350. };
  351.  
  352. Display_Hand_for_Bidding (pos)
  353. int pos;
  354. {
  355.     int i, x, y;
  356.     suit_type h;
  357.  
  358.     y = YMIN(bidding_board);
  359.     x = XMIN(bidding_board) + 45;
  360.     clear_screen_area (y, x, HEIGHT(bidding_board),
  361.         XMAX(bidding_board)-x+1);
  362.     for (i = 0; i < 6; i++)
  363.         print (y+i, x, "|");
  364.  
  365.     x+=1;
  366.     print (y, x, player_names[pos]);
  367.     underline (y, x, strlen(player_names[pos]));
  368.     h = current_hand[pos];
  369.     print (y+2, x, "S "); Display_suit (y+2, x+2, h+39);
  370.     print (y+3, x, "H "); Display_suit (y+3, x+2, h+26);
  371.     print (y+4, x, "D "); Display_suit (y+4, x+2, h+13);
  372.     print (y+5, x, "C "); Display_suit (y+5, x+2, h);
  373. };
  374.  
  375. Display_Bidder (player)
  376.     int player;
  377. {
  378.     char bid_buf[80];
  379.  
  380.     sprintf (bid_buf, "%s's BID        ", player_names[player]);
  381.     print (YMIN(title)+2, XMIN(title), bid_buf);
  382. };
  383.  
  384. Display_Bid (round, player)
  385.      int round, player;
  386. {
  387.     int x, y, bid, position;
  388.     char *bid_string;
  389.  
  390.     y = YMIN(bidding_board) + round + 1;
  391.     sprintf (line_buf, " %2d", round);
  392.     print (y, XMIN(bidding_board), line_buf);
  393.  
  394. /* 
  395.     if (player == dealer) position = 0;
  396.     else if (player == player_next[dealer]) position = 1;
  397.     else if (player == player_partner[dealer]) position = 2;
  398.     else position = 3;
  399. */
  400.     y++; 
  401.     for (x = dealer; x < 4; x++)
  402.         if (x == player) y--;
  403.  
  404.     position = player;
  405.     x = XMIN(bidding_board) + 10 * position + 5;
  406.     bid = bids[player][round-1];
  407.     if (bid == BID_PASS)
  408.         bid_string = "--";
  409.     else
  410.         bid_string = bid_names[bid];
  411.     print (y, x, bid_string);
  412. };
  413.  
  414. Display_Contract ()
  415. {
  416.     char double_buf[40], contract_buf[60];
  417.  
  418.     clear_screen_area (YMIN(title)+2, XMIN(title), HEIGHT(title),
  419.                WIDTH(title));
  420.     if (redoubled)
  421.         sprintf (double_buf,"  REDOUBLED");
  422.     else if (doubled)
  423.         sprintf (double_buf, "  DOUBLED");
  424.     else
  425.         double_buf[0] = '\0';
  426.     sprintf (contract_buf, "%1d%s (%s)%s",contract,suit_names[trump_suit],
  427.         player_names[declarer], double_buf);
  428.  
  429.     print (YMIN(title)+3, XMIN(title), contract_buf);
  430. }
  431.  
  432. Clear_Playing_Board ()
  433. {
  434.     clear_screen_area (YMIN(playing_board), XMIN(playing_board),
  435.         HEIGHT(playing_board), WIDTH(playing_board));
  436.     clear_screen_area (YMIN(left_hand), XMIN(left_hand),
  437.         HEIGHT(left_hand), WIDTH(left_hand));
  438.     clear_screen_area (YMIN(right_hand), XMIN(right_hand),
  439.         HEIGHT(right_hand), WIDTH(right_hand));
  440.       clear_screen_area (YMIN(top_hand), XMIN(top_hand),
  441.         HEIGHT(top_hand), WIDTH(top_hand));
  442.     clear_screen_area (YMIN(bottom_hand), XMIN(bottom_hand),
  443.         HEIGHT(bottom_hand), WIDTH(bottom_hand));
  444.     clear_screen_area (YMIN(title)+3, XMIN(title), 1, WIDTH(title));
  445. };
  446.  
  447. Display_Playing_Board ()
  448. {
  449.     int i;
  450.  
  451. /*    Clear_Playing_Board (); */
  452.  
  453.     for (i = 0; i < 4; i++)
  454.         print (PLAYERHAND_Y[i]+1, PLAYERHAND_X[i]+12 -
  455.                strlen(player_names[i]), player_names[i]);
  456.  
  457.     for (i = 0; i < WIDTH(playing_board)-1; i++) line_buf[i] = '-';
  458.     line_buf[WIDTH(playing_board)-2] = '\0';
  459.     print (YMIN(playing_board)+1,XMIN(playing_board)+1,line_buf);
  460.     print (YMAX(playing_board)-1,XMIN(playing_board)+1,line_buf);
  461.  
  462.     for (i = YMIN(playing_board)+2; i < YMAX(playing_board)-1; i++) {
  463.         print (i, XMIN(playing_board)+1, "|");
  464.         print (i, XMAX(playing_board)-1, "|");
  465.     };
  466. };
  467.  
  468. Display_Player (player)
  469.     int player;
  470. {
  471.     char play_buf[80];
  472.  
  473.     if (player < 0)
  474.         sprintf (play_buf, "                    ");
  475.     else if (player == dummy)
  476.         sprintf (play_buf, "DUMMY'S PLAY        ");
  477.     else
  478.         sprintf (play_buf, "%s's PLAY        ",
  479.              player_names[player]);
  480.     print (YMIN(title)+4, XMIN(title), play_buf);
  481. };
  482.  
  483. Display_Play (p, card)
  484.      int p, card;
  485. {
  486.     int x, y, position;
  487.  
  488.     y = CARDPOS_Y [p];
  489.     x = CARDPOS_X [p];
  490.     if ((0 <= card) && (card < 52))
  491.         print (y, x, card_names[card]);
  492.     else
  493.         print (y, x, "   ");
  494. };
  495.  
  496. Clear_Plays  ()
  497. {
  498.     Display_Play (PLAYER_NORTH, -1);
  499.     Display_Play (PLAYER_EAST,  -1);
  500.     Display_Play (PLAYER_SOUTH, -1);
  501.     Display_Play (PLAYER_WEST,  -1);
  502. };
  503.  
  504. Display_Hand (p)
  505.      int p;
  506. {
  507.     int y, x, i;
  508.     suit_type h;
  509.  
  510.     y = PLAYERHAND_Y [p];
  511.     x = PLAYERHAND_X [p];
  512.     for (i = 0; i < 4; i++)
  513.         print (y+i, x, "                   ");
  514.  
  515.     h = current_hand[p];
  516.     print (y,   x+5-strlen(player_names[p]), player_names[p]);
  517.     if (p == dummy)
  518.         print (y+1, x+5-7, "(DUMMY)");
  519.     print (y,   x+7, "S "); Display_suit (y,   x+10, h+39);
  520.     print (y+1, x+7, "H "); Display_suit (y+1, x+10, h+26);
  521.     print (y+2, x+7, "D "); Display_suit (y+2, x+10, h+13);
  522.     print (y+3, x+7, "C "); Display_suit (y+3, x+10, h);
  523. };
  524.  
  525. Clear_Hand (p)
  526.      int p;
  527. {
  528.     int y, x, i;
  529.  
  530.     y = PLAYERHAND_Y [p];
  531.     x = PLAYERHAND_X [p];
  532.     for (i = 0; i < 4; i++)
  533.         print (y+i, x, "                   ");
  534.  
  535.     print (y,   x+5-strlen(player_names[p]), player_names[p]);
  536.     if (p == dummy)
  537.         print (y+1, x+5-7, "(DUMMY)");
  538. };
  539.  
  540. Display_Status (message)
  541.      char *message;
  542. {
  543.         Clear_Status_Display ();
  544.     print (YMIN(status), XMIN(status), message);
  545.     sprintf (status_message_buf, "%s", message);
  546.     set_cursor (YMIN(status), XMIN(status) + strlen(message) + 1);
  547. };
  548.  
  549. Clear_Status_Display ()
  550. {
  551.     clear_screen_area (YMIN(status), XMIN(status), 1, WIDTH(status));
  552.     status_message_buf [0] = '\0';
  553. };
  554.  
  555. Refresh_Status_Display ()
  556. {
  557.     clear_screen_area (YMIN(status), XMIN(status), 1, WIDTH(status));
  558.     print (YMIN(status), XMIN(status), status_message_buf);
  559.     set_cursor (YMIN(status), 
  560.             XMIN(status) + strlen(status_message_buf) + 1);
  561. };
  562.  
  563. /* The bottom part of the screen is used for the exchange of comments
  564.    between the players.  The following procedures are used for managing
  565.    this part of the display. */
  566.  
  567. #define COMMENT_LENGTH 78
  568. #define COMMENT_BUF_SIZE 5
  569.  
  570. typedef char comment_line [COMMENT_LENGTH];
  571. typedef comment_line comment_buf [COMMENT_BUF_SIZE];
  572. static  comment_buf  player_comments;
  573.  
  574. static blank_out_comment (c)
  575.      comment_line c;
  576. {
  577.     int i;
  578.  
  579.     for (i = 0; i < COMMENT_LENGTH-1; i++) c[i] = ' ';
  580.     c[COMMENT_LENGTH-1] = '\0';
  581. };
  582.  
  583. static copy_string_to_comment (c, s)
  584.      comment_line c; char *s;
  585. {
  586.     int i;
  587.  
  588.     blank_out_comment(c);
  589.     i = 0;
  590.     while ((s[i] != '\0') && (i < COMMENT_LENGTH-1)) {
  591.         c[i] = s[i]; i++; }
  592.  
  593. };
  594.  
  595. static scroll_player_comments ()
  596. {
  597.     int i, j;
  598.  
  599.     for (i = 0; i < COMMENT_BUF_SIZE - 1; i++)
  600.         for (j = 0; j < COMMENT_LENGTH; j++) {
  601.             player_comments[i][j] =
  602.                 player_comments[i+1][j];
  603.         };
  604. };
  605.  
  606. Refresh_Player_Comments ()
  607. {
  608.     int i, x, y;
  609.  
  610.     if (comments_suspended)
  611.         return;
  612.  
  613.     x = XMIN(converse) + 1;
  614.     y = YMIN(converse) + 1;
  615.  
  616.     for (i = 0; i < COMMENT_BUF_SIZE; i++)
  617.         print (y+i, x, player_comments[i]);
  618. };
  619.  
  620. Initialize_Player_Comments ()
  621. {
  622.     int i;
  623.  
  624.     for (i = 0; i < COMMENT_BUF_SIZE; i++)
  625.         blank_out_comment (player_comments[i]);
  626.     Refresh_Player_Comments ();
  627. };
  628.  
  629. Display_Player_Comment (player_name, comment)
  630.      char *player_name, *comment;
  631. {
  632.     char message_buf [80];
  633.  
  634.     sprintf (message_buf, "%s: %s", player_name, comment);
  635.     scroll_player_comments ();
  636.     copy_string_to_comment (player_comments[COMMENT_BUF_SIZE-1],
  637.                 message_buf);
  638.     Refresh_Player_Comments ();
  639. };
  640.  
  641.  
  642. void Suspend_Comment_Display ()
  643. {
  644.     comments_suspended = 1;
  645. };
  646.  
  647. void Continue_Comment_Display ()
  648. {
  649.     comments_suspended = 0;
  650. };
  651.  
  652.  
  653.