home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 January / usenetsourcesnewsgroupsinfomagicjanuary1994.iso / sources / games / volume14 / okbridge2 / part06 / display.c < prev   
C/C++ Source or Header  |  1993-01-27  |  34KB  |  1,287 lines
  1. /* display.c -- Display functions for OKbridge program.
  2.  *
  3.  ! Copyright (C) 1990-1992 by Matthew Clegg.  All Rights Reserved
  4.  ! 
  5.  ! OKbridge is made available as a free service to the Internet.
  6.  ! Accordingly, the following restrictions are placed on its use:
  7.  ! 
  8.  ! 1.  OKbridge may not be modified in any way without the explicit 
  9.  !     permission of Matthew Clegg.  
  10.  ! 
  11.  ! 2.  OKbridge may not be used in any way for commercial advantage.
  12.  !     It may not be placed on for-profit networks or on for-profit
  13.  !     computer systems.  It may not be bundled as part of a package
  14.  !     or service provided by a for-profit organization.
  15.  ! 
  16.  ! If you have questions about restrictions on the use of OKbridge,
  17.  ! write to mclegg@cs.ucsd.edu.
  18.  ! 
  19.  ! DISCLAIMER:  The user of OKbridge accepts full responsibility for any
  20.  ! damage which may be caused by OKbridge.
  21.  *
  22.  */
  23.  
  24. #include <stdio.h>
  25. #include <string.h>
  26.  
  27. extern char *malloc ();
  28.  
  29. #define _DISPLAY_
  30.  
  31. #include "state.h"
  32. #include "terminal.h"
  33. #include "display.h"
  34. #include "help.h"
  35. #include "input.h"
  36.  
  37. #ifdef LOGFILE
  38. extern FILE *net_log;
  39. #endif
  40.  
  41. typedef int window[4];
  42.  
  43. /* Conceptually, we think of the screen as being divided into a number
  44.    of windows, where each window describes one particular type of activity
  45.    or aspect of the game.  Therefore, we make the following definitions,
  46.    although these are only guidelines for operation of the display.
  47.  
  48. Name of
  49. Window               Ymin    Xmin    Height    Width
  50. -------             ----    ----    ----    ----            */
  51. window title          = { 1,    1,    6,    25};
  52. window top_hand      = { 2,    30,    4,    26};
  53. window scores         = { 1,    58,    6,    26};
  54. window left_hand     = { 8,    6,    6,    18};
  55. window playing_board = { 5,    27,    9,    26};
  56. window bidding_board = { 5,    1,    9,    57};
  57. window right_hand    = { 8,    56,    6,    23};
  58. window input         = { 13,    1,    6,    26};
  59. window status         = { 18,    1,    1,    79};
  60. window bottom_hand   = { 13,    30,    4,    26};
  61. window help         = { 13,    53,    6,    26};
  62. window converse         = { 19,    1,    6,    78};
  63.  
  64. #define XMIN(w)        w[1]
  65. #define YMIN(w)         w[0]
  66. #define XMAX(w)        (w[1] + w[3] - 1)
  67. #define YMAX(w)        (w[0] + w[2] - 1)
  68. #define HEIGHT(w)    w[2]
  69. #define WIDTH(w)    w[3]
  70.  
  71. static int PLAYERHAND_X [4];
  72. static int PLAYERHAND_Y [4]; 
  73. static int CARDPOS_X    [4];
  74. static int CARDPOS_Y    [4];
  75. static char *position_names [4];
  76. static int comments_suspended = 0;
  77.  
  78. static char line_buf [81];
  79. static int  status_loc;
  80.  
  81. #define COMMENT_LENGTH 78
  82.  
  83. typedef char comment_line [COMMENT_LENGTH];
  84. typedef comment_line *comment_buf;
  85.  
  86. static int full_screen_talk_start = 3;
  87.   /* The first line of the screen on which comments will be displayed,
  88.      if the full screen is used for talking.  */
  89. static int full_screen_talk_end  = 22;
  90.   /* The last line on which comments will be displayed for full screen mode. */
  91. static int full_screen_talk_size = 20;
  92.   /* The total number of lines in the full screen talk display. */
  93. static int full_screen_cursor = 0;
  94.   /* The line in the full screen buffer where the next talk message will be
  95.      displayed. */
  96.  
  97. static int playing_screen_talk_start = 20;
  98.   /* The first line of the screen on which comments will be displayed,
  99.      if we are in playing mode. */
  100. static int playing_screen_talk_end = 24;
  101.   /* last comment line for playing screen. */
  102. static int playing_screen_talk_size = 5;
  103.   /* The total number of lines in the playing screen talk display. */
  104.  
  105. static int talk_start, talk_end;
  106.   /* The current first and last lines for display of player comments. */
  107. static int talk_size;
  108.   /* talk_end - talk_start + 1. */
  109.  
  110. static comment_line *full_screen_comments = NULL, 
  111.                     *playing_screen_comments = NULL,
  112.                     *player_comments;
  113.  
  114. /* We record the list of cards played in the current trick, so that
  115.    we can redisplay them during a refresh if necessary. */
  116. static int Current_trick [4];
  117.   /* A list of plays indexed by position.  If the value is non-negative,
  118.      then it indicates the play made by the corresponding player. */
  119.  
  120. static int status_display_level = 0;
  121.   /* The number of locks which have been placed on the status display. */
  122. static char status_buf [10] [80];
  123.   /* For each lock level, a record of the status message at that level. */
  124.  
  125. Board *Board_for_display;
  126.   /* This is a pointer to the board which is being displayed in the
  127.      SCORING_DISPLAY mode. */
  128. Play_record *Current_page_of_scores = NULL;
  129.   /* The first play record which is being displayed on the current page
  130.      of scores. */
  131. Play_record *Next_page_of_scores = NULL;
  132.   /* The first play record which will be displayed on the next page 
  133.      of scores. */
  134.  
  135. char total_time_buffer [20];
  136.   /* A buffer used for displaying the total time playing the current hand. */
  137. char local_time_buffer [20];
  138.   /* A buffer used for displaying the time used by the local player. */
  139.     
  140. void Select_Talk_Mode ();
  141. void Select_Conversation_Mode ();
  142. void Display_Page_of_Scores ();
  143. void Refresh_Time_Display ();
  144.  
  145.  
  146. static void underline (ymin, xmin, length)
  147.        int ymin, xmin, length;
  148. /* Prints a line of hyphens BELOW the field beginning at (ymin,xmin),
  149.  *  of given length.
  150.  */
  151. {
  152.     int i;
  153.  
  154.     for (i = 0; i < length; i++)
  155.         line_buf[i] = '-';
  156.     line_buf[length] = '\0';
  157.     print (ymin+1, xmin, line_buf);
  158. }
  159.  
  160. static void clear_screen_area (ymin, xmin, height, width)
  161.        int ymin, xmin, height, width;
  162. {
  163.     int i;
  164.  
  165.     for (i = 0; i < width; i++) line_buf[i] = ' ';
  166.     line_buf[width] = '\0';
  167.     for (i = 0; i < height; i++) print (ymin+i, xmin, line_buf);
  168. }
  169.  
  170. static void Display_Board_Number ()
  171. {
  172.   if ((Local_board != NULL) && (Local_board->source != NULL)) {
  173.     sprintf (line_buf, "%s BOARD %d", Local_board->source,
  174.          Local_board->serial_no);
  175.     print (YMIN(title)+1,  XMIN(title),  line_buf);
  176.   } else {
  177.     sprintf (line_buf, "%d", hands_played);
  178.     print (YMIN(title)+1, XMIN(title)+6, line_buf);
  179.   }
  180.  
  181. }
  182.  
  183. static void Redraw_Scoring_Panel ()
  184. /* Redraws the scoring panel in the upper corner of the screen, which
  185.    displays the vulnerabilities, number of tricks taken, and scores.
  186. */
  187. {
  188.   /* Setup the scoreboard: */
  189.   if (local_player >= 4) {
  190.     print (YMIN(scores), XMIN(scores) + 8,   "  N-S");
  191.     print (YMIN(scores), XMIN(scores) + 16,  "  E-W");
  192.   } else if (side_of(local_player) == SIDE_NS) {
  193.     print (YMIN(scores), XMIN(scores) + 8,   "   WE");
  194.     print (YMIN(scores), XMIN(scores) + 16,  " THEY");
  195.   } else {
  196.     print (YMIN(scores), XMIN(scores) + 16,  "   WE");
  197.     print (YMIN(scores), XMIN(scores) + 8,   " THEY");
  198.   }
  199.   underline (YMIN(scores), XMIN(scores) + 8, 5);
  200.   underline (YMIN(scores), XMIN(scores) + 16, 5);
  201.   print (YMIN(scores)+2, XMIN(scores), "TRICKS");
  202.   print (YMIN(scores)+3, XMIN(scores), "VUL");
  203.   
  204.   switch (Local_board->scoring_mode) {
  205.   case RUBBER_SCORING:
  206.     print (YMIN(scores)+4, XMIN(scores), "ABOVE");
  207.     print (YMIN(scores)+5, XMIN(scores), "BELOW");
  208.     print (YMIN(title)+1,  XMIN(title),  "HAND");
  209.     break;
  210.   case DUPLICATE_SCORING:
  211.     print (YMIN(scores)+4, XMIN(scores), "TOTAL");
  212.     print (YMIN(scores)+5, XMIN(scores), "PREV");
  213.     print (YMIN(title)+1,  XMIN(title),  "BOARD");
  214.     break;
  215.   case IMP_SCORING:
  216.     print (YMIN(scores)+4, XMIN(scores), "TOTAL");
  217.     print (YMIN(scores)+5, XMIN(scores), "IMP");
  218.     print (YMIN(title)+1,  XMIN(title),  "BOARD");
  219.     break;
  220.   case MP_SCORING:
  221.     print (YMIN(scores)+4, XMIN(scores), "TOTAL");
  222.     print (YMIN(scores)+5, XMIN(scores), "MP");
  223.     print (YMIN(title)+1,  XMIN(title),  "BOARD");
  224.     break;
  225.   default:
  226.     break;
  227.   }
  228.  
  229.   Display_Tricks_Taken ();
  230.   Display_Above_Line_Points ();
  231.   Display_Below_Line_Points ();
  232.   Display_Vulnerabilities ();
  233.   Display_Board_Number ();
  234.  
  235. }
  236.  
  237. static void Redraw_Conversation_Area ()
  238. {
  239.   int i;
  240.  
  241.   /* Setup the conversational area: */
  242.   for (i = 0; i <= XMAX(converse); i++) line_buf[i] = '-';
  243.   line_buf[72] = '+';
  244.   line_buf[XMAX(converse)+1] = '\0';
  245.   print (YMIN(converse), XMIN(converse), line_buf);
  246.   for (i = talk_start; i <= talk_end; i++) {
  247.     print (i, XMIN(converse), "|");
  248.     print (i, XMAX(converse)+1, "|");
  249.   }
  250.  
  251.   /* Setup the input area: */
  252.   print (TALK_ROW, TALK_COL, "TALK");
  253.   status_loc = YMIN(status);
  254.  
  255. }
  256.  
  257. static void Redraw_Bidding_Display ()
  258. {
  259.   int i, p;
  260.   hand h;
  261.   
  262.   Display_Bidding_Board ();
  263.   if (IS_PLAYER(local_player)) {
  264.     Generate_holdings (Local_board, Local_play->play_list, 0, local_player, h);
  265.     Display_Hand_for_Bidding (local_player, h);
  266.   } else if (spectator_mode) {
  267.     Generate_holdings (Local_board, Local_play->play_list, 0, 
  268.                revealed_bidder, h);
  269.     Display_Hand_for_Bidding (revealed_bidder, h);
  270.   }
  271.  
  272.   p = Local_board->dealer;
  273.   for (i = 0; i < Local_play->no_bids; i++) {
  274.     Display_Bid (i);
  275.     p = player_next [p];
  276.   }
  277.   Display_Bidder (p);
  278.   Refresh_Time_Display ();
  279.   print (PLAY_ROW, PLAY_COL, "BID ");
  280. }
  281.  
  282. static void Redraw_Playing_Display ()
  283. {
  284.   int i;
  285.  
  286.   Display_Contract (); 
  287.   Display_Playing_Board ();
  288.  
  289.   for (i = 0; i < 4; i++)
  290.     if (revealed_hands[i]) {
  291.       if (Local_table->game_mode == PLAYING_MODE)
  292.     Display_Hand(i);
  293.       else
  294.     Display_Partial_Hand (i, 0);
  295.     }
  296.  
  297.   for (i = 0; i < 4; i++)
  298.     Display_Play (i, Current_trick[i]);
  299.  
  300.   Display_Player (Local_play->next_player);
  301.   Refresh_Time_Display ();
  302.   print (PLAY_ROW, PLAY_COL, "PLAY");
  303. }
  304.  
  305. static void Redraw_Scoring_Display ()
  306. {
  307.   Display_Page_of_Scores (Current_page_of_scores);
  308. }
  309.  
  310. void Display_Player_Position ()
  311. {
  312.   char buf[80], *position_name;
  313.   
  314.   if (IS_PLAYER(local_player))
  315.     position_name = seat_names[local_player];
  316.   else if (spectator_mode)
  317.     position_name = "SPECTATOR";
  318.   else
  319.     position_name = "OBSERVER";
  320.   
  321.   sprintf (buf, "OKBRIDGE %s%s  %s     ", 
  322.        major_revision_level, minor_revision_level, position_name);
  323.   
  324.   print (1, 1, buf);
  325. } 
  326.  
  327. void Refresh_Status_Display ();
  328. void Begin_full_screen_talk_mode ();
  329. void Recompute_Display_Positions ();
  330.  
  331. void Reset_Display ()
  332. /* Redraws the main features of the screen.  Used in the process
  333.  * of doing a 'refresh'.
  334.  */
  335. {
  336.   if (display_mode == MANUAL_DISPLAY)
  337.     return;
  338.  
  339.   clear_screen ();
  340.  
  341.   Recompute_Display_Positions ();
  342.  
  343.   if (display_mode == HELP_DISPLAY) {
  344.     Suspend_Comment_Display ();
  345.     status_loc = terminal_lines;
  346.     display_topics ("LIST OF HELP TOPICS");
  347.     print (terminal_lines-1, 1, "HELP");
  348.     Refresh_Status_Display ();
  349.     return;
  350.   }
  351.  
  352.   Display_Player_Position ();
  353.   Continue_Comment_Display ();
  354.   
  355.   switch (display_mode) {
  356.   case TALK_DISPLAY:
  357.     Begin_full_screen_talk_mode ();
  358.     break;
  359.   case BIDDING_DISPLAY:
  360.     Redraw_Bidding_Display ();
  361.     Redraw_Scoring_Panel ();
  362.     Redraw_Conversation_Area ();
  363.     break;
  364.   case PLAYING_DISPLAY:
  365.     Redraw_Playing_Display ();
  366.     Redraw_Scoring_Panel ();
  367.     Redraw_Conversation_Area ();
  368.     break;
  369.   case SCORING_DISPLAY:
  370.     Redraw_Scoring_Display ();
  371.     Redraw_Conversation_Area ();
  372.     break;
  373.   }
  374.  
  375.   Refresh_Player_Comments ();
  376.   Refresh_Status_Display ();
  377. }
  378.  
  379. void Recompute_Display_Positions ()
  380. /* Recomputes a number of internal constants for the display. */
  381. {
  382.   int l = local_player;
  383.   
  384.   if (l >= 4) l = PLAYER_SOUTH;
  385.   
  386.   PLAYERHAND_X [l] = XMIN(bottom_hand);
  387.   PLAYERHAND_Y [l] = YMIN(bottom_hand);
  388.   PLAYERHAND_X [player_next[l]] = XMIN(left_hand);
  389.   PLAYERHAND_Y [player_next[l]] = YMIN(left_hand);
  390.   PLAYERHAND_X [player_partner[l]] = XMIN(top_hand);
  391.   PLAYERHAND_Y [player_partner[l]] = YMIN(top_hand);
  392.   PLAYERHAND_X [player_prev[l]] = XMIN(right_hand);
  393.   PLAYERHAND_Y [player_prev[l]] = YMIN(right_hand);
  394.   
  395.   CARDPOS_Y[l] = YMAX(playing_board) - 2;
  396.   CARDPOS_X[l] = (XMAX(playing_board) + 
  397.           XMIN(playing_board))/2;
  398.   CARDPOS_Y[player_next[l]] = (YMAX(playing_board) + 
  399.                    YMIN(playing_board))/2;
  400.   CARDPOS_X[player_next[l]] = XMIN(playing_board) + 3;
  401.   CARDPOS_Y[player_partner[l]] = YMIN(playing_board) + 2;
  402.   CARDPOS_X[player_partner[l]] = (XMAX(playing_board) + 
  403.                   XMIN(playing_board))/2;
  404.   CARDPOS_Y[player_prev[l]] = (YMAX(playing_board) + 
  405.                    YMIN(playing_board))/2;
  406.   CARDPOS_X[player_prev[l]] = XMAX(playing_board) - 4;
  407.   
  408.   position_names[0] = PLAYER_NAME(Local_table, l);
  409.   position_names[1] = PLAYER_NAME(Local_table, player_next[l]);
  410.   position_names[2] = PLAYER_NAME(Local_table, player_partner[l]);
  411.   position_names[3] = PLAYER_NAME(Local_table, player_prev[l]);
  412. }
  413.  
  414. void Initialize_Display ()
  415. /* Should be called once when the program starts up. */
  416. { 
  417.   Initialize_Player_Comments ();
  418.   status_buf[0][0] = '\0';
  419.   display_mode = TALK_DISPLAY;
  420.   Current_trick[0] = Current_trick[1] = 
  421.     Current_trick[2] = Current_trick[3] = -1;
  422.  
  423.   Reset_Display ();
  424.   Recompute_Display_Positions ();
  425. }
  426.  
  427. void Reinitialize_Display ()
  428. {
  429.   Reinitialize_Player_Comments ();
  430.   Reset_Display ();
  431.  
  432.   Recompute_Display_Positions ();
  433. }
  434.  
  435. void Refresh_Display ()
  436. /* Resets the terminal display and redraws everything. */
  437. {
  438.   Reset_Display ();
  439. }
  440.  
  441. void Clear_Playing_Area ();
  442.  
  443. void Refresh_Player_Names ()
  444. /* Redraws the player names.  Useful in case one of the players has changed
  445.    position. */
  446. {
  447.   if ((display_mode != BIDDING_DISPLAY) && (display_mode != PLAYING_DISPLAY))
  448.     return;
  449.  
  450.   if (display_mode == BIDDING_DISPLAY) {
  451.     Clear_Bidding_Board ();
  452.     Redraw_Bidding_Display ();
  453.   } else {
  454.     Clear_Playing_Area ();
  455.     Redraw_Playing_Display ();
  456.   }
  457.  
  458. }
  459.  
  460. void Set_Display_Mode (mode)
  461.      int mode;
  462. {
  463.   if (display_mode == mode)
  464.     return;
  465.  
  466.   display_mode = mode;
  467.  
  468.   if ((mode == HELP_DISPLAY) || (mode == MANUAL_DISPLAY)) {
  469.     clear_screen ();
  470.     Suspend_Comment_Display ();
  471.     status_loc = terminal_lines;
  472.     return;
  473.   }
  474.  
  475.   if (display_mode == TALK_DISPLAY)
  476.     Select_Talk_Mode ();
  477.   else
  478.     Select_Conversation_Mode ();
  479.  
  480.   Refresh_Display ();
  481. }
  482.  
  483. void Display_Tricks_Taken ()
  484. {
  485.   sprintf (line_buf,"%5d   %5d",
  486.        Local_play->tricks[SIDE_NS], Local_play->tricks[SIDE_EW]);
  487.   print (YMIN(scores)+2,XMIN(scores)+8, line_buf);
  488. }
  489.  
  490. void Format_IMP_string (score, buf)
  491.      int score; char *buf;
  492. {
  493.   int whole, fraction;
  494.  
  495.  
  496.   if ((-95 < score) && (score < 0)) {
  497.     score = (score - 5) / 10;
  498.     sprintf (buf, " -0.%d", -score);
  499.     return;
  500.   } else if (score < 0) {
  501.     score = (score - 5) / 10;
  502.     fraction = (-score) % 10;
  503.     whole = -((-score) / 10);
  504.   } else {
  505.     score = (score + 5) / 10;
  506.     fraction = score % 10;
  507.     whole = score / 10;
  508.   }
  509.  
  510.   if (fraction == 0)
  511.     sprintf (buf, "%4d. ", whole);
  512.   else
  513.     sprintf (buf, "%4d.%d", whole, fraction);
  514. }
  515.  
  516. void Display_Above_Line_Points ()
  517. {
  518.   char ew_buf[10], ns_buf [10];
  519.  
  520.   if (Local_board->scoring_mode == IMP_SCORING) {
  521.     Format_IMP_string (Local_table->above_line[SIDE_NS], ns_buf);
  522.     Format_IMP_string (Local_table->above_line[SIDE_EW], ew_buf);
  523.     sprintf (line_buf,"%6s  %6s", ns_buf, ew_buf);
  524.   } else if (Local_board->scoring_mode == MP_SCORING) {
  525.     sprintf (line_buf, "%5.2f  %6.2f", 
  526.          ((float) Local_table->above_line[SIDE_NS]) * 0.01,
  527.          ((float) Local_table->above_line[SIDE_EW]) * 0.01);
  528.   } else
  529.     sprintf (line_buf,"%5d   %5d",
  530.          Local_table->above_line[SIDE_NS], 
  531.          Local_table->above_line[SIDE_EW]);
  532.  
  533.   print (YMIN(scores)+4,XMIN(scores)+8, line_buf);
  534. }
  535.  
  536. void Display_Below_Line_Points ()
  537. {
  538.   char ew_buf[10], ns_buf [10];
  539.  
  540.   if (Local_board->scoring_mode == IMP_SCORING) {
  541.     Format_IMP_string (Local_table->below_line[SIDE_NS], ns_buf);
  542.     Format_IMP_string (Local_table->below_line[SIDE_EW], ew_buf);
  543.     sprintf (line_buf,"%6s  %6s", ns_buf, ew_buf);
  544.   } else if (Local_board->scoring_mode == MP_SCORING) {
  545.     sprintf (line_buf, "%5.2f  %6.2f", 
  546.          ((float) Local_table->below_line[SIDE_NS]) * 0.01,
  547.          ((float) Local_table->below_line[SIDE_EW]) * 0.01);
  548.   } else
  549.     sprintf (line_buf,"%5d   %5d",
  550.          Local_table->below_line[SIDE_NS], 
  551.          Local_table->below_line[SIDE_EW]);
  552.  
  553.   print (YMIN(scores)+5,XMIN(scores)+8, line_buf);
  554. }
  555.  
  556. void Display_Vulnerabilities   ()
  557. {
  558.   char *nsv, *ewv;
  559.  
  560.   if (Local_board->vulnerable[SIDE_NS]) 
  561.     nsv = "  YES";
  562.   else
  563.     nsv = "   NO";
  564.  
  565.   if (Local_board->vulnerable[SIDE_EW]) 
  566.     ewv = "  YES";
  567.   else
  568.     ewv = "   NO";
  569.  
  570.   sprintf (line_buf, "%s   %s",nsv,ewv);
  571.   print (YMIN(scores)+3, XMIN(scores)+8, line_buf);
  572. }
  573.  
  574. void Clear_Bidding_Board ()
  575. {
  576.   int x, y, h, w;
  577.  
  578.   x = XMIN(bidding_board);
  579.   y = YMIN(bidding_board);
  580.   h = HEIGHT(bidding_board);
  581.   w = WIDTH(bidding_board);
  582.   clear_screen_area (y, x, h, w);
  583.   clear_screen_area (PLAY_ROW, 1, 1, 10);
  584.  
  585. }
  586.  
  587. void Refresh_Time_Display ()
  588. {
  589.   if ((display_mode != PLAYING_DISPLAY) && (display_mode != BIDDING_DISPLAY))
  590.     return;
  591.  
  592.   print (PLAY_ROW,   80 - strlen(total_time_buffer), total_time_buffer);
  593.   print (PLAY_ROW+1, 80 - strlen(local_time_buffer), local_time_buffer);
  594. }
  595.  
  596. void Display_Total_Time (total_buf, local_buf)
  597.      char *total_buf, *local_buf;
  598. {
  599.   sprintf (total_time_buffer, "%s", total_buf);
  600.   sprintf (local_time_buffer, "%s", local_buf);
  601.   Refresh_Time_Display ();
  602. }
  603.  
  604. void Display_Bidding_Board ()
  605. /* The bidding display is given as four columns, similar to that found
  606.    in many bridge books.  At the top of each column is printed the
  607.    corresponding input parameter string to identify the bidder. */
  608. {
  609.   char *first, *second, *third, *fourth;
  610.   
  611.   Clear_Bidding_Board ();
  612.   
  613.   first  = PLAYER_NAME(Local_table, PLAYER_NORTH);
  614.   second = PLAYER_NAME(Local_table, player_next[PLAYER_NORTH]);
  615.   third  = PLAYER_NAME(Local_table, player_partner[PLAYER_NORTH]);
  616.   fourth = PLAYER_NAME(Local_table, player_prev[PLAYER_NORTH]);
  617.   
  618.   print(YMIN(bidding_board), XMIN(bidding_board)+05, first);
  619.   print(YMIN(bidding_board), XMIN(bidding_board)+15, second);
  620.   print(YMIN(bidding_board), XMIN(bidding_board)+25, third);
  621.   print(YMIN(bidding_board), XMIN(bidding_board)+35, fourth);
  622.   
  623.   underline(YMIN(bidding_board),XMIN(bidding_board)+05,strlen(first));
  624.   underline(YMIN(bidding_board),XMIN(bidding_board)+15,strlen(second));
  625.   underline(YMIN(bidding_board),XMIN(bidding_board)+25,strlen(third));
  626.   underline(YMIN(bidding_board),XMIN(bidding_board)+35,strlen(fourth));
  627.  
  628.   Display_Board_Number ();
  629. }
  630.  
  631. static void Display_suit (y, x, cards)
  632.      int y, x; suit_type cards;
  633. /* Displays the cards in a given suit held by a player.  As input,
  634.  * cards[] is an array of 13 elements, where cards[i] is TRUE if the
  635.  * player holds the given card.  Displays the cards as a string on
  636.  * the terminal, beginning at coordinates <y,x>.
  637.  */
  638. {
  639.   int i;
  640.  
  641.   for (i = 12; i >= 0; i--)
  642.     if (cards[i])
  643.       print (y, x++, rank_names[i]);
  644. }
  645.  
  646. void Display_Hand_for_Bidding (pos, h)
  647.      int pos; hand h;
  648. {
  649.   int i, x, y;
  650.   
  651.   if (pos >= 4) return;
  652.   
  653.   y = YMIN(bidding_board);
  654.   x = XMIN(bidding_board) + 45;
  655.   clear_screen_area (y, x, HEIGHT(bidding_board), XMAX(bidding_board)-x+1);
  656.   for (i = 0; i < 6; i++)
  657.     print (y+i, x, "|");
  658.   
  659.   x+=1;
  660.   print (y, x, PLAYER_NAME(Local_table, pos));
  661.   underline (y, x, strlen(PLAYER_NAME(Local_table, pos)));
  662.   print (y+2, x, "S "); Display_suit (y+2, x+2, h+39);
  663.   print (y+3, x, "H "); Display_suit (y+3, x+2, h+26);
  664.   print (y+4, x, "D "); Display_suit (y+4, x+2, h+13);
  665.   print (y+5, x, "C "); Display_suit (y+5, x+2, h);
  666. }
  667.  
  668. void Clear_Bidder ()
  669. {
  670.   clear_screen_area (YMIN(title)+2, XMIN(title), 1, 20);
  671. }
  672.  
  673. void Display_Bidder (player)
  674.     int player;
  675. {
  676.   char bid_buf[80];
  677.  
  678.   sprintf (bid_buf, "(%c) %s's BID        ", *("NESW" + player),
  679.        PLAYER_NAME(Local_table, player));
  680.          
  681.   print (YMIN(title)+2, XMIN(title), bid_buf);
  682. }
  683.  
  684. void Display_Bid (k)
  685.      int k;
  686. /* Displays the k-th bid in the bidding list. */
  687. {
  688.   int i, x, y, bid, position, round, player;
  689.   char bid_string [10];
  690.   
  691.   round = (k / 4) + 1;
  692.   bid = Local_play->bids[k];
  693.   player = k % 4;
  694.   for (i = 0; i != Local_board->dealer; i++)
  695.     player = player_next[player];
  696.   
  697.   y = YMIN(bidding_board) + round + 1;
  698.   sprintf (line_buf, " %2d", round);
  699.   print (y, XMIN(bidding_board), line_buf);
  700.   
  701.   y++; 
  702.   for (x = Local_board->dealer; x < 4; x++)
  703.     if (x == player) y--;
  704.   
  705.   position = player;
  706.   x = XMIN(bidding_board) + 10 * position + 5;
  707.   if (bid == BID_PASS)
  708.     sprintf (bid_string, "--");
  709.   else
  710.     sprintf (bid_string, "%s", bid_names[bid]);
  711.   if (Local_play->alerts[k])
  712.     sprintf (bid_string + strlen(bid_string)," !");
  713.   
  714.   print (y, x, bid_string);
  715. }
  716.  
  717. void Display_Contract ()
  718. {
  719.   char double_buf[40], contract_buf[60];
  720.   int trump_suit = trumpsuit_of (Local_play->contract);
  721.   int contract   = level_of (Local_play->contract);
  722.  
  723.   if (Local_play->contract == BID_PASS) {
  724.     print (YMIN(title)+3, XMIN(title), "PASSED HAND");
  725.     return;
  726.   }
  727.  
  728.   clear_screen_area (YMIN(title)+2, XMIN(title), HEIGHT(title),
  729.                WIDTH(title));
  730.   if (Local_play->doubled == 2)
  731.     sprintf (double_buf,"  REDOUBLED");
  732.   else if (Local_play->doubled == 1)
  733.     sprintf (double_buf, "  DOUBLED");
  734.   else
  735.     double_buf[0] = '\0';
  736.   sprintf (contract_buf, "%1d%s (%s)%s",contract,suit_names[trump_suit],
  737.        PLAYER_NAME(Local_table, Local_play->declarer), double_buf);
  738.  
  739.   print (YMIN(title)+3, XMIN(title), contract_buf);
  740. }
  741.  
  742. void Clear_Playing_Area () 
  743. {
  744.   clear_screen_area (YMIN(playing_board), XMIN(playing_board),
  745.              HEIGHT(playing_board), WIDTH(playing_board));
  746.   clear_screen_area (YMIN(left_hand), XMIN(left_hand),
  747.              HEIGHT(left_hand), WIDTH(left_hand));
  748.   clear_screen_area (YMIN(right_hand), XMIN(right_hand),
  749.              HEIGHT(right_hand), WIDTH(right_hand));
  750.   clear_screen_area (YMIN(top_hand), XMIN(top_hand),
  751.              HEIGHT(top_hand), WIDTH(top_hand));
  752.   clear_screen_area (YMIN(bottom_hand), XMIN(bottom_hand),
  753.              HEIGHT(bottom_hand), WIDTH(bottom_hand));
  754.   clear_screen_area (YMIN(title)+3, XMIN(title), 1, WIDTH(title));
  755.   
  756. }
  757.  
  758. void Clear_Playing_Board ()
  759. {
  760.   Clear_Playing_Area ();
  761.  
  762.   Current_trick[0] = Current_trick[1] = 
  763.     Current_trick[2] = Current_trick[3] = -1;
  764. }
  765.  
  766. void Display_Playing_Board ()
  767. {
  768.   int i;
  769.   
  770.   for (i = 0; i < 4; i++)
  771.     print (PLAYERHAND_Y[i]+1, PLAYERHAND_X[i]+12 -
  772.        strlen(PLAYER_NAME(Local_table, i)), PLAYER_NAME(Local_table, i));
  773.   
  774.   for (i = 0; i < WIDTH(playing_board)-1; i++) line_buf[i] = '-';
  775.   line_buf[WIDTH(playing_board)-2] = '\0';
  776.   print (YMIN(playing_board)+1,XMIN(playing_board)+1,line_buf);
  777.   print (YMAX(playing_board)-1,XMIN(playing_board)+1,line_buf);
  778.   
  779.   for (i = YMIN(playing_board)+2; i < YMAX(playing_board)-1; i++) {
  780.     print (i, XMIN(playing_board)+1, "|");
  781.     print (i, XMAX(playing_board)-1, "|");
  782.   }
  783. }
  784.  
  785. void Display_Player (player)
  786.      int player;
  787. {
  788.   char play_buf[80];
  789.   
  790.   if (player < 0)
  791.     sprintf (play_buf, "                    ");
  792.   else if (player == player_partner[Local_play->declarer])
  793.     sprintf (play_buf, "DUMMY'S PLAY        ");
  794.   else
  795.     sprintf (play_buf, "(%c) %s's PLAY        ", 
  796.          *("NESW" + player), PLAYER_NAME(Local_table, player));
  797.   print (YMIN(title)+4, XMIN(title), play_buf);
  798. }
  799.  
  800. void Display_Play (p, card)
  801.      int p, card;
  802. {
  803.   int x, y;
  804.   
  805.   y = CARDPOS_Y [p];
  806.   x = CARDPOS_X [p];
  807.   if ((0 <= card) && (card < 52))
  808.     print (y, x, card_names[card]);
  809.   else
  810.     print (y, x, "   ");
  811.   
  812.   Current_trick [p] = card;
  813. }
  814.  
  815. void Clear_Plays  ()
  816. {
  817.   Display_Play (PLAYER_NORTH, -1);
  818.   Display_Play (PLAYER_EAST,  -1);
  819.   Display_Play (PLAYER_SOUTH, -1);
  820.   Display_Play (PLAYER_WEST,  -1);
  821. }
  822.  
  823. void Display_Partial_Hand (p, no_plays)
  824.      int p; int no_plays;
  825. {
  826.   int y, x, i;
  827.   hand h;
  828.   
  829.   if (IS_OBSERVER(p))
  830.     return;
  831.   
  832.   y = PLAYERHAND_Y [p];
  833.   x = PLAYERHAND_X [p];
  834.   for (i = 0; i < 4; i++)
  835.     print (y+i, x, "                   ");
  836.   
  837.   Generate_holdings (Local_board, Local_play->play_list, no_plays, p, h);
  838.   print (y,   x+5-8, "        ");
  839.   print (y,   x+5-strlen(PLAYER_NAME(Local_table, p)), 
  840.      PLAYER_NAME(Local_table, p));
  841.   if (p == player_partner[Local_play->declarer])
  842.     print (y+1, x+5-7, "(DUMMY)");
  843.   print (y,   x+7, "S "); Display_suit (y,   x+10, h+39);
  844.   print (y+1, x+7, "H "); Display_suit (y+1, x+10, h+26);
  845.   print (y+2, x+7, "D "); Display_suit (y+2, x+10, h+13);
  846.   print (y+3, x+7, "C "); Display_suit (y+3, x+10, h);
  847.   
  848.   revealed_hands[p] = 1;
  849. }
  850.  
  851. void Display_Hand (p)
  852.      int p;
  853. {
  854.   Display_Partial_Hand (p, Local_play->no_plays);
  855. }
  856.  
  857. void Clear_Hand (p)
  858.      int p;
  859. {
  860.   int y, x, i;
  861.   
  862.   y = PLAYERHAND_Y [p];
  863.   x = PLAYERHAND_X [p];
  864.   for (i = 0; i < 4; i++)
  865.     print (y+i, x, "                   ");
  866.   
  867.   print (y,   x+5-strlen(PLAYER_NAME(Local_table, p)), 
  868.      PLAYER_NAME(Local_table, p));
  869.   if (p == player_partner[Local_play->declarer])
  870.     print (y+1, x+5-7, "(DUMMY)");
  871.   
  872.   revealed_hands[p] = 0;
  873. }
  874.  
  875. static char *seat_letters [4] = {"N", "E", "S", "W"};
  876. static char *double_names [3] = {"", "-X", "-XX"};
  877.  
  878. static void Display_Score_Record (b, p, line)
  879.      Board *b;
  880.      Play_record *p;
  881.      int line;
  882. {
  883.   char contract_buf[10];
  884.   char buf[100];
  885.   char mark;
  886.  
  887.   if (p->contract == BID_PASS)
  888.     sprintf (contract_buf, "PASSED");
  889.   else
  890.     sprintf (contract_buf, "%s%s", bid_names[p->contract], 
  891.          double_names[p->doubled]);
  892.  
  893.   if (!strcasecmp(p->player_names[PLAYER_NORTH], local_player_name) ||
  894.       !strcasecmp(p->player_names[PLAYER_SOUTH], local_player_name))
  895.     mark = '>';
  896.   else
  897.     mark = ' ';
  898.  
  899.   sprintf (buf,
  900.        "  %c   N %-8s S %-8s %-8s %-2s %+6d %6d %6.1f %6.2f", mark,
  901.        p->player_names[PLAYER_NORTH], p->player_names[PLAYER_SOUTH],
  902.        contract_buf, seat_letters[p->declarer], p->result,
  903.        p->below_line[SIDE_NS], 
  904.        p->imatch_points[SIDE_NS],
  905.        p->match_points[SIDE_NS]);
  906.   print (line, 1, buf);
  907.  
  908.   if (!strcasecmp(p->player_names[PLAYER_EAST], local_player_name) ||
  909.       !strcasecmp(p->player_names[PLAYER_WEST], local_player_name))
  910.     mark = '>';
  911.   else
  912.     mark = ' ';
  913.  
  914.   sprintf (buf,
  915.        "  %c   E %-8s W %-8s %-8s %2s %6s %6d %6.1f %6.2f", mark,
  916.        p->player_names[PLAYER_EAST], p->player_names[PLAYER_WEST],
  917.        " ", " ", " ", p->below_line[SIDE_EW],
  918.        p->imatch_points[SIDE_EW],
  919.        p->match_points[SIDE_EW]);
  920.   print (line+1, 1, buf);
  921. }
  922.  
  923. void Display_Page_of_Scores (p)
  924.      Play_record *p;
  925. /* Displays a page of scores, starting with the play record p.  Sets the
  926.    variable Current_page_of_scores equal to p, and the variable 
  927.    Next_page_of_scores equal to the first undisplayed record.
  928. */
  929. {
  930.   char buf[100];
  931.   char *vul_string;
  932.   int line = 5;
  933.   Board *b = Board_for_display;
  934.  
  935.   clear_screen_area (1, 1, 15, 80);
  936.  
  937.   Current_page_of_scores = Next_page_of_scores = p;
  938.  
  939.   if (b->vulnerable[SIDE_NS] && b->vulnerable[SIDE_EW])
  940.     vul_string = "BOTH";
  941.   else if (b->vulnerable[SIDE_NS])
  942.     vul_string = "N-S";
  943.   else if (b->vulnerable[SIDE_EW])
  944.     vul_string = "E-W";
  945.   else
  946.     vul_string = "NONE";
  947.  
  948.   sprintf (buf, "%s BOARD %d", b->source, b->serial_no);
  949.   print (1, 78 - strlen(buf), buf);
  950.  
  951.   switch (b->scoring_mode) {
  952.   case RUBBER_SCORING:
  953.     print (1, 1, "RUBBER BRIDGE");
  954.     break;
  955.   case DUPLICATE_SCORING:
  956.     print (1, 1, "DUPLICATE BRIDGE");
  957.     break;
  958.   case MP_SCORING:
  959.     print (1, 1, "MATCH POINTS");
  960.     break;
  961.   case IMP_SCORING:
  962.     print (1, 1, "INTL MATCH POINTS");
  963.     break;
  964.   }
  965.  
  966.   sprintf (buf, "DEALER %s, VUL %s", seat_names[b->dealer], vul_string);
  967.   print (2, 1, buf);
  968.  
  969.   sprintf (buf, "%5s %21s %-8s %-2s %6s %6s %6s %6s", " ", " ",
  970.        "CONTRACT", "BY", "RESULT", "SCORE", "IMPS", "MPS");
  971.   print (4, 1, buf);
  972.  
  973.   while ((line < 15) && (Next_page_of_scores != NULL)) {
  974.     Display_Score_Record (b, Next_page_of_scores, line);
  975.     line += 3;
  976.     Next_page_of_scores = Next_page_of_scores->next;
  977.   }
  978.  
  979. }
  980.  
  981. void Display_First_Page_of_Scores (b)
  982.      Board *b;
  983. /* Initiales the scoring display and displays the first page of results from
  984.  * board b. 
  985.  */
  986. {
  987.   if ((b->play_records == NULL) || (b->play_records->next == NULL)) {
  988.     Next_page_of_scores = Current_page_of_scores = NULL;
  989.     return;
  990.   }
  991.  
  992.   Board_for_display = b;
  993.   Set_Display_Mode (SCORING_DISPLAY);
  994.   Set_Input_Mode (TALK_INPUT);
  995.  
  996.   Display_Page_of_Scores (b->play_records);
  997. }
  998.  
  999. int More_Scores_to_Display ()
  1000. /* int More_Scores_to_Display (void); */
  1001. /* Returns true if not all of the results have been displayed from the
  1002.  * board which is currently being displayed. 
  1003.  */
  1004. {
  1005.   return (Next_page_of_scores != NULL);
  1006. }
  1007.  
  1008. void Display_More_Scores ()
  1009. /* void Display_More_Scores (void); */
  1010. /* Displays the next page of scores for the board b. */
  1011. {
  1012.   Display_Page_of_Scores (Next_page_of_scores);
  1013. }
  1014.  
  1015.  
  1016.  
  1017. static void Save_Status_Message (message)
  1018.      char *message;
  1019. /* Saves the given message into the status display buffer at the
  1020.    current level of locking. */
  1021. {
  1022.   int i;
  1023.  
  1024.   for (i = 0; (i < WIDTH(status)) && (message[i] != '\0'); i++)
  1025.     status_buf[status_display_level][i] = message[i];
  1026.   status_buf[status_display_level][i] = '\0';
  1027. }
  1028.  
  1029. void Status (message)
  1030.      char *message;
  1031. {
  1032.   if (status_display_level > 0) {
  1033.     Moderator_Comment (message);
  1034.     return;
  1035.   }
  1036.  
  1037.   Clear_Status ();
  1038.   Save_Status_Message (message);
  1039.   Refresh_Status_Display ();
  1040. }
  1041.  
  1042. void Clear_Status ()
  1043. {
  1044.   if (status_display_level > 0)
  1045.     return;
  1046.  
  1047.   clear_screen_area (status_loc, XMIN(status), 1, WIDTH(status));
  1048.   status_buf [0][0] = '\0';
  1049. }
  1050.  
  1051. void Lock_Status (message)
  1052.      char *message;
  1053. /* Locks the status display.  This prevents the current message from being
  1054.    erased from the display.  If a new request to Status is made, that
  1055.    message is displayed as a moderator comment instead.
  1056. */
  1057. {
  1058.   status_display_level += 1;
  1059.   Save_Status_Message (message);
  1060.   Refresh_Status_Display ();
  1061. }
  1062.  
  1063. void Unlock_Status ()
  1064. /* Unlocks the status display. */
  1065. {
  1066.   if (status_display_level > 0)
  1067.     status_display_level -= 1;
  1068.   Refresh_Status_Display ();
  1069. }
  1070.  
  1071. void Reset_Status ()
  1072. /* Resets the status display. */
  1073. {
  1074.   status_display_level = 0;
  1075.   Clear_Status ();
  1076. }
  1077.  
  1078. void Refresh_Status_Display ()
  1079. {
  1080.   clear_screen_area (status_loc, XMIN(status), 1, WIDTH(status));
  1081.   print (status_loc, XMIN(status), status_buf[status_display_level]);
  1082.   set_cursor 
  1083.     (status_loc, XMIN(status) + strlen(status_buf[status_display_level]) + 1);
  1084. }
  1085.  
  1086. /* The bottom part of the screen is used for the exchange of comments
  1087.    between the players.  The following procedures are used for managing
  1088.    this part of the display. */
  1089.  
  1090.  
  1091. static void blank_out_comment (c)
  1092.      comment_line c;
  1093. {
  1094.   int i;
  1095.  
  1096.   for (i = 0; i < COMMENT_LENGTH-1; i++) c[i] = ' ';
  1097.   c[COMMENT_LENGTH-1] = '\0';
  1098. }
  1099.  
  1100. static void copy_string_to_comment (c, s)
  1101.      comment_line c; char *s;
  1102. {
  1103.   int i;
  1104.  
  1105.   blank_out_comment(c);
  1106.   i = 0;
  1107.   while ((s[i] != '\0') && (i < COMMENT_LENGTH-1)) {
  1108.     c[i] = s[i]; 
  1109.     i++; 
  1110.   }
  1111.  
  1112. }
  1113.  
  1114. static void scroll_player_comments ()
  1115. {
  1116.   int i;
  1117.  
  1118.   for (i = 0; i < playing_screen_talk_size-1; i++)
  1119.     bcopy (playing_screen_comments[i+1], playing_screen_comments[i], 
  1120.        sizeof(comment_line));
  1121.   blank_out_comment (playing_screen_comments[playing_screen_talk_size-1]);
  1122. }
  1123.  
  1124. void Select_Conversation_Mode ()
  1125. {
  1126.   talk_start = playing_screen_talk_start;
  1127.   talk_end   = playing_screen_talk_end;
  1128.   talk_size  = playing_screen_talk_size;
  1129.   player_comments = playing_screen_comments;
  1130. }
  1131.  
  1132. void Select_Talk_Mode ()
  1133. {
  1134.   talk_start = full_screen_talk_start;
  1135.   talk_end   = full_screen_talk_end;
  1136.   talk_size  = full_screen_talk_size;
  1137.   player_comments = full_screen_comments;
  1138. }
  1139.  
  1140. void Refresh_Player_Comments ()
  1141. {
  1142.   int i;
  1143.  
  1144.   if (comments_suspended)
  1145.     return;
  1146.  
  1147.   for (i = 0; i < talk_size; i++)
  1148.     print (talk_start+i, 2, player_comments[i]);
  1149. }
  1150.  
  1151. void Clear_Comment_Display ()
  1152. {
  1153.   int i;
  1154.  
  1155.   for (i = 0; i < full_screen_talk_size; i++)
  1156.     blank_out_comment (full_screen_comments + i);
  1157.   for (i = 0; i < playing_screen_talk_size; i++)
  1158.     blank_out_comment (playing_screen_comments + i);
  1159.  
  1160.   full_screen_cursor = 0;
  1161.   Refresh_Player_Comments ();
  1162. }
  1163.  
  1164. void Initialize_Player_Comments ()
  1165. {
  1166.   int i, m, n;
  1167.   
  1168.   full_screen_talk_end = terminal_lines - 3;
  1169.   playing_screen_talk_end = terminal_lines;
  1170.   
  1171.   n = full_screen_talk_end - full_screen_talk_start + 1;
  1172.   m = playing_screen_talk_end - playing_screen_talk_start + 1;
  1173.   if (n <= 0)
  1174.     n = 1;
  1175.   else if (m <= 0)
  1176.     m = 1;
  1177.   
  1178.   full_screen_comments = (comment_line *) 
  1179.     malloc (n * sizeof(comment_line));
  1180.   
  1181.   playing_screen_comments = (comment_line *)
  1182.     malloc (m * sizeof(comment_line));
  1183.   
  1184.   for (i = 0; i < n; i++)
  1185.     blank_out_comment (full_screen_comments[i]);
  1186.   for (i = 0; i < m; i++)
  1187.     blank_out_comment (playing_screen_comments[i]);
  1188.   
  1189.   full_screen_cursor = 0;
  1190.   full_screen_talk_size = n;
  1191.   playing_screen_talk_size = m;
  1192.  
  1193.   if (display_mode == TALK_DISPLAY)
  1194.     Select_Talk_Mode ();
  1195.   else
  1196.     Select_Conversation_Mode ();
  1197. }
  1198.  
  1199. void Reinitialize_Player_Comments ()
  1200. {
  1201.   Initialize_Player_Comments ();
  1202. }
  1203.  
  1204. void Display_Player_Comment (comment_level, player_name, comment)
  1205.      int comment_level; char *player_name, *comment;
  1206. {
  1207.   char message_buf [200];
  1208.   char level_id;
  1209.   
  1210.   switch (comment_level) {
  1211.   case COMMENT_PRIVATE: level_id = '-'; break;
  1212.   case COMMENT_FORMAL:  level_id = '='; break;
  1213.   case COMMENT_PUBLIC:  level_id = ':'; break;
  1214.   default:              level_id = '*';
  1215.   }
  1216.   
  1217.   sprintf (message_buf, "%s%c %s", player_name, level_id, comment);
  1218.   
  1219.   copy_string_to_comment (full_screen_comments[full_screen_cursor], 
  1220.               message_buf);
  1221.   if (full_screen_cursor < full_screen_talk_size - 1)
  1222.     full_screen_cursor++;
  1223.   else
  1224.     full_screen_cursor = 0;
  1225.   blank_out_comment (full_screen_comments[full_screen_cursor]);
  1226.  
  1227.   scroll_player_comments ();
  1228.   copy_string_to_comment 
  1229.     (playing_screen_comments[playing_screen_talk_size-1], message_buf);
  1230.  
  1231.   Refresh_Player_Comments ();
  1232. }
  1233.  
  1234. void Moderator_Comment (msg)
  1235.      char *msg;
  1236. {
  1237.   Display_Player_Comment (COMMENT_PUBLIC, "MODERATOR", msg);
  1238. }
  1239.  
  1240. void Network_Comment (msg)
  1241.      char *msg;
  1242. {
  1243.   Display_Player_Comment (COMMENT_PRIVATE, "NETWORK", msg);
  1244. }
  1245.  
  1246. void Suspend_Comment_Display ()
  1247. {
  1248.   comments_suspended = 1;
  1249. }
  1250.  
  1251. void Continue_Comment_Display ()
  1252. {
  1253.   comments_suspended = 0;
  1254. }
  1255.  
  1256.  
  1257. void Begin_full_screen_talk_mode ()
  1258. {
  1259.   int i;
  1260.  
  1261.   Select_Talk_Mode ();
  1262.   
  1263.   for (i = 0; i <= XMAX(converse); i++) line_buf[i] = '-';
  1264.   line_buf[XMAX(converse)+1] = '\0';
  1265.   print (full_screen_talk_start-1, 1, line_buf);
  1266.   line_buf[72] = '+';
  1267.   print (full_screen_talk_end+1, 1, line_buf);
  1268.   for (i = 1; i < XMAX(converse); i++) line_buf[i] = ' ';
  1269.   line_buf[0] = line_buf[XMAX(converse)] = '|';
  1270.   for (i = full_screen_talk_start; i <= full_screen_talk_end; i++)
  1271.     print (i, 1, line_buf);
  1272.   
  1273.   Refresh_Player_Comments ();
  1274.   
  1275.   /* setup the talk buffer: */
  1276.   
  1277.   print (terminal_lines-1, 1, "TALK");
  1278.   status_loc = terminal_lines;
  1279. }
  1280.  
  1281. void End_full_screen_talk_mode ()
  1282. {
  1283.   Select_Conversation_Mode ();
  1284.   status_loc = YMIN(status);
  1285.   Refresh_Display ();
  1286. }
  1287.