Return to twinkle1.c CVS log

Up to [CSRG BSD Unix] / 43BSDReno / share / doc / ps1 / 18.curses

Annotation of 43BSDReno/share/doc/ps1/18.curses/twinkle1.c, revision 1.1.1.1

1.1       root        1: /*
                      2:  * Copyright (c) 1980 The Regents of the University of California.
                      3:  * All rights reserved.
                      4:  *
                      5:  * Redistribution and use in source and binary forms are permitted
                      6:  * provided that the above copyright notice and this paragraph are
                      7:  * duplicated in all such forms and that any documentation,
                      8:  * advertising materials, and other materials related to such
                      9:  * distribution and use acknowledge that the software was developed
                     10:  * by the University of California, Berkeley.  The name of the
                     11:  * University may not be used to endorse or promote products derived
                     12:  * from this software without specific prior written permission.
                     13:  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
                     14:  * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
                     15:  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
                     16:  */
                     17: 
                     18: #ifndef lint
                     19: char copyright[] =
                     20: "@(#) Copyright (c) 1980 The Regents of the University of California.\n\
                     21:  All rights reserved.\n";
                     22: #endif /* not lint */
                     23: 
                     24: #ifndef lint
                     25: static char sccsid[] = "@(#)twinkle1.c 6.2 (Berkeley) 3/17/89";
                     26: #endif /* not lint */
                     27: 
                     28: # include      <curses.h>
                     29: # include      <signal.h>
                     30: 
                     31: /*
                     32:  * the idea for this program was a product of the imagination of
                     33:  * Kurt Schoens.  Not responsible for minds lost or stolen.
                     34:  */
                     35: 
                     36: # define       NCOLS   80
                     37: # define       NLINES  24
                     38: # define       MAXPATTERNS     4
                     39: 
                     40: typedef struct {
                     41:        int     y, x;
                     42: } LOCS;
                     43: 
                     44: LOCS   Layout[NCOLS * NLINES]; /* current board layout */
                     45: 
                     46: int    Pattern,                /* current pattern number */
                     47:        Numstars;               /* number of stars in pattern */
                     48: 
                     49: char   *getenv();
                     50: 
                     51: int    die();
                     52: 
                     53: main()
                     54: {
                     55:        srand(getpid());                /* initialize random sequence */
                     56: 
                     57:        initscr();
                     58:        signal(SIGINT, die);
                     59:        noecho();
                     60:        nonl();
                     61:        leaveok(stdscr, TRUE);
                     62:        scrollok(stdscr, FALSE);
                     63: 
                     64:        for (;;) {
                     65:                makeboard();            /* make the board setup */
                     66:                puton('*');             /* put on '*'s */
                     67:                puton(' ');             /* cover up with ' 's */
                     68:        }
                     69: }
                     70: 
                     71: /*
                     72:  * On program exit, move the cursor to the lower left corner by
                     73:  * direct addressing, since current location is not guaranteed.
                     74:  * We lie and say we used to be at the upper right corner to guarantee
                     75:  * absolute addressing.
                     76:  */
                     77: die()
                     78: {
                     79:        signal(SIGINT, SIG_IGN);
                     80:        mvcur(0, COLS - 1, LINES - 1, 0);
                     81:        endwin();
                     82:        exit(0);
                     83: }
                     84: 
                     85: 
                     86: /*
                     87:  * Make the current board setup.  It picks a random pattern and
                     88:  * calls ison() to determine if the character is on that pattern
                     89:  * or not.
                     90:  */
                     91: makeboard()
                     92: {
                     93:        reg int         y, x;
                     94:        reg LOCS        *lp;
                     95: 
                     96:        Pattern = rand() % MAXPATTERNS;
                     97:        lp = Layout;
                     98:        for (y = 0; y < NLINES; y++)
                     99:                for (x = 0; x < NCOLS; x++)
                    100:                        if (ison(y, x)) {
                    101:                                lp->y = y;
                    102:                                lp->x = x;
                    103:                                lp++;
                    104:                        }
                    105:        Numstars = lp - Layout;
                    106: }
                    107: 
                    108: /*
                    109:  * Return TRUE if (y, x) is on the current pattern.
                    110:  */
                    111: ison(y, x)
                    112: reg int        y, x; {
                    113: 
                    114:        switch (Pattern) {
                    115:          case 0:       /* alternating lines */
                    116:                return !(y & 01);
                    117:          case 1:       /* box */
                    118:                if (x >= LINES && y >= NCOLS)
                    119:                        return FALSE;
                    120:                if (y < 3 || y >= NLINES - 3)
                    121:                        return TRUE;
                    122:                return (x < 3 || x >= NCOLS - 3);
                    123:          case 2:       /* holy pattern! */
                    124:                return ((x + y) & 01);
                    125:          case 3:       /* bar across center */
                    126:                return (y >= 9 && y <= 15);
                    127:        }
                    128:        /* NOTREACHED */
                    129: }
                    130: 
                    131: puton(ch)
                    132: reg char       ch;
                    133: {
                    134:        reg LOCS        *lp;
                    135:        reg int         r;
                    136:        reg LOCS        *end;
                    137:        LOCS            temp;
                    138: 
                    139:        end = &Layout[Numstars];
                    140:        for (lp = Layout; lp < end; lp++) {
                    141:                r = rand() % Numstars;
                    142:                temp = *lp;
                    143:                *lp = Layout[r];
                    144:                Layout[r] = temp;
                    145:        }
                    146: 
                    147:        for (lp = Layout; lp < end; lp++) {
                    148:                mvaddch(lp->y, lp->x, ch);
                    149:                refresh();
                    150:        }
                    151: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.