games/hack/hack.termcap.c

   1 /*      $NetBSD: hack.termcap.c,v 1.17 2009/06/07 18:30:39 dholland Exp $       */
   2
   3 /*
   4  * Copyright (c) 1985, Stichting Centrum voor Wiskunde en Informatica,
   5  * Amsterdam
   6  * All rights reserved.
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted provided that the following conditions are
  10  * met:
  11  *
  12  * - Redistributions of source code must retain the above copyright notice,
  13  * this list of conditions and the following disclaimer.
  14  *
  15  * - Redistributions in binary form must reproduce the above copyright
  16  * notice, this list of conditions and the following disclaimer in the
  17  * documentation and/or other materials provided with the distribution.
  18  *
  19  * - Neither the name of the Stichting Centrum voor Wiskunde en
  20  * Informatica, nor the names of its contributors may be used to endorse or
  21  * promote products derived from this software without specific prior
  22  * written permission.
  23  *
  24  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
  25  * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  26  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
  27  * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
  28  * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  29  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  30  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  31  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
  32  * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
  33  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  34  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  35  */
  36
  37 /*
  38  * Copyright (c) 1982 Jay Fenlason <hack@gnu.org>
  39  * All rights reserved.
  40  *
  41  * Redistribution and use in source and binary forms, with or without
  42  * modification, are permitted provided that the following conditions
  43  * are met:
  44  * 1. Redistributions of source code must retain the above copyright
  45  *    notice, this list of conditions and the following disclaimer.
  46  * 2. Redistributions in binary form must reproduce the above copyright
  47  *    notice, this list of conditions and the following disclaimer in the
  48  *    documentation and/or other materials provided with the distribution.
  49  * 3. The name of the author may not be used to endorse or promote products
  50  *    derived from this software without specific prior written permission.
  51  *
  52  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
  53  * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
  54  * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL
  55  * THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  56  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  57  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
  58  * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
  59  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
  60  * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
  61  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  62  */
  63
  64 #include <sys/cdefs.h>
  65 #ifndef lint
  66 __RCSID("$NetBSD: hack.termcap.c,v 1.17 2009/06/07 18:30:39 dholland Exp $");
  67 #endif                          /* not lint */
  68
  69 #include <string.h>
  70 #include <termios.h>
  71 #include <termcap.h>
  72 #include <stdlib.h>
  73 #include <unistd.h>
  74 #include "hack.h"
  75 #include "extern.h"
  76 #include "def.flag.h"           /* for flags.nonull */
  77
  78 static struct tinfo *info;
  79 static const char    *HO, *CL, *CE, *CM, *ND, *XD, *BC_BS, *SO, *SE, *TI, *TE;
  80 static const char    *VS, *VE;
  81 static int      SG;
  82 char           *CD;             /* tested in pri.c: docorner() */
  83 int             CO, LI;         /* used in pri.c and whatis.c */
  84
  85 static void nocmov(int, int);
  86 static void cmov(int, int);
  87 static int xputc(int);
  88 static void xputs(const char *);
  89
  90 void
  91 startup(void)
  92 {
  93         char           *term;
  94
  95         /* UP, BC, PC already set */
  96         if (!(term = getenv("TERM")))
  97                 error("Can't get TERM.");
  98         if (!strncmp(term, "5620", 4))
  99                 flags.nonull = 1;       /* this should be a termcap flag */
 100         if (t_getent(&info, term) < 1)
 101                 error("Unknown terminal type: %s.", term);
 102         BC_BS = t_agetstr(info, "bc");
 103         if (!BC_BS) {
 104                 if (!t_getflag(info, "bs"))
 105                         error("Terminal must backspace.");
 106                 BC_BS = "\b";
 107         }
 108         HO = t_agetstr(info, "ho");
 109         CO = t_getnum(info, "co");
 110         LI = t_getnum(info, "li");
 111         if (CO < COLNO || LI < ROWNO + 2)
 112                 setclipped();
 113         if (!(CL = t_agetstr(info, "cl")))
 114                 error("Hack needs CL.");
 115         ND = t_agetstr(info, "nd");
 116         if (t_getflag(info, "os"))
 117                 error("Hack can't have OS.");
 118         CE = t_agetstr(info, "ce");
 119         /*
 120          * It seems that xd is no longer supported, and we should use a
 121          * linefeed instead; unfortunately this requires resetting CRMOD, and
 122          * many output routines will have to be modified slightly. Let's
 123          * leave that till the next release.
 124          */
 125         XD = t_agetstr(info, "xd");
 126         /* not:                 XD = t_agetstr(info, "do"); */
 127         if (!(CM = t_agetstr(info, "cm"))) {
 128                 if (!UP && !HO)
 129                         error("Hack needs CM or UP or HO.");
 130                 printf("Playing hack on terminals without cm is suspect...\n");
 131                 getret();
 132         }
 133         SO = t_agetstr(info, "so");
 134         SE = t_agetstr(info, "se");
 135         SG = t_getnum(info, "sg");      /* -1: not fnd; else # of spaces left by so */
 136         if (!SO || !SE || (SG > 0))
 137                 SO = SE = 0;
 138         CD = t_agetstr(info, "cd");
 139         set_whole_screen();     /* uses LI and CD */
 140 }
 141
 142 void
 143 start_screen(void)
 144 {
 145         xputs(TI);
 146         xputs(VS);
 147 }
 148
 149 void
 150 end_screen(void)
 151 {
 152         xputs(VE);
 153         xputs(TE);
 154 }
 155
 156 /*
 157  * Cursor movements
 158  *
 159  * x,y not xchar: perhaps xchar is unsigned and
 160  * curx-x would be unsigned as well
 161  */
 162 void
 163 curs(int x, int y)
 164 {
 165
 166         if (y == cury && x == curx)
 167                 return;
 168         if (!ND && (curx != x || x <= 3)) {     /* Extremely primitive */
 169                 cmov(x, y);     /* bunker!wtm */
 170                 return;
 171         }
 172         if (abs(cury - y) <= 3 && abs(curx - x) <= 3)
 173                 nocmov(x, y);
 174         else if ((x <= 3 && abs(cury - y) <= 3) || (!CM && x < abs(curx - x))) {
 175                 (void) putchar('\r');
 176                 curx = 1;
 177                 nocmov(x, y);
 178         } else if (!CM) {
 179                 nocmov(x, y);
 180         } else
 181                 cmov(x, y);
 182 }
 183
 184 static void
 185 nocmov(int x, int y)
 186 {
 187         if (cury > y) {
 188                 if (UP) {
 189                         while (cury > y) {      /* Go up. */
 190                                 xputs(UP);
 191                                 cury--;
 192                         }
 193                 } else if (CM) {
 194                         cmov(x, y);
 195                 } else if (HO) {
 196                         home();
 197                         curs(x, y);
 198                 }               /* else impossible("..."); */
 199         } else if (cury < y) {
 200                 if (XD) {
 201                         while (cury < y) {
 202                                 xputs(XD);
 203                                 cury++;
 204                         }
 205                 } else if (CM) {
 206                         cmov(x, y);
 207                 } else {
 208                         while (cury < y) {
 209                                 xputc('\n');
 210                                 curx = 1;
 211                                 cury++;
 212                         }
 213                 }
 214         }
 215         if (curx < x) {         /* Go to the right. */
 216                 if (!ND)
 217                         cmov(x, y);
 218                 else            /* bah */
 219                         /* should instead print what is there already */
 220                         while (curx < x) {
 221                                 xputs(ND);
 222                                 curx++;
 223                         }
 224         } else if (curx > x) {
 225                 while (curx > x) {      /* Go to the left. */
 226                         xputs(BC_BS);
 227                         curx--;
 228                 }
 229         }
 230 }
 231
 232 static void
 233 cmov(int x, int y)
 234 {
 235         char buf[256];
 236
 237         if (t_goto(info, CM, x - 1, y - 1, buf, 255) >= 0) {
 238                 xputs(buf);
 239                 cury = y;
 240                 curx = x;
 241         }
 242 }
 243
 244 static int
 245 xputc(int c)
 246 {
 247         return (fputc(c, stdout));
 248 }
 249
 250 static void
 251 xputs(const char *s)
 252 {
 253         tputs(s, 1, xputc);
 254 }
 255
 256 void
 257 cl_end(void)
 258 {
 259         if (CE)
 260                 xputs(CE);
 261         else {                  /* no-CE fix - free after Harold Rynes */
 262                 /*
 263                  * this looks terrible, especially on a slow terminal but is
 264                  * better than nothing
 265                  */
 266                 int cx = curx, cy = cury;
 267
 268                 while (curx < COLNO) {
 269                         xputc(' ');
 270                         curx++;
 271                 }
 272                 curs(cx, cy);
 273         }
 274 }
 275
 276 void
 277 clear_screen(void)
 278 {
 279         xputs(CL);
 280         curx = cury = 1;
 281 }
 282
 283 void
 284 home(void)
 285 {
 286         char buf[256];
 287
 288         if (HO)
 289                 xputs(HO);
 290         else if ((CM) && (t_goto(info, CM, 0, 0, buf, 255) >= 0))
 291                 xputs(buf);
 292         else
 293                 curs(1, 1);     /* using UP ... */
 294         curx = cury = 1;
 295 }
 296
 297 void
 298 standoutbeg(void)
 299 {
 300         if (SO)
 301                 xputs(SO);
 302 }
 303
 304 void
 305 standoutend(void)
 306 {
 307         if (SE)
 308                 xputs(SE);
 309 }
 310
 311 void
 312 backsp(void)
 313 {
 314         xputs(BC_BS);
 315         curx--;
 316 }
 317
 318 void
 319 bell(void)
 320 {
 321         (void) putchar('\007'); /* curx does not change */
 322         (void) fflush(stdout);
 323 }
 324
 325 void
 326 delay_output(void)
 327 {
 328
 329         /* delay 50 ms - could also use a 'nap'-system call */
 330           /* or the usleep call like this :-) */
 331         usleep(50000);
 332 }
 333
 334 void
 335 cl_eos(void)
 336 {                               /* free after Robert Viduya *//* must only be
 337                                  * called with curx = 1 */
 338
 339         if (CD)
 340                 xputs(CD);
 341         else {
 342                 int             cx = curx, cy = cury;
 343                 while (cury <= LI - 2) {
 344                         cl_end();
 345                         xputc('\n');
 346                         curx = 1;
 347                         cury++;
 348                 }
 349                 cl_end();
 350                 curs(cx, cy);
 351         }
 352 }