1: /*      $NetBSD: draw.c,v 1.3 2003/06/11 12:00:22 wiz Exp $  */
    2: /*
    3:  * Copyright (c) 1983-2003, Regents of the University of California.
    4:  * All rights reserved.
    5:  * 
    6:  * Redistribution and use in source and binary forms, with or without 
    7:  * modification, are permitted provided that the following conditions are 
    8:  * met:
    9:  * 
   10:  * + Redistributions of source code must retain the above copyright 
   11:  *   notice, this list of conditions and the following disclaimer.
   12:  * + Redistributions in binary form must reproduce the above copyright 
   13:  *   notice, this list of conditions and the following disclaimer in the 
   14:  *   documentation and/or other materials provided with the distribution.
   15:  * + Neither the name of the University of California, San Francisco nor 
   16:  *   the names of its contributors may be used to endorse or promote 
   17:  *   products derived from this software without specific prior written 
   18:  *   permission.
   19:  * 
   20:  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS 
   21:  * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 
   22:  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A 
   23:  * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 
   24:  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 
   25:  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 
   26:  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 
   27:  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 
   28:  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 
   29:  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 
   30:  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
   31:  */
   32: 
   33: #include <sys/cdefs.h>
   34: #ifndef lint
   35: __RCSID("$NetBSD: draw.c,v 1.3 2003/06/11 12:00:22 wiz Exp $");
   36: #endif /* not lint */
   37: 
   38: # include       "hunt.h"
   39: 
   40: void
   41: drawmaze(pp)
   42:         PLAYER *pp;
   43: {
   44:         int    x;
   45:         char   *sp;
   46:         int    y;
   47:         char   *endp;
   48: 
   49:         clrscr(pp);
   50:         outstr(pp, pp->p_maze[0], WIDTH);
   51:         for (y = 1; y < HEIGHT - 1; y++) {
   52:                 endp = &pp->p_maze[y][WIDTH];
   53:                 for (x = 0, sp = pp->p_maze[y]; sp < endp; x++, sp++)
   54:                         if (*sp != SPACE) {
   55:                                 cgoto(pp, y, x);
   56:                                 if (pp->p_x == x && pp->p_y == y)
   57:                                         outch(pp, translate(*sp));
   58:                                 else if (is_player(*sp))
   59:                                         outch(pp, player_sym(pp, y, x));
   60:                                 else
   61:                                         outch(pp, *sp);
   62:                         }
   63:         }
   64:         cgoto(pp, HEIGHT - 1, 0);
   65:         outstr(pp, pp->p_maze[HEIGHT - 1], WIDTH);
   66:         drawstatus(pp);
   67: }
   68: 
   69: /*
   70:  * drawstatus - put up the status lines (this assumes the screen
   71:  *              size is 80x24 with the maze being 64x24)
   72:  */
   73: void
   74: drawstatus(pp)
   75:         PLAYER *pp;
   76: {
   77:         int    i;
   78:         PLAYER *np;
   79: 
   80:         cgoto(pp, STAT_AMMO_ROW, STAT_LABEL_COL);
   81:         outstr(pp, "Ammo:", 5);
   82:         (void) sprintf(Buf, "%3d", pp->p_ammo);
   83:         cgoto(pp, STAT_AMMO_ROW, STAT_VALUE_COL);
   84:         outstr(pp, Buf, 3);
   85: 
   86:         cgoto(pp, STAT_GUN_ROW, STAT_LABEL_COL);
   87:         outstr(pp, "Gun:", 4);
   88:         cgoto(pp, STAT_GUN_ROW, STAT_VALUE_COL);
   89:         outstr(pp, (pp->p_ncshot < MAXNCSHOT) ? " ok" : "   ", 3);
   90: 
   91:         cgoto(pp, STAT_DAM_ROW, STAT_LABEL_COL);
   92:         outstr(pp, "Damage:", 7);
   93:         (void) sprintf(Buf, "%2d/%2d", pp->p_damage, pp->p_damcap);
   94:         cgoto(pp, STAT_DAM_ROW, STAT_VALUE_COL);
   95:         outstr(pp, Buf, 5);
   96: 
   97:         cgoto(pp, STAT_KILL_ROW, STAT_LABEL_COL);
   98:         outstr(pp, "Kills:", 6);
   99:         (void) sprintf(Buf, "%3d", (pp->p_damcap - MAXDAM) / 2);
  100:         cgoto(pp, STAT_KILL_ROW, STAT_VALUE_COL);
  101:         outstr(pp, Buf, 3);
  102: 
  103:         cgoto(pp, STAT_PLAY_ROW, STAT_LABEL_COL);
  104:         outstr(pp, "Player:", 7);
  105:         for (i = STAT_PLAY_ROW + 1, np = Player; np < End_player; np++) {
  106:                 (void) sprintf(Buf, "%5.2f%c%-10.10s %c", np->p_ident->i_score,
  107:                         stat_char(np), np->p_ident->i_name,
  108:                         np->p_ident->i_team);
  109:                 cgoto(pp, i++, STAT_NAME_COL);
  110:                 outstr(pp, Buf, STAT_NAME_LEN);
  111:         }
  112: 
  113: # ifdef MONITOR
  114:         cgoto(pp, STAT_MON_ROW, STAT_LABEL_COL);
  115:         outstr(pp, "Monitor:", 8);
  116:         for (i = STAT_MON_ROW + 1, np = Monitor; np < End_monitor; np++) {
  117:                 (void) sprintf(Buf, "%5.5s %-10.10s %c", " ",
  118:                         np->p_ident->i_name, np->p_ident->i_team);
  119:                 cgoto(pp, i++, STAT_NAME_COL);
  120:                 outstr(pp, Buf, STAT_NAME_LEN);
  121:         }
  122: # endif
  123: }
  124: 
  125: void
  126: look(pp)
  127:         PLAYER *pp;
  128: {
  129:         int    x, y;
  130: 
  131:         x = pp->p_x;
  132:         y = pp->p_y;
  133: 
  134:         check(pp, y - 1, x - 1);
  135:         check(pp, y - 1, x    );
  136:         check(pp, y - 1, x + 1);
  137:         check(pp, y    , x - 1);
  138:         check(pp, y    , x    );
  139:         check(pp, y    , x + 1);
  140:         check(pp, y + 1, x - 1);
  141:         check(pp, y + 1, x    );
  142:         check(pp, y + 1, x + 1);
  143: 
  144:         switch (pp->p_face) {
  145:           case LEFTS:
  146:                 see(pp, LEFTS);
  147:                 see(pp, ABOVE);
  148:                 see(pp, BELOW);
  149:                 break;
  150:           case RIGHT:
  151:                 see(pp, RIGHT);
  152:                 see(pp, ABOVE);
  153:                 see(pp, BELOW);
  154:                 break;
  155:           case ABOVE:
  156:                 see(pp, ABOVE);
  157:                 see(pp, LEFTS);
  158:                 see(pp, RIGHT);
  159:                 break;
  160:           case BELOW:
  161:                 see(pp, BELOW);
  162:                 see(pp, LEFTS);
  163:                 see(pp, RIGHT);
  164:                 break;
  165: # ifdef FLY
  166:           case FLYER:
  167:                 break;
  168: # endif
  169:         }
  170:         cgoto(pp, y, x);
  171: }
  172: 
  173: void
  174: see(pp, face)
  175:         PLAYER *pp;
  176:         int    face;
  177: {
  178:         char   *sp;
  179:         int    y, x, i, cnt;
  180: 
  181:         x = pp->p_x;
  182:         y = pp->p_y;
  183: 
  184:         switch (face) {
  185:           case LEFTS:
  186:                 sp = &Maze[y][x];
  187:                 for (i = 0; See_over[(int)*--sp]; i++)
  188:                         continue;
  189: 
  190:                 if (i == 0)
  191:                         break;
  192: 
  193:                 cnt = i;
  194:                 x = pp->p_x - 1;
  195:                 --y;
  196:                 while (i--)
  197:                         check(pp, y, --x);
  198:                 i = cnt;
  199:                 x = pp->p_x - 1;
  200:                 ++y;
  201:                 while (i--)
  202:                         check(pp, y, --x);
  203:                 i = cnt;
  204:                 x = pp->p_x - 1;
  205:                 ++y;
  206:                 while (i--)
  207:                         check(pp, y, --x);
  208:                 break;
  209:           case RIGHT:
  210:                 sp = &Maze[y][++x];
  211:                 for (i = 0; See_over[(int)*sp++]; i++)
  212:                         continue;
  213: 
  214:                 if (i == 0)
  215:                         break;
  216: 
  217:                 cnt = i;
  218:                 x = pp->p_x + 1;
  219:                 --y;
  220:                 while (i--)
  221:                         check(pp, y, ++x);
  222:                 i = cnt;
  223:                 x = pp->p_x + 1;
  224:                 ++y;
  225:                 while (i--)
  226:                         check(pp, y, ++x);
  227:                 i = cnt;
  228:                 x = pp->p_x + 1;
  229:                 ++y;
  230:                 while (i--)
  231:                         check(pp, y, ++x);
  232:                 break;
  233:           case ABOVE:
  234:                 sp = &Maze[--y][x];
  235:                 if (!See_over[(int)*sp])
  236:                         break;
  237:                 do {
  238:                         --y;
  239:                         sp -= sizeof Maze[0];
  240:                         check(pp, y, x - 1);
  241:                         check(pp, y, x    );
  242:                         check(pp, y, x + 1);
  243:                 } while (See_over[(int)*sp]);
  244:                 break;
  245:           case BELOW:
  246:                 sp = &Maze[++y][x];
  247:                 if (!See_over[(int)*sp])
  248:                         break;
  249:                 do {
  250:                         y++;
  251:                         sp += sizeof Maze[0];
  252:                         check(pp, y, x - 1);
  253:                         check(pp, y, x    );
  254:                         check(pp, y, x + 1);
  255:                 } while (See_over[(int)*sp]);
  256:                 break;
  257:         }
  258: }
  259: 
  260: void
  261: check(pp, y, x)
  262:         PLAYER *pp;
  263:         int    y, x;
  264: {
  265:         int    index;
  266:         int    ch;
  267:         PLAYER *rpp;
  268: 
  269:         index = y * sizeof Maze[0] + x;
  270:         ch = ((char *) Maze)[index];
  271:         if (ch != ((char *) pp->p_maze)[index]) {
  272:                 rpp = pp;
  273:                 cgoto(rpp, y, x);
  274:                 if (x == rpp->p_x && y == rpp->p_y)
  275:                         outch(rpp, translate(ch));
  276:                 else if (is_player(ch))
  277:                         outch(rpp, player_sym(rpp, y, x));
  278:                 else
  279:                         outch(rpp, ch);
  280:                 ((char *) rpp->p_maze)[index] = ch;
  281:         }
  282: }
  283: 
  284: /*
  285:  * showstat
  286:  *      Update the status of players
  287:  */
  288: void
  289: showstat(pp)
  290:         PLAYER *pp;
  291: {
  292:         PLAYER *np;
  293:         int    y;
  294:         char   c;
  295: 
  296:         y = STAT_PLAY_ROW + 1 + (pp - Player);
  297:         c = stat_char(pp);
  298: # ifdef MONITOR
  299:         for (np = Monitor; np < End_monitor; np++) {
  300:                 cgoto(np, y, STAT_SCAN_COL);
  301:                 outch(np, c);
  302:         }
  303: # endif
  304:         for (np = Player; np < End_player; np++) {
  305:                 cgoto(np, y, STAT_SCAN_COL);
  306:                 outch(np, c);
  307:         }
  308: }
  309: 
  310: /*
  311:  * drawplayer:
  312:  *      Draw the player on the screen and show him to everyone who's scanning
  313:  *      unless he is cloaked.
  314:  */
  315: void
  316: drawplayer(pp, draw)
  317:         PLAYER *pp;
  318:         FLAG   draw;
  319: {
  320:         PLAYER *newp;
  321:         int    x, y;
  322: 
  323:         x = pp->p_x;
  324:         y = pp->p_y;
  325:         Maze[y][x] = draw ? pp->p_face : pp->p_over;
  326: 
  327: # ifdef MONITOR
  328:         for (newp = Monitor; newp < End_monitor; newp++)
  329:                 check(newp, y, x);
  330: # endif
  331: 
  332:         for (newp = Player; newp < End_player; newp++) {
  333:                 if (!draw || newp == pp) {
  334:                         check(newp, y, x);
  335:                         continue;
  336:                 }
  337:                 if (newp->p_scan == 0) {
  338:                         newp->p_scan--;
  339:                         showstat(newp);
  340:                 }
  341:                 else if (newp->p_scan > 0) {
  342:                         if (pp->p_cloak < 0)
  343:                                 check(newp, y, x);
  344:                         newp->p_scan--;
  345:                 }
  346:         }
  347:         if (!draw || pp->p_cloak < 0)
  348:                 return;
  349:         if (pp->p_cloak-- == 0)
  350:                 showstat(pp);
  351: }
  352: 
  353: void
  354: message(pp, s)
  355:         PLAYER *pp;
  356:         const char     *s;
  357: {
  358:         cgoto(pp, HEIGHT, 0);
  359:         outstr(pp, s, strlen(s));
  360:         ce(pp);
  361: }
  362: 
  363: /*
  364:  * translate:
  365:  *      Turn a character into the right direction character if we are
  366:  *      looking at the current player.
  367:  */
  368: char
  369: translate(ch)
  370:         char   ch;
  371: {
  372:         switch (ch) {
  373:           case LEFTS:
  374:                 return '<';
  375:           case RIGHT:
  376:                 return '>';
  377:           case ABOVE:
  378:                 return '^';
  379:           case BELOW:
  380:                 return 'v';
  381:         }
  382:         return ch;
  383: }
  384: 
  385: /*
  386:  * player_sym:
  387:  *      Return the player symbol
  388:  */
  389: int
  390: player_sym(pp, y, x)
  391:         const PLAYER   *pp;
  392:         int    y, x;
  393: {
  394:         PLAYER *npp;
  395: 
  396:         npp = play_at(y, x);
  397:         if (npp->p_ident->i_team == ' ')
  398:                 return Maze[y][x];
  399: #ifdef MONITOR
  400:         if (pp->p_ident->i_team == '*')
  401:                 return npp->p_ident->i_team;
  402: #endif
  403:         if (pp->p_ident->i_team != npp->p_ident->i_team)
  404:                 return Maze[y][x];
  405:         return pp->p_ident->i_team;
  406: }