UNIX 7th Ed. - /usr/src/games/chess/io.c

   1: #include "old.h"
   2: 
   3: rline()
   4: {
   5:     char *p1;
   6:     int c;
   7: 
   8:     p1 = sbuf;
   9:     while((c = getchar()) != '\n')
  10:         if(c <= 0)
  11:             onhup(); else
  12:             *p1++ = c;
  13:     *p1++ = '\0';
  14: }
  15: 
  16: getchar()
  17: {
  18:     int c;
  19: 
  20: loop:
  21:     c = 0;
  22:     read(0, &c, 1);
  23:     if(c == 0 && intrp) {
  24:         intrp = 0;
  25:         goto loop;
  26:     }
  27:     return(c);
  28: }
  29: 
  30: pboard()
  31: {
  32:     int i, x, y, c, p;
  33: 
  34:     c = 0;
  35:     i = 0;
  36:     x = 8;
  37:     while(x--) {
  38:         if(!mantom || mfmt)
  39:             putchar('1'+x); else
  40:             putchar('8'-x);
  41:         putchar(' ');
  42:         c++;
  43:         y = 8;
  44:         while(y--) {
  45:             c++;
  46:             putchar(' ');
  47:             if(p = board[i++])
  48:                 putchar("kqrbnp PNBRQK"[p+6]); else
  49:                 if((c&1)!=0)
  50:                     putchar('*'); else
  51:                     putchar('-');
  52:         }
  53:         putchar('\n');
  54:         if(intrp)
  55:             return;
  56:     }
  57:     if(mfmt)
  58:         printf("\n   a b c d e f g h"); else
  59:         printf("\n   q q q q k k k k\n   r n b     b n r");
  60:         printf("\n");
  61: }
  62: 
  63: out1(m)
  64: {
  65:     printf("%d. ", moveno);
  66:     if(mantom)
  67:         printf("... ");
  68:     out(m);
  69:     putchar('\n');
  70: }
  71: 
  72: out(m)
  73: int m;
  74: {
  75:     int from, to, epf, pmf;
  76: 
  77:     from = m>>8;
  78:     to = m&0377;
  79:     if(mfmt) {
  80:         algco(from);
  81:         algco(to);
  82:         return;
  83:     }
  84:     mantom? bmove(m): wmove(m);
  85:     epf = pmf = 0;
  86:     switch(amp[-1]) {
  87: 
  88:     case 0:
  89:     case 1:
  90:         stdp(board[to]);
  91:     ed:
  92:         putchar('/');
  93:         stdb(from);
  94:         if(amp[-2]) {
  95:             putchar('x');
  96:             stdp(amp[-2]);
  97:             putchar('/');
  98:         } else
  99:             putchar('-');
 100:         stdb(to);
 101:         break;
 102: 
 103:     case 3:
 104:         putchar('o');
 105:         putchar('-');
 106: 
 107:     case 2:
 108:         putchar('o');
 109:         putchar('-');
 110:         putchar('o');
 111:         break;
 112: 
 113:     case 4:
 114:         epf = 1;
 115:         putchar('p');
 116:         goto ed;
 117: 
 118:     case 5:
 119:         pmf = 1;
 120:         putchar('p');
 121:         goto ed;
 122:     }
 123:     if(pmf) {
 124:         putchar('(');
 125:         putchar('q');
 126:         putchar(')');
 127:     }
 128:     if(epf) {
 129:         putchar('e');
 130:         putchar('p');
 131:     }
 132:     if(check())
 133:         putchar('+');
 134:     mantom? bremove(): wremove();
 135: }
 136: 
 137: stdp(p)
 138: int p;
 139: {
 140: 
 141:     if(p < 0)
 142:         p = -p;
 143:     p = "ppnbrqk"[p];
 144:     putchar(p);
 145: }
 146: 
 147: stdb(b)
 148: int b;
 149: {
 150:     int r, f;
 151: 
 152:     r = b/8;
 153:     if((f = b%8) < 4)
 154:         putchar('q'); else {
 155:         putchar('k');
 156:         f = 7-f;
 157:     }
 158:     f = "rnb\0"[f];
 159:     if(f)
 160:         putchar(f);
 161:     putchar(mantom? r+'1': '8'-r);
 162: }
 163: 
 164: algco(p)
 165: int p;
 166: {
 167:     putchar('a'+(p%8));
 168:     putchar('8'-(p/8));
 169: }
 170: 
 171: putchar(c)
 172: {
 173: 
 174:     switch(c) {
 175: 
 176:     case '\t':
 177:         do
 178:             putchar(' ');
 179:         while(column%8);
 180:         return;
 181: 
 182:     case '\n':
 183:         column = 0;
 184:         break;
 185: 
 186:     default:
 187:         column++;
 188:     }
 189:     write(1, &c, 1);
 190: }
 191: 
 192: prtime(a, b)
 193: {
 194: 
 195:     printf("time = %d/%d\n", a, b);
 196: }
 197: 
 198: score1(m)
 199: {
 200:     if(intrp)
 201:         return;
 202:     if(!mantom) {
 203:         if(moveno < 10)
 204:             putchar(' '); else
 205:             putchar(moveno/10 + '0');
 206:         putchar(moveno%10 + '0');
 207:         putchar('.');
 208:         putchar(' ');
 209:     } else
 210:         while(column < 20)
 211:             putchar(' ');
 212:     out(m);
 213:     if(mantom)
 214:         putchar('\n');
 215: }
 216: 
 217: score()
 218: {
 219:     int *p;
 220: 
 221:     putchar('\n');
 222:     p = amp;
 223:     while(amp[-1] != -1) {
 224:         mantom? wremove(): bremove();
 225:         decrem();
 226:     }
 227:     posit(score1, p);
 228:     putchar('\n');
 229: }

Defined functions