home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 October / usenetsourcesnewsgroupsinfomagicoctober1994disk2.iso / games / volume8 / mgt / part01 / ascii.c next >
C/C++ Source or Header  |  1990-02-23  |  11KB  |  554 lines
  1. /*
  2.  
  3.         "mgt" Copyright 1990 Shodan
  4.         All Rights Reserved.
  5.         Program by Greg Hale
  6.  
  7. Permission to use, copy, modify, and distribute this software and its
  8. documentation for any purpose and without fee is hereby granted,
  9. provided that this entire comment and copyright notice appear in all
  10. copies and that both that copyright notice and this permission notice
  11. appear in supporting documentation.  No representations are made about
  12. the suitability of this software for any purpose.  It is provided "as
  13. is" without express or implied warranty.
  14.  
  15. Please send copies of extensions to:
  16.  
  17. hale@scam.berkeley.edu
  18. 128.32.138.4    scam.berkeley.edu sting sting.Berkeley.EDU
  19.  
  20. Donations for the 'From My Go Teacher' series may be sent to:
  21.     Shodan
  22.     P.O. Box 4456
  23.     Berkeley, CA 94704
  24.     (415) 849-9475
  25.  
  26. */
  27.  
  28. #include <sys/time.h>
  29. #include <curses.h>
  30. #include <ctype.h>
  31. #include "mgt.h"
  32. #include "ascii.h"
  33. #include "var.h"
  34. #include "file.h"
  35.  
  36.  
  37. #define TOP 2
  38. #define LEFT 4
  39.  
  40. #define ASCII_ENV_STR "_ASCII="
  41. #define COMMENT_X 46
  42. #define COMMENT_Y 1
  43. #define COMMENT_WIDE (79-COMMENT_X)
  44. #define COMMENT_HIGH (14-COMMENT_Y)
  45.  
  46. #define TREE_X COMMENT_X
  47. #define TREE_Y 15
  48. #define TREEWIDE (79-TREE_X)
  49. #define TREEHIGH 6
  50.  
  51. #define COMMAND_X TREE_X
  52. #define COMMAND_Y TREE_Y+TREEHIGH
  53.  
  54. enum { s_comment };
  55.  
  56. boolean commentExists;
  57. int commentLine;
  58. int treeLine;
  59.  
  60.  
  61. char envAscii[]="q><.,ebcx][gnpui@O.+";
  62.  
  63.  
  64. char *xAxisChars = "ABCDEFGHJKLMNOPQRSTUVWXYZ";
  65.  
  66.  
  67. FUNCTION void printCmdSet()
  68. {
  69.     commandIndex i;
  70.     mvaddstr(COMMAND_Y,COMMAND_X,"Commands:");
  71.     for (i=ASC_QUIT; i!= ASC_CHAR_BLACK; i++) {
  72.         mvaddch(COMMAND_Y,i+COMMAND_X+sizeof("Commands"),envAscii[i]);
  73.     }
  74.     refresh();
  75. }
  76.  
  77. FUNCTION int notifyMessageAscii(s)
  78. char *s;
  79. {
  80.     mvaddstr(23,1,s);
  81.     refresh();
  82. }
  83.  
  84. FUNCTION int notifyClearAscii()
  85. {
  86.     move(23,1);
  87.     clrtoeol();
  88. }
  89.  
  90. FUNCTION int getLine(query,dst,maxLen) /* char *, char *, int */
  91. char *query, *dst;
  92. int maxLen;
  93. {
  94.     int qLen, dLen;
  95.     char c;
  96.     mvaddstr(23,1,query);
  97.     clrtoeol();
  98.     dLen = 0;
  99.     qLen = strlen(query);
  100.     do {
  101.         move(23,qLen+1+dLen);
  102.         refresh();
  103.         c = getKey();
  104.         if (isprint(c) && dLen < maxLen) {
  105.             mvaddch(23,qLen+dLen+1,c);
  106.             dst[dLen++] = c;
  107.         } else if (dLen && (c=='\b' || c=='\177')) {
  108.             dLen--;
  109.             mvaddch(23,qLen+dLen+1,' ');
  110.         }
  111.     } while (c != '\n' && c != '\r');
  112.     dst[dLen]=0;
  113.     move(23,1);
  114.     clrtoeol();
  115.     return dLen;
  116. }
  117.  
  118. /*
  119.  * draw the tree children when node currently is at n
  120.  */
  121. FUNCTION int drawTreeAscii(n)
  122. nodep n;
  123. {
  124.     treeLine = 0;
  125.     drawTreeAscii0(n);
  126. }
  127.  
  128. FUNCTION void printNStr(s,n)
  129. char *s;
  130. int n;
  131. {
  132.     int i;
  133.     for (i=0; i<n && s[i]; i++)
  134.         addch(s[i]);
  135. }
  136.  
  137.  
  138. FUNCTION int drawTreeAscii0(n)
  139. nodep n;
  140. {
  141.     property *p;
  142.  
  143.     move(TREE_Y,TREE_X+1);
  144.     printw(" Node #%d:",n->nodeNum);
  145.     if (p = getprop(n,t_Name))
  146.         printNStr(p->d, 22);
  147.     clrtoeol();
  148.     {
  149.         int temp;
  150.         if (treeLine < 0)
  151.             treeLine = 0;
  152.         else {
  153.             temp = treeCountSiblings(n) - TREEHIGH+1;
  154.             temp = MAX(temp,0);
  155.             treeLine = treeLine > temp ? temp : treeLine; 
  156.         }
  157.     }
  158.     {
  159.         nodep ch;
  160.         int index;
  161.         index = 0;
  162.         ch = nthChild(n, treeLine, false);
  163.         while (ch && index < TREEHIGH-1) {
  164.             move(index+TREE_Y+1,TREE_X);
  165.             printw("%c:",'A'+ index + treeLine);
  166.             clrtoeol();
  167.             if (p = getprop(ch,t_Name))
  168.                 printNStr(p->d, 80-(TREE_X+3));
  169.             ch = ch->nextSibling;
  170.             index++;
  171.         }
  172.         while(index<TREEHIGH-1) {
  173.             move(index++ + TREE_Y+1,TREE_X);
  174.             clrtoeol();
  175.         }
  176.         mvaddch(TREE_Y+TREEHIGH-1,TREE_X-1,ch ? '+' : ' ');
  177.         mvaddch(TREE_Y+1,TREE_X-1,treeLine ? '-' : ' ');
  178.     }
  179.     refresh();
  180. }
  181.  
  182. FUNCTION int depthAscii(d)
  183. depthrec *d;
  184. {
  185. #if 0
  186.     int i,lim;
  187.     /* lim = d->depth > DEPTH_LIMIT-1 ? DEPTH_LIMIT-1 : d->depth;
  188.     move(INDEXLINE,0);
  189.     clrtoeol();
  190.     move(INDEXLINE,0);
  191.     for (i=0 ; i<=lim ; i++) {
  192.         printw("%d.",(int)d->d[i]);
  193.     }
  194.     refresh(); */
  195. #endif
  196. }
  197.  
  198. FUNCTION int initAscii(i)
  199. interface *i;
  200. {
  201.  
  202.     initscr();
  203.     noecho();
  204.     crmode();
  205. }
  206.  
  207. FUNCTION int closeAscii()
  208. {
  209.     clear();
  210.     refresh();
  211.     endwin();
  212. }
  213.  
  214. FUNCTION int refreshAscii()
  215. {
  216.     refresh();
  217. }
  218.  
  219.  
  220. FUNCTION char boardPiece(x,y)
  221. int x,y;
  222. {
  223.     return ((x==3 || x==9 || x == 15) && (y==3 || y==9 || y==15))
  224.         ? envAscii[(int)ASC_CHAR_HANDICAP] : envAscii[(int)ASC_CHAR_NOTHING];
  225. }
  226.  
  227.  
  228. FUNCTION int plotPieceAscii(b,i,j)
  229. pBoard b;
  230. int i,j;
  231. {
  232.     piece p;
  233.     p = boardGet(b,i,j);
  234.     mvaddch(TOP+j, LEFT + (i) * 2, p == P_NOTHING ? boardPiece(i,j) : 
  235.                             (p == P_BLACK ? envAscii[(int)ASC_CHAR_BLACK] :
  236.                             envAscii[(int)ASC_CHAR_WHITE]));
  237. }
  238.  
  239. FUNCTION int highlightAscii(x,y,movenum,turn)
  240. int x,y,movenum,turn;
  241. {
  242.     if (movenum>0 && x>=0) {
  243.         mvprintw(23,1,"%s #%d at '%c%d'  ",
  244.             turn ? "White" : "Black",
  245.             movenum,xAxisChars[x],19-y);
  246.     } else {
  247.         mvprintw(23,1,"                            ");
  248.     }
  249.     move(TOP+y, LEFT+x*2);
  250.     refresh();
  251. }
  252.  
  253. FUNCTION int setPieceAscii(b,i,j,p)
  254. pBoard b;
  255. int i,j;
  256. piece p;
  257. {
  258.     boardSet(b,i,j,p);
  259.     plotPieceAscii(b,i,j);
  260. }
  261.  
  262. FUNCTION int showCommentAscii(i)    /* display from line i onward */
  263. int i;
  264. {
  265.     short line;
  266.  
  267.     line=MIN(commentLines()-i,COMMENT_HIGH);
  268.     /* move(line+COMMENT_Y,COMMENT_X);
  269.     clrtoeol(); */
  270.  
  271.     mvaddch(COMMENT_Y,COMMENT_X-1,i ? '-' : ' ');
  272.     mvaddch(COMMENT_Y+COMMENT_HIGH-1,COMMENT_X-1,
  273.         commentLines()-i>COMMENT_HIGH? '+' : ' ');
  274.  
  275.     while (line--) {
  276.         move(line+COMMENT_Y,COMMENT_X);
  277.         printw(commentGet(line+i));
  278.         clrtoeol();
  279.     }
  280.     refresh();
  281. }
  282.  
  283. FUNCTION int clearCommentAscii()
  284. {
  285.     commentExists = false;
  286.     {
  287.         int line;
  288.         for (line = COMMENT_Y; line < COMMENT_Y+COMMENT_HIGH; line++)
  289.             move(line,COMMENT_X),clrtoeol();
  290.     }
  291.     mvaddch(COMMENT_Y,COMMENT_X-1,' ');
  292.     mvaddch(COMMENT_Y+COMMENT_HIGH-1,COMMENT_X-1, ' ');
  293. }
  294.  
  295. FUNCTION int displayCommentAscii(s)
  296. char *s;
  297. {
  298.     commentExists = true;
  299.     commentBuf = s;
  300.     commentLine = 0;
  301.     formatComment(s, COMMENT_WIDE);
  302.     showCommentAscii(0);
  303.     refresh();
  304. }
  305.  
  306. FUNCTION int clearBoardAscii(b)
  307. pBoard b;
  308. {
  309.     int i,j;
  310.     clear();
  311.     for (i = boardsize; i--;) {
  312.         /* left */
  313.         mvprintw(TOP+i,LEFT-3,"%2d|",19-i);
  314.  
  315.         /* right */
  316.         mvprintw(TOP+i,LEFT+boardsize*2-1,"|%2d|",19-i);
  317.  
  318.         /* top */
  319.         mvaddch(TOP-2,LEFT+i*2,xAxisChars[i]);
  320.         mvprintw(TOP-1,LEFT+i*2-1,"--");
  321.  
  322.         /* bottom */
  323.         mvaddch(TOP+boardsize+1,LEFT+i*2,xAxisChars[i]);
  324.         mvprintw(TOP+boardsize,LEFT+i*2-1,"--");
  325.         for (j = boardsize; j--;) {
  326.             setPieceAscii(b,i,j,P_NOTHING);
  327.         }
  328.     }
  329.     mvaddch(TOP-1,LEFT-1,'+');
  330.     mvaddch(TOP-1,LEFT+boardsize*2-1,'+');
  331.     mvaddch(TOP+boardsize,LEFT-1,'+');
  332.     mvaddch(TOP+boardsize,LEFT+boardsize*2-1,'+');
  333.     printCmdSet();
  334. }
  335.  
  336. FUNCTION commandIndex charToIndex(c)
  337. char c;
  338. {
  339.     int i;
  340.     for (i=ASC_CHAR_BLACK; i--;) {
  341.         if (c == envAscii[i])
  342.             break;
  343.     }
  344.     return i; /* -1 = not found */
  345. }
  346.  
  347. FUNCTION int idleAscii(curnode)
  348. nodep curnode;
  349. {
  350.     char c;
  351.     command r;
  352.     commandIndex i;
  353.     long mask;
  354.     struct timeval t;
  355.  
  356.     t.tv_sec = 0;
  357.     t.tv_usec = 0;
  358.  
  359.     mask = 1;
  360.     r = C_NOTHING;
  361.     highlightLast();
  362.     if (select(32,&mask,0,0,&t)>0) {
  363.         c = getKey();
  364.         if (c>='A' && c<='Z') {
  365.             r=(command)((char)C_CHOSECHILD+(c-'A'));
  366.         } else {
  367.             switch(charToIndex(c)) {
  368.                 case ASC_QUIT: 
  369.                     {
  370.                         char buf[5];
  371.                         getLine("Quit (y/n)?",buf,1);
  372.                         if (buf[0]=='y')
  373.                             r = C_QUIT; 
  374.                     }
  375.                     break;
  376.                 case ASC_DOWN:
  377.                     r = C_DOWN; 
  378.                     break;
  379.                 case ASC_UP:
  380.                     r = C_UP; 
  381.                     break;
  382.                 case ASC_WALKDOWN:
  383.                     r = C_WALKDOWN; 
  384.                     break;
  385.                 case ASC_WALKUP:
  386.                     r = C_WALKUP; 
  387.                     break;
  388.                 case ASC_END:
  389.                     r = C_END; 
  390.                     break;
  391.                 case ASC_BEGINNING:
  392.                     r = C_BEGINNING; 
  393.                     break;
  394.                 case ASC_SEARCHCOMMENT:
  395.                     r = C_SEARCHCOMMENT; 
  396.                     break;
  397.                 case ASC_SEARCHBACKCOMMENT:
  398.                     r = C_SEARCHBACKCOMMENT; 
  399.                     break;
  400.                 case ASC_DOWNFORK:
  401.                     r = C_DOWNFORK; 
  402.                     break;
  403.                 case ASC_UPFORK:
  404.                     r = C_UPFORK; 
  405.                     break;
  406.                 case ASC_GOTO:
  407.                     {
  408.                         char buf[7];
  409.                         getLine("Move to node # ?",buf,5);
  410.                         searchNodeNum = atoi(buf);
  411.                         if (searchNodeNum)
  412.                             r = C_GOTO;
  413.                     }
  414.                     break;
  415.                 case ASC_COMMENTSCROLLDOWN:
  416.                     {
  417.                         if (commentLine< commentLines() - COMMENT_HIGH)
  418.                             commentLine++;
  419.                         showCommentAscii(commentLine);
  420.                     }
  421.                     break;
  422.                 case ASC_COMMENTSCROLLUP:
  423.                     if (commentLine) {
  424.                         commentLine--;
  425.                         showCommentAscii(commentLine);
  426.                     }
  427.                     break;
  428.                 case ASC_TREESCROLLDOWN:
  429.                     treeLine++;
  430.                     drawTreeAscii0(curnode);
  431.                     break;
  432.                 case ASC_TREESCROLLUP:
  433.                     treeLine--;
  434.                     drawTreeAscii0(curnode);
  435.                     break;
  436.  
  437.                 default:
  438.                     helpAscii();
  439.                     break;
  440.             }
  441.         }
  442.     }
  443.     return (int)r;
  444. }
  445.  
  446.  
  447. FUNCTION boolean setEnvAscii(env)
  448. char *env;
  449. {
  450.     char *c;
  451.     if (!strncmp(env,ASCII_ENV_STR, strlen(ASCII_ENV_STR))) {
  452.         env += strlen(ASCII_ENV_STR);
  453.         strncpy(envAscii,env,ASC_NUMENVS);
  454.         return true;
  455.     } else {
  456.         return false;
  457.     }
  458. }
  459.  
  460. FUNCTION helpMessage(s)
  461. char *s;
  462. {
  463.     notifyMessageAscii(s);
  464.     getKey();
  465. }
  466.  
  467. FUNCTION helpAscii()
  468. {
  469.     char buf[3];
  470.  
  471.     do {
  472.         getLine("Help for what key (<return> stops)?",buf,2);
  473.         if (buf[0]) switch (charToIndex(buf[0])) {
  474.                 case ASC_QUIT:
  475.                     helpMessage("Quit mgt -more-");
  476.                     break;
  477.                 case ASC_DOWN:
  478.                     helpMessage("Move forward -more-");
  479.                     break;
  480.                 case ASC_UP:
  481.                     helpMessage("Move backward -more-");
  482.                     break;
  483.                 case ASC_WALKDOWN:
  484.                     helpMessage("Walk forwards & visit variations -more-");
  485.                     break;
  486.                 case ASC_WALKUP:
  487.                     helpMessage("Walk backwards & visit variations -more-");
  488.                     break;
  489.                 case ASC_END:
  490.                     helpMessage("Go to the end of the current variation -more-");
  491.                     break;
  492.                 case ASC_BEGINNING:
  493.                     helpMessage("Go to the beginning of all variations -more-");
  494.                     break;
  495.                 case ASC_SEARCHCOMMENT:
  496.                     helpMessage("Walk forward until a comment is found -more-");
  497.                     break;
  498.                 case ASC_SEARCHBACKCOMMENT:
  499.                     helpMessage("Walk backward until a comment is found -more-");
  500.                     break;
  501.                 case ASC_DOWNFORK:
  502.                     helpMessage("Go forward until a variation appears -more-");
  503.                     break;
  504.                 case ASC_UPFORK:
  505.                     helpMessage("Go backward until a variation appears -more-");
  506.                     break;
  507.                 case ASC_GOTO:
  508.                     helpMessage("Jump to a specific node number -more-");
  509.                     helpMessage("The number is next to 'Node #' -more-");
  510.                     break;
  511.                 case ASC_COMMENTSCROLLDOWN:
  512.                     helpMessage("Scroll the comment window down -more-");
  513.                     break;
  514.                 case ASC_COMMENTSCROLLUP:
  515.                     helpMessage("Scroll the comment window up -more-");
  516.                     break;
  517.                 case ASC_TREESCROLLDOWN:
  518.                     helpMessage("Scroll the tree window down -more-");
  519.                     break;
  520.                 case ASC_TREESCROLLUP:
  521.                     helpMessage("Scroll the tree window up -more-");
  522.                     break;
  523.                 default:
  524.                     helpMessage("That does not exist. -more-");
  525.                     helpMessage("Uppercase letters visit variations. -more-");
  526.                     helpMessage("To the right, 'Commands' lists the key commands. -more-");
  527.                     break;
  528.             }
  529.     } while (buf[0]);
  530. }
  531.  
  532. interface asciiInterface = {
  533.     "Curses",
  534.     "c",
  535.     (char *)0,
  536.     initAscii,
  537.     closeAscii,
  538.     refreshAscii,
  539.     setPieceAscii,
  540.     plotPieceAscii,
  541.     displayCommentAscii,
  542.     clearCommentAscii,
  543.     clearBoardAscii,
  544.     idleAscii,
  545.     depthAscii,
  546.     drawTreeAscii,
  547.     highlightAscii,
  548.     setEnvAscii,
  549.     notifyMessageAscii,
  550.     notifyClearAscii
  551. };
  552.  
  553.  
  554.