| 0,0 → 1,493 |
|---|
| /* $OpenBSD: screen.c,v 1.13 2006/04/20 03:25:36 ray Exp $ */ |
| /* $NetBSD: screen.c,v 1.4 1995/04/29 01:11:36 mycroft Exp $ */ |
| |
| /*- |
| * Copyright (c) 1992, 1993 |
| * The Regents of the University of California. All rights reserved. |
| * |
| * This code is derived from software contributed to Berkeley by |
| * Chris Torek and Darren F. Provine. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * 1. Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * 2. Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * 3. Neither the name of the University nor the names of its contributors |
| * may be used to endorse or promote products derived from this software |
| * without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND |
| * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
| * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
| * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE |
| * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL |
| * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS |
| * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) |
| * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT |
| * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY |
| * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF |
| * SUCH DAMAGE. |
| * |
| * @(#)screen.c 8.1 (Berkeley) 5/31/93 |
| */ |
| |
| /* |
| * Tetris screen control. |
| */ |
| |
| #include <sys/ioctl.h> |
| |
| #include <err.h> |
| #include <setjmp.h> |
| #include <signal.h> |
| #include <stdio.h> |
| #include <stdlib.h> |
| #include <string.h> |
| #include <term.h> |
| #include <termios.h> |
| #include <unistd.h> |
| |
| #include "screen.h" |
| #include "tetris.h" |
| |
| static cell curscreen[B_SIZE]; /* 1 => standout (or otherwise marked) */ |
| static int curscore; |
| static int isset; /* true => terminal is in game mode */ |
| static struct termios oldtt; |
| static void (*tstp)(int); |
| |
| static void scr_stop(int); |
| static void stopset(int); |
| |
| /* |
| * Capabilities from TERMCAP. |
| */ |
| char PC, *BC, *UP; /* tgoto requires globals: ugh! */ |
| |
| static char |
| *bcstr, /* backspace char */ |
| *CEstr, /* clear to end of line */ |
| *CLstr, /* clear screen */ |
| *CMstr, /* cursor motion string */ |
| #ifdef unneeded |
| *CRstr, /* "\r" equivalent */ |
| #endif |
| *HOstr, /* cursor home */ |
| *LLstr, /* last line, first column */ |
| *pcstr, /* pad character */ |
| *TEstr, /* end cursor motion mode */ |
| *TIstr; /* begin cursor motion mode */ |
| char |
| *SEstr, /* end standout mode */ |
| *SOstr; /* begin standout mode */ |
| static int |
| COnum, /* co# value */ |
| LInum, /* li# value */ |
| MSflag; /* can move in standout mode */ |
| |
| |
| struct tcsinfo { /* termcap string info; some abbrevs above */ |
| char tcname[3]; |
| char **tcaddr; |
| } tcstrings[] = { |
| {"bc", &bcstr}, |
| {"ce", &CEstr}, |
| {"cl", &CLstr}, |
| {"cm", &CMstr}, |
| #ifdef unneeded |
| {"cr", &CRstr}, |
| #endif |
| {"le", &BC}, /* move cursor left one space */ |
| {"pc", &pcstr}, |
| {"se", &SEstr}, |
| {"so", &SOstr}, |
| {"te", &TEstr}, |
| {"ti", &TIstr}, |
| {"up", &UP}, /* cursor up */ |
| { {0}, NULL} |
| }; |
| |
| /* This is where we will actually stuff the information */ |
| |
| static char combuf[1024], tbuf[1024]; |
| |
| |
| /* |
| * Routine used by tputs(). |
| */ |
| int |
| put(int c) |
| { |
| |
| return (putchar(c)); |
| } |
| |
| /* |
| * putstr() is for unpadded strings (either as in termcap(5) or |
| * simply literal strings); putpad() is for padded strings with |
| * count=1. (See screen.h for putpad().) |
| */ |
| #define putstr(s) (void)fputs(s, stdout) |
| #define moveto(r, c) putpad(tgoto(CMstr, c, r)) |
| |
| /* |
| * Set up from termcap. |
| */ |
| void |
| scr_init(void) |
| { |
| static int bsflag, xsflag, sgnum; |
| #ifdef unneeded |
| static int ncflag; |
| #endif |
| char *term, *fill; |
| static struct tcninfo { /* termcap numeric and flag info */ |
| char tcname[3]; |
| int *tcaddr; |
| } tcflags[] = { |
| {"bs", &bsflag}, |
| {"ms", &MSflag}, |
| #ifdef unneeded |
| {"nc", &ncflag}, |
| #endif |
| {"xs", &xsflag}, |
| { {0}, NULL} |
| }, tcnums[] = { |
| {"co", &COnum}, |
| {"li", &LInum}, |
| {"sg", &sgnum}, |
| { {0}, NULL} |
| }; |
| |
| if ((term = getenv("TERM")) == NULL) |
| stop("you must set the TERM environment variable"); |
| if (tgetent(tbuf, term) <= 0) |
| stop("cannot find your termcap"); |
| fill = combuf; |
| { |
| struct tcsinfo *p; |
| |
| for (p = tcstrings; p->tcaddr; p++) |
| *p->tcaddr = tgetstr(p->tcname, &fill); |
| } |
| if (classic) |
| SOstr = SEstr = NULL; |
| { |
| struct tcninfo *p; |
| |
| for (p = tcflags; p->tcaddr; p++) |
| *p->tcaddr = tgetflag(p->tcname); |
| for (p = tcnums; p->tcaddr; p++) |
| *p->tcaddr = tgetnum(p->tcname); |
| } |
| if (bsflag) |
| BC = "\b"; |
| else if (BC == NULL && bcstr != NULL) |
| BC = bcstr; |
| if (CLstr == NULL) |
| stop("cannot clear screen"); |
| if (CMstr == NULL || UP == NULL || BC == NULL) |
| stop("cannot do random cursor positioning via tgoto()"); |
| PC = pcstr ? *pcstr : 0; |
| if (sgnum > 0 || xsflag) |
| SOstr = SEstr = NULL; |
| #ifdef unneeded |
| if (ncflag) |
| CRstr = NULL; |
| else if (CRstr == NULL) |
| CRstr = "\r"; |
| #endif |
| } |
| |
| /* this foolery is needed to modify tty state `atomically' */ |
| static jmp_buf scr_onstop; |
| |
| static void |
| stopset(int sig) |
| { |
| sigset_t sigset; |
| |
| (void) signal(sig, SIG_DFL); |
| (void) kill(getpid(), sig); |
| sigemptyset(&sigset); |
| sigaddset(&sigset, sig); |
| (void) sigprocmask(SIG_UNBLOCK, &sigset, (sigset_t *)0); |
| longjmp(scr_onstop, 1); |
| } |
| |
| static void |
| scr_stop(int sig) |
| { |
| sigset_t sigset; |
| |
| scr_end(); |
| (void) kill(getpid(), sig); |
| sigemptyset(&sigset); |
| sigaddset(&sigset, sig); |
| (void) sigprocmask(SIG_UNBLOCK, &sigset, (sigset_t *)0); |
| scr_set(); |
| scr_msg(key_msg, 1); |
| } |
| |
| /* |
| * Set up screen mode. |
| */ |
| void |
| scr_set(void) |
| { |
| struct winsize ws; |
| struct termios newtt; |
| sigset_t sigset, osigset; |
| void (*ttou)(int); |
| |
| sigemptyset(&sigset); |
| sigaddset(&sigset, SIGTSTP); |
| sigaddset(&sigset, SIGTTOU); |
| (void) sigprocmask(SIG_BLOCK, &sigset, &osigset); |
| if ((tstp = signal(SIGTSTP, stopset)) == SIG_IGN) |
| (void) signal(SIGTSTP, SIG_IGN); |
| if ((ttou = signal(SIGTTOU, stopset)) == SIG_IGN) |
| (void) signal(SIGTTOU, SIG_IGN); |
| /* |
| * At last, we are ready to modify the tty state. If |
| * we stop while at it, stopset() above will longjmp back |
| * to the setjmp here and we will start over. |
| */ |
| (void) setjmp(scr_onstop); |
| (void) sigprocmask(SIG_SETMASK, &osigset, (sigset_t *)0); |
| Rows = 0, Cols = 0; |
| if (ioctl(0, TIOCGWINSZ, &ws) == 0) { |
| Rows = ws.ws_row; |
| Cols = ws.ws_col; |
| } |
| if (Rows == 0) |
| Rows = LInum; |
| if (Cols == 0) |
| Cols = COnum; |
| if (Rows < MINROWS || Cols < MINCOLS) { |
| char smallscr[55]; |
| |
| (void)snprintf(smallscr, sizeof(smallscr), |
| "the screen is too small (must be at least %dx%d)", |
| MINROWS, MINCOLS); |
| stop(smallscr); |
| } |
| if (tcgetattr(0, &oldtt) < 0) |
| stop("tcgetattr() fails"); |
| newtt = oldtt; |
| newtt.c_lflag &= ~(ICANON|ECHO); |
| newtt.c_oflag &= ~OXTABS; |
| if (tcsetattr(0, TCSADRAIN, &newtt) < 0) |
| stop("tcsetattr() fails"); |
| (void) sigprocmask(SIG_BLOCK, &sigset, &osigset); |
| |
| /* |
| * We made it. We are now in screen mode, modulo TIstr |
| * (which we will fix immediately). |
| */ |
| if (TIstr) |
| putstr(TIstr); /* termcap(5) says this is not padded */ |
| if (tstp != SIG_IGN) |
| (void) signal(SIGTSTP, scr_stop); |
| if (ttou != SIG_IGN) |
| (void) signal(SIGTTOU, ttou); |
| |
| isset = 1; |
| (void) sigprocmask(SIG_SETMASK, &osigset, (sigset_t *)0); |
| scr_clear(); |
| } |
| |
| /* |
| * End screen mode. |
| */ |
| void |
| scr_end(void) |
| { |
| sigset_t sigset, osigset; |
| |
| sigemptyset(&sigset); |
| sigaddset(&sigset, SIGTSTP); |
| sigaddset(&sigset, SIGTTOU); |
| (void) sigprocmask(SIG_BLOCK, &sigset, &osigset); |
| /* move cursor to last line */ |
| if (LLstr) |
| putstr(LLstr); /* termcap(5) says this is not padded */ |
| else |
| moveto(Rows - 1, 0); |
| /* exit screen mode */ |
| if (TEstr) |
| putstr(TEstr); /* termcap(5) says this is not padded */ |
| (void) fflush(stdout); |
| (void) tcsetattr(0, TCSADRAIN, &oldtt); |
| isset = 0; |
| /* restore signals */ |
| (void) signal(SIGTSTP, tstp); |
| (void) sigprocmask(SIG_SETMASK, &osigset, (sigset_t *)0); |
| } |
| |
| void |
| stop(char *why) |
| { |
| |
| if (isset) |
| scr_end(); |
| errx(1, "aborting: %s", why); |
| } |
| |
| /* |
| * Clear the screen, forgetting the current contents in the process. |
| */ |
| void |
| scr_clear(void) |
| { |
| |
| putpad(CLstr); |
| curscore = -1; |
| memset((char *)curscreen, 0, sizeof(curscreen)); |
| } |
| |
| #if vax && !__GNUC__ |
| typedef int regcell; /* pcc is bad at `register char', etc */ |
| #else |
| typedef cell regcell; |
| #endif |
| |
| /* |
| * Update the screen. |
| */ |
| void |
| scr_update(void) |
| { |
| cell *bp, *sp; |
| regcell so, cur_so = 0; |
| int i, ccol, j; |
| sigset_t sigset, osigset; |
| static const struct shape *lastshape; |
| |
| sigemptyset(&sigset); |
| sigaddset(&sigset, SIGTSTP); |
| (void) sigprocmask(SIG_BLOCK, &sigset, &osigset); |
| |
| /* always leave cursor after last displayed point */ |
| curscreen[D_LAST * B_COLS - 1] = -1; |
| |
| if (score != curscore) { |
| if (HOstr) |
| putpad(HOstr); |
| else |
| moveto(0, 0); |
| (void) printf("Score: %d", score); |
| curscore = score; |
| } |
| |
| /* draw preview of next pattern */ |
| if (showpreview && (nextshape != lastshape)) { |
| int i; |
| static int r=5, c=2; |
| int tr, tc, t; |
| |
| lastshape = nextshape; |
| |
| /* clean */ |
| putpad(SEstr); |
| moveto(r-1, c-1); putstr(" "); |
| moveto(r, c-1); putstr(" "); |
| moveto(r+1, c-1); putstr(" "); |
| moveto(r+2, c-1); putstr(" "); |
| |
| moveto(r-3, c-2); |
| putstr("Next shape:"); |
| |
| /* draw */ |
| if (SOstr) |
| putpad(SOstr); |
| moveto(r, 2 * c); |
| putstr(SOstr ? " " : "[]"); |
| for (i = 0; i < 3; i++) { |
| t = c + r * B_COLS; |
| t += nextshape->off[i]; |
| |
| tr = t / B_COLS; |
| tc = t % B_COLS; |
| |
| moveto(tr, 2*tc); |
| putstr(SOstr ? " " : "[]"); |
| } |
| putpad(SEstr); |
| } |
| |
| bp = &board[D_FIRST * B_COLS]; |
| sp = &curscreen[D_FIRST * B_COLS]; |
| for (j = D_FIRST; j < D_LAST; j++) { |
| ccol = -1; |
| for (i = 0; i < B_COLS; bp++, sp++, i++) { |
| if (*sp == (so = *bp)) |
| continue; |
| *sp = so; |
| if (i != ccol) { |
| if (cur_so && MSflag) { |
| putpad(SEstr); |
| cur_so = 0; |
| } |
| moveto(RTOD(j), CTOD(i)); |
| } |
| if (SOstr) { |
| if (so != cur_so) { |
| putpad(so ? SOstr : SEstr); |
| cur_so = so; |
| } |
| putstr(" "); |
| } else |
| putstr(so ? "[]" : " "); |
| ccol = i + 1; |
| /* |
| * Look ahead a bit, to avoid extra motion if |
| * we will be redrawing the cell after the next. |
| * Motion probably takes four or more characters, |
| * so we save even if we rewrite two cells |
| * `unnecessarily'. Skip it all, though, if |
| * the next cell is a different color. |
| */ |
| #define STOP (B_COLS - 3) |
| if (i > STOP || sp[1] != bp[1] || so != bp[1]) |
| continue; |
| if (sp[2] != bp[2]) |
| sp[1] = -1; |
| else if (i < STOP && so == bp[2] && sp[3] != bp[3]) { |
| sp[2] = -1; |
| sp[1] = -1; |
| } |
| } |
| } |
| if (cur_so) |
| putpad(SEstr); |
| (void) fflush(stdout); |
| (void) sigprocmask(SIG_SETMASK, &osigset, (sigset_t *)0); |
| } |
| |
| /* |
| * Write a message (set!=0), or clear the same message (set==0). |
| * (We need its length in case we have to overwrite with blanks.) |
| */ |
| void |
| scr_msg(char *s, int set) |
| { |
| |
| if (set || CEstr == NULL) { |
| int l = strlen(s); |
| |
| moveto(Rows - 2, ((Cols - l) >> 1) - 1); |
| if (set) |
| putstr(s); |
| else |
| while (--l >= 0) |
| (void) putchar(' '); |
| } else { |
| moveto(Rows - 2, 0); |
| putpad(CEstr); |
| } |
| } |