test/xmas.c

   1 /******************************************************************************/
   2 /* asciixmas                                                                  */
   3 /* December 1989             Larry Bartz           Indianapolis, IN           */
   4 /*                                                                            */
   5 /*                                                                            */
   6 /* I'm dreaming of an ascii character-based monochrome Christmas,             */
   7 /* Just like the one's I used to know!                                        */
   8 /* Via a full duplex communications channel,                                  */
   9 /* At 9600 bits per second,                                                   */
  10 /* Even though it's kinda slow.                                               */
  11 /*                                                                            */
  12 /* I'm dreaming of an ascii character-based monochrome Christmas,             */
  13 /* With ev'ry C program I write!                                              */
  14 /* May your screen be merry and bright!                                       */
  15 /* And may all your Christmases be amber or green,                            */
  16 /* (for reduced eyestrain and improved visibility)!                           */
  17 /*                                                                            */
  18 /*                                                                            */
  19 /*                                                                            */
  20 /*                                                                            */
  21 /*                                                                            */
  22 /* IMPLEMENTATION                                                             */
  23 /*                                                                            */
  24 /* Feel free to modify the defined string FROMWHO to reflect you, your        */
  25 /* organization, your site, whatever.                                         */
  26 /*                                                                            */
  27 /* This really looks a lot better if you can turn off your cursor before      */
  28 /* execution. I wanted to do that here but very few termcap entries or        */
  29 /* terminfo definitions have the appropriate string defined. If you know      */
  30 /* the string(s) for the terminal(s) you use or which your site supports,     */
  31 /* you could call asciixmas from within a shell in which you issue the        */
  32 /* string to the terminal. The cursor is distracting but it doesn't really    */
  33 /* ruin the show.                                                             */
  34 /*                                                                            */
  35 /* At our site, we invoke this for our users just after login and the         */
  36 /* determination of terminal type.                                            */
  37 /*                                                                            */
  38 /*                                                                            */
  39 /* PORTABILITY                                                                */
  40 /*                                                                            */
  41 /* I wrote this using only the very simplest curses functions so that it      */
  42 /* might be the most portable. I was personally able to test on five          */
  43 /* different cpu/UNIX combinations.                                           */
  44 /*                                                                            */
  45 /*                                                                            */
  46 /* COMPILE                                                                    */
  47 /*                                                                            */
  48 /* usually this:                                                              */
  49 /*                                                                            */
  50 /* cc -O asciixmas.c -lcurses -o asciixmas -s                                 */
  51 /*                                                                            */
  52 /*                                                                            */
  53 /* Zilog S8000 models 11, 21, 31, etc with ZEUS variant of SYSTEM III         */
  54 /* maybe other SYSTEM III also:                                               */
  55 /*                                                                            */
  56 /* cc asciixmas.c -lcurses -ltermlib -o asciixmas -s                          */
  57 /*                                                                            */
  58 /* as above with optional "peephole optimizer" installed:                     */
  59 /*                                                                            */
  60 /* cc -O asciixmas.c -lcurses -ltermlib -o asciixmas -s                       */
  61 /*                                                                            */
  62 /*                                                                            */
  63 /* Zilog S8000 models 32, 130 with WE32100 chip and SYS V, REL2               */
  64 /* maybe 3B2 also?                                                            */
  65 /*                                                                            */
  66 /* cc -f -O -K sd asciixmas.c -lcurses -o asciixmas -s                        */
  67 /*                                                                            */
  68 /*                                                                            */
  69 /* Pyramid, Sequent, any other "dual universe" types compile and execute      */
  70 /* under either universe. The compile line for the ucb universe (as you       */
  71 /* might expect) is the same as for SYS III UNIX:                             */
  72 /*                                                                            */
  73 /* cc -O asciixmas.c -lcurses -ltermlib -o asciixmas -s                       */
  74 /*                                                                            */
  75 /* The above compile will also hold true for other BSD systems. (I hope)      */
  76 /*                                                                            */
  77 /*                                                                            */
  78 /*                                                                            */
  79 /*                                                                            */
  80 /* For the Scrooges out there among you who don't want this thing to loop     */
  81 /* forever (or until the user hits a key), insert this into your compile      */
  82 /* line just after "cc" :                                                     */
  83 /*                                                                            */
  84 /* -DNOLOOP                                                                   */
  85 /*                                                                            */
  86 /* like so:                                                                   */
  87 /*                                                                            */
  88 /* cc -DNOLOOP -O asciixmas.c -lcurses -o asciixmas -s                        */
  89 /*                                                                            */
  90 /*                                                                            */
  91 /*                                                                            */
  92 /******************************************************************************/
  93
  94 /*
  95  * $Id: xmas.c,v 1.12 1998/01/18 01:13:47 tom Exp $
  96  */
  97 #include <test.priv.h>
  98
  99 #include <signal.h>
 100
 101 #define FROMWHO "Mark Hessling - (M.Hessling@gu.edu.au)"
 102
 103 static int my_bg = COLOR_BLACK;
 104 static int y_pos, x_pos;
 105
 106 static WINDOW
 107         *treescrn, *treescrn2,*treescrn3, *treescrn4,*treescrn5, *treescrn6,
 108         *treescrn7, *treescrn8,
 109         *dotdeer0,
 110         *stardeer0,
 111         *lildeer0, *lildeer1, *lildeer2, *lildeer3,
 112         *middeer0, *middeer1, *middeer2, *middeer3,
 113         *bigdeer0, *bigdeer1, *bigdeer2, *bigdeer3, *bigdeer4,
 114         *lookdeer0, *lookdeer1, *lookdeer2, *lookdeer3, *lookdeer4,
 115         *w_holiday,
 116         *w_del_msg;
 117
 118 static int boxit(void);
 119 static int seas(void);
 120 static int greet(void);
 121 static int fromwho(void);
 122 static int tree(void);
 123 static int balls(void);
 124 static int star(void);
 125 static int strng1(void);
 126 static int strng2(void);
 127 static int strng3(void);
 128 static int strng4(void);
 129 static int strng5(void);
 130 static int reindeer(void);
 131 static int blinkit(void);
 132 static RETSIGTYPE done(int sig) GCC_NORETURN ;
 133
 134 static void
 135 set_color(WINDOW *win, chtype color)
 136 {
 137         if (has_colors()) {
 138                 static bool *pairs;
 139                 int n = (color + 1);
 140                 if (pairs == 0)
 141                         pairs = (bool *)calloc(COLORS+1, sizeof(bool));
 142                 if (!pairs[n]) {
 143                         init_pair(n, color, my_bg);
 144                         pairs[n] = TRUE;
 145                 }
 146                 wattroff(win, A_COLOR);
 147                 wattron(win, COLOR_PAIR(n));
 148         }
 149 }
 150
 151 static void
 152 unset_color(WINDOW *win)
 153 {
 154         if (has_colors())
 155                 wattrset(win, COLOR_PAIR(0));
 156 }
 157
 158 static void
 159 look_out(int msecs)
 160 {
 161         napms(msecs);
 162         if (getch() != ERR) {
 163                 beep();
 164                 done(0);
 165         }
 166 }
 167
 168 int main(
 169         int argc GCC_UNUSED,
 170         char **argv GCC_UNUSED)
 171 {
 172 int loopy;
 173
 174         initscr();
 175         noecho();
 176         nonl();
 177         refresh();
 178         signal(SIGINT,done);
 179         signal(SIGTERM,done);
 180 #if !defined    DOS && !defined OS2
 181         signal(SIGHUP,done);
 182         signal(SIGQUIT,done);
 183 #endif
 184         if (has_colors()) {
 185                 start_color();
 186 #ifdef NCURSES_VERSION
 187                 if (use_default_colors() == OK)
 188                         my_bg = -1;
 189 #endif
 190         }
 191         curs_set(0);
 192
 193         treescrn = newwin(16,27,3,53);
 194         treescrn2 = newwin(16,27,3,53);
 195         treescrn3 = newwin(16,27,3,53);
 196         treescrn4 = newwin(16,27,3,53);
 197         treescrn5 = newwin(16,27,3,53);
 198         treescrn6 = newwin(16,27,3,53);
 199         treescrn7 = newwin(16,27,3,53);
 200         treescrn8 = newwin(16,27,3,53);
 201
 202         dotdeer0 = newwin(3,71,0,8);
 203
 204         stardeer0 = newwin(4,56,0,8);
 205
 206         lildeer0 = newwin(7,53,0,8);
 207         lildeer1 = newwin(2,4,0,0);
 208         lildeer2 = newwin(2,4,0,0);
 209         lildeer3 = newwin(2,4,0,0);
 210
 211         middeer0 = newwin(15,42,0,8);
 212         middeer1 = newwin(3,7,0,0);
 213         middeer2 = newwin(3,7,0,0);
 214         middeer3 = newwin(3,7,0,0);
 215
 216         bigdeer0 = newwin(10,23,0,0);
 217         bigdeer1 = newwin(10,23,0,0);
 218         bigdeer2 = newwin(10,23,0,0);
 219         bigdeer3 = newwin(10,23,0,0);
 220         bigdeer4 = newwin(10,23,0,0);
 221
 222         lookdeer0 = newwin(10,25,0,0);
 223         lookdeer1 = newwin(10,25,0,0);
 224         lookdeer2 = newwin(10,25,0,0);
 225         lookdeer3 = newwin(10,25,0,0);
 226         lookdeer4 = newwin(10,25,0,0);
 227
 228         w_holiday = newwin(1,26,3,27);
 229
 230         w_del_msg = newwin(1,19,23,60);
 231
 232         mvwaddstr(w_del_msg,0,0,"Hit any key to quit");
 233
 234         mvwaddstr(w_holiday,0,0,"H A P P Y  H O L I D A Y S");
 235
 236         /* set up the windows for our various reindeer */
 237
 238         /* lildeer1 */
 239         mvwaddch(lildeer1,0,0,(chtype)'V');
 240         mvwaddch(lildeer1,1,0,(chtype)'@');
 241         mvwaddch(lildeer1,1,1,(chtype)'<');
 242         mvwaddch(lildeer1,1,2,(chtype)'>');
 243         mvwaddch(lildeer1,1,3,(chtype)'~');
 244
 245         /* lildeer2 */
 246         mvwaddch(lildeer2,0,0,(chtype)'V');
 247         mvwaddch(lildeer2,1,0,(chtype)'@');
 248         mvwaddch(lildeer2,1,1,(chtype)'|');
 249         mvwaddch(lildeer2,1,2,(chtype)'|');
 250         mvwaddch(lildeer2,1,3,(chtype)'~');
 251
 252         /* lildeer3 */
 253         mvwaddch(lildeer3,0,0,(chtype)'V');
 254         mvwaddch(lildeer3,1,0,(chtype)'@');
 255         mvwaddch(lildeer3,1,1,(chtype)'>');
 256         mvwaddch(lildeer3,1,2,(chtype)'<');
 257         mvwaddch(lildeer2,1,3,(chtype)'~');
 258
 259
 260         /* middeer1 */
 261         mvwaddch(middeer1,0,2,(chtype)'y');
 262         mvwaddch(middeer1,0,3,(chtype)'y');
 263         mvwaddch(middeer1,1,2,(chtype)'0');
 264         mvwaddch(middeer1,1,3,(chtype)'(');
 265         mvwaddch(middeer1,1,4,(chtype)'=');
 266         mvwaddch(middeer1,1,5,(chtype)')');
 267         mvwaddch(middeer1,1,6,(chtype)'~');
 268         mvwaddch(middeer1,2,3,(chtype)'\\');
 269         mvwaddch(middeer1,2,4,(chtype)'/');
 270
 271         /* middeer2 */
 272         mvwaddch(middeer2,0,2,(chtype)'y');
 273         mvwaddch(middeer2,0,3,(chtype)'y');
 274         mvwaddch(middeer2,1,2,(chtype)'0');
 275         mvwaddch(middeer2,1,3,(chtype)'(');
 276         mvwaddch(middeer2,1,4,(chtype)'=');
 277         mvwaddch(middeer2,1,5,(chtype)')');
 278         mvwaddch(middeer2,1,6,(chtype)'~');
 279         mvwaddch(middeer2,2,3,(chtype)'|');
 280         mvwaddch(middeer2,2,5,(chtype)'|');
 281
 282         /* middeer3 */
 283         mvwaddch(middeer3,0,2,(chtype)'y');
 284         mvwaddch(middeer3,0,3,(chtype)'y');
 285         mvwaddch(middeer3,1,2,(chtype)'0');
 286         mvwaddch(middeer3,1,3,(chtype)'(');
 287         mvwaddch(middeer3,1,4,(chtype)'=');
 288         mvwaddch(middeer3,1,5,(chtype)')');
 289         mvwaddch(middeer3,1,6,(chtype)'~');
 290         mvwaddch(middeer3,2,2,(chtype)'/');
 291         mvwaddch(middeer3,2,6,(chtype)'\\');
 292
 293
 294         /* bigdeer1 */
 295         mvwaddch(bigdeer1,0,17,(chtype)'\\');
 296         mvwaddch(bigdeer1,0,18,(chtype)'/');
 297         mvwaddch(bigdeer1,0,20,(chtype)'\\');
 298         mvwaddch(bigdeer1,0,21,(chtype)'/');
 299         mvwaddch(bigdeer1,1,18,(chtype)'\\');
 300         mvwaddch(bigdeer1,1,20,(chtype)'/');
 301         mvwaddch(bigdeer1,2,19,(chtype)'|');
 302         mvwaddch(bigdeer1,2,20,(chtype)'_');
 303         mvwaddch(bigdeer1,3,18,(chtype)'/');
 304         mvwaddch(bigdeer1,3,19,(chtype)'^');
 305         mvwaddch(bigdeer1,3,20,(chtype)'0');
 306         mvwaddch(bigdeer1,3,21,(chtype)'\\');
 307         mvwaddch(bigdeer1,4,17,(chtype)'/');
 308         mvwaddch(bigdeer1,4,18,(chtype)'/');
 309         mvwaddch(bigdeer1,4,19,(chtype)'\\');
 310         mvwaddch(bigdeer1,4,22,(chtype)'\\');
 311         mvwaddstr(bigdeer1,5,7,"^~~~~~~~~//  ~~U");
 312         mvwaddstr(bigdeer1,6,7,"( \\_____( /");
 313         mvwaddstr(bigdeer1,7,8,"( )    /");
 314         mvwaddstr(bigdeer1,8,9,"\\\\   /");
 315         mvwaddstr(bigdeer1,9,11,"\\>/>");
 316
 317         /* bigdeer2 */
 318         mvwaddch(bigdeer2,0,17,(chtype)'\\');
 319         mvwaddch(bigdeer2,0,18,(chtype)'/');
 320         mvwaddch(bigdeer2,0,20,(chtype)'\\');
 321         mvwaddch(bigdeer2,0,21,(chtype)'/');
 322         mvwaddch(bigdeer2,1,18,(chtype)'\\');
 323         mvwaddch(bigdeer2,1,20,(chtype)'/');
 324         mvwaddch(bigdeer2,2,19,(chtype)'|');
 325         mvwaddch(bigdeer2,2,20,(chtype)'_');
 326         mvwaddch(bigdeer2,3,18,(chtype)'/');
 327         mvwaddch(bigdeer2,3,19,(chtype)'^');
 328         mvwaddch(bigdeer2,3,20,(chtype)'0');
 329         mvwaddch(bigdeer2,3,21,(chtype)'\\');
 330         mvwaddch(bigdeer2,4,17,(chtype)'/');
 331         mvwaddch(bigdeer2,4,18,(chtype)'/');
 332         mvwaddch(bigdeer2,4,19,(chtype)'\\');
 333         mvwaddch(bigdeer2,4,22,(chtype)'\\');
 334         mvwaddstr(bigdeer2,5,7,"^~~~~~~~~//  ~~U");
 335         mvwaddstr(bigdeer2,6,7,"(( )____( /");
 336         mvwaddstr(bigdeer2,7,7,"( /      |");
 337         mvwaddstr(bigdeer2,8,8,"\\/      |");
 338         mvwaddstr(bigdeer2,9,9,"|>     |>");
 339
 340         /* bigdeer3 */
 341         mvwaddch(bigdeer3,0,17,(chtype)'\\');
 342         mvwaddch(bigdeer3,0,18,(chtype)'/');
 343         mvwaddch(bigdeer3,0,20,(chtype)'\\');
 344         mvwaddch(bigdeer3,0,21,(chtype)'/');
 345         mvwaddch(bigdeer3,1,18,(chtype)'\\');
 346         mvwaddch(bigdeer3,1,20,(chtype)'/');
 347         mvwaddch(bigdeer3,2,19,(chtype)'|');
 348         mvwaddch(bigdeer3,2,20,(chtype)'_');
 349         mvwaddch(bigdeer3,3,18,(chtype)'/');
 350         mvwaddch(bigdeer3,3,19,(chtype)'^');
 351         mvwaddch(bigdeer3,3,20,(chtype)'0');
 352         mvwaddch(bigdeer3,3,21,(chtype)'\\');
 353         mvwaddch(bigdeer3,4,17,(chtype)'/');
 354         mvwaddch(bigdeer3,4,18,(chtype)'/');
 355         mvwaddch(bigdeer3,4,19,(chtype)'\\');
 356         mvwaddch(bigdeer3,4,22,(chtype)'\\');
 357         mvwaddstr(bigdeer3,5,7,"^~~~~~~~~//  ~~U");
 358         mvwaddstr(bigdeer3,6,6,"( ()_____( /");
 359         mvwaddstr(bigdeer3,7,6,"/ /       /");
 360         mvwaddstr(bigdeer3,8,5,"|/          \\");
 361         mvwaddstr(bigdeer3,9,5,"/>           \\>");
 362
 363         /* bigdeer4 */
 364         mvwaddch(bigdeer4,0,17,(chtype)'\\');
 365         mvwaddch(bigdeer4,0,18,(chtype)'/');
 366         mvwaddch(bigdeer4,0,20,(chtype)'\\');
 367         mvwaddch(bigdeer4,0,21,(chtype)'/');
 368         mvwaddch(bigdeer4,1,18,(chtype)'\\');
 369         mvwaddch(bigdeer4,1,20,(chtype)'/');
 370         mvwaddch(bigdeer4,2,19,(chtype)'|');
 371         mvwaddch(bigdeer4,2,20,(chtype)'_');
 372         mvwaddch(bigdeer4,3,18,(chtype)'/');
 373         mvwaddch(bigdeer4,3,19,(chtype)'^');
 374         mvwaddch(bigdeer4,3,20,(chtype)'0');
 375         mvwaddch(bigdeer4,3,21,(chtype)'\\');
 376         mvwaddch(bigdeer4,4,17,(chtype)'/');
 377         mvwaddch(bigdeer4,4,18,(chtype)'/');
 378         mvwaddch(bigdeer4,4,19,(chtype)'\\');
 379         mvwaddch(bigdeer4,4,22,(chtype)'\\');
 380         mvwaddstr(bigdeer4,5,7,"^~~~~~~~~//  ~~U");
 381         mvwaddstr(bigdeer4,6,6,"( )______( /");
 382         mvwaddstr(bigdeer4,7,5,"(/          \\");
 383         mvwaddstr(bigdeer4,8,0,"v___=             ----^");
 384
 385
 386         /* lookdeer1 */
 387         mvwaddstr(lookdeer1,0,16,"\\/     \\/");
 388         mvwaddstr(lookdeer1,1,17,"\\Y/ \\Y/");
 389         mvwaddstr(lookdeer1,2,19,"\\=/");
 390         mvwaddstr(lookdeer1,3,17,"^\\o o/^");
 391         mvwaddstr(lookdeer1,4,17,"//( )");
 392         mvwaddstr(lookdeer1,5,7,"^~~~~~~~~// \\O/");
 393         mvwaddstr(lookdeer1,6,7,"( \\_____( /");
 394         mvwaddstr(lookdeer1,7,8,"( )    /");
 395         mvwaddstr(lookdeer1,8,9,"\\\\   /");
 396         mvwaddstr(lookdeer1,9,11,"\\>/>");
 397
 398         /* lookdeer2 */
 399         mvwaddstr(lookdeer2,0,16,"\\/     \\/");
 400         mvwaddstr(lookdeer2,1,17,"\\Y/ \\Y/");
 401         mvwaddstr(lookdeer2,2,19,"\\=/");
 402         mvwaddstr(lookdeer2,3,17,"^\\o o/^");
 403         mvwaddstr(lookdeer2,4,17,"//( )");
 404         mvwaddstr(lookdeer2,5,7,"^~~~~~~~~// \\O/");
 405         mvwaddstr(lookdeer2,6,7,"(( )____( /");
 406         mvwaddstr(lookdeer2,7,7,"( /      |");
 407         mvwaddstr(lookdeer2,8,8,"\\/      |");
 408         mvwaddstr(lookdeer2,9,9,"|>     |>");
 409
 410         /* lookdeer3 */
 411         mvwaddstr(lookdeer3,0,16,"\\/     \\/");
 412         mvwaddstr(lookdeer3,1,17,"\\Y/ \\Y/");
 413         mvwaddstr(lookdeer3,2,19,"\\=/");
 414         mvwaddstr(lookdeer3,3,17,"^\\o o/^");
 415         mvwaddstr(lookdeer3,4,17,"//( )");
 416         mvwaddstr(lookdeer3,5,7,"^~~~~~~~~// \\O/");
 417         mvwaddstr(lookdeer3,6,6,"( ()_____( /");
 418         mvwaddstr(lookdeer3,7,6,"/ /       /");
 419         mvwaddstr(lookdeer3,8,5,"|/          \\");
 420         mvwaddstr(lookdeer3,9,5,"/>           \\>");
 421
 422         /* lookdeer4 */
 423         mvwaddstr(lookdeer4,0,16,"\\/     \\/");
 424         mvwaddstr(lookdeer4,1,17,"\\Y/ \\Y/");
 425         mvwaddstr(lookdeer4,2,19,"\\=/");
 426         mvwaddstr(lookdeer4,3,17,"^\\o o/^");
 427         mvwaddstr(lookdeer4,4,17,"//( )");
 428         mvwaddstr(lookdeer4,5,7,"^~~~~~~~~// \\O/");
 429         mvwaddstr(lookdeer4,6,6,"( )______( /");
 430         mvwaddstr(lookdeer4,7,5,"(/          \\");
 431         mvwaddstr(lookdeer4,8,0,"v___=             ----^");
 432
 433
 434
 435         /***********************************************/
 436         cbreak();
 437         nodelay(stdscr,TRUE);
 438         for (;;) {
 439           clear();
 440           werase(treescrn);
 441           touchwin(w_del_msg);
 442           touchwin(treescrn);
 443           werase(treescrn2);
 444           touchwin(treescrn2);
 445           werase(treescrn8);
 446           touchwin(treescrn8);
 447           refresh();
 448           look_out(150);
 449           boxit();
 450           refresh();
 451           look_out(150);
 452           seas();
 453           refresh();
 454           look_out(150);
 455           greet();
 456           refresh();
 457           look_out(150);
 458           fromwho();
 459           refresh();
 460           look_out(150);
 461           tree();
 462           look_out(150);
 463           balls();
 464           look_out(150);
 465           star();
 466           look_out(150);
 467           strng1();
 468           strng2();
 469           strng3();
 470           strng4();
 471           strng5();
 472
 473
 474         /* set up the windows for our blinking trees */
 475         /* **************************************** */
 476         /* treescrn3 */
 477
 478            overlay(treescrn, treescrn3);
 479
 480            /*balls*/
 481            mvwaddch(treescrn3, 4, 18, ' ');
 482            mvwaddch(treescrn3, 7, 6, ' ');
 483            mvwaddch(treescrn3, 8, 19, ' ');
 484            mvwaddch(treescrn3, 11, 22, ' ');
 485
 486            /*star*/
 487            mvwaddch(treescrn3, 0, 12, '*');
 488
 489            /*strng1*/
 490            mvwaddch(treescrn3, 3, 11, ' ');
 491
 492            /*strng2*/
 493            mvwaddch(treescrn3, 5, 13, ' ');
 494            mvwaddch(treescrn3, 6, 10, ' ');
 495
 496            /*strng3*/
 497            mvwaddch(treescrn3, 7, 16, ' ');
 498            mvwaddch(treescrn3, 7, 14, ' ');
 499
 500                    /*strng4*/
 501            mvwaddch(treescrn3, 10, 13, ' ');
 502            mvwaddch(treescrn3, 10, 10, ' ');
 503            mvwaddch(treescrn3, 11, 8, ' ');
 504
 505                    /*strng5*/
 506            mvwaddch(treescrn3, 11, 18, ' ');
 507            mvwaddch(treescrn3, 12, 13, ' ');
 508
 509
 510         /* treescrn4 */
 511
 512            overlay(treescrn, treescrn4);
 513
 514            /*balls*/
 515            mvwaddch(treescrn4, 3, 9, ' ');
 516            mvwaddch(treescrn4, 4, 16, ' ');
 517            mvwaddch(treescrn4, 7, 6, ' ');
 518            mvwaddch(treescrn4, 8, 19, ' ');
 519            mvwaddch(treescrn4, 11, 2, ' ');
 520            mvwaddch(treescrn4, 12, 23, ' ');
 521
 522            /*star*/
 523            wstandout(treescrn4);
 524            mvwaddch(treescrn4, 0, 12, '*');
 525            wstandend(treescrn4);
 526
 527            /*strng1*/
 528            mvwaddch(treescrn4, 3, 13, ' ');
 529
 530            /*strng2*/
 531
 532            /*strng3*/
 533            mvwaddch(treescrn4, 7, 15, ' ');
 534            mvwaddch(treescrn4, 8, 11, ' ');
 535
 536            /*strng4*/
 537            mvwaddch(treescrn4, 9, 16, ' ');
 538            mvwaddch(treescrn4, 10, 12, ' ');
 539            mvwaddch(treescrn4, 11, 8, ' ');
 540
 541            /*strng5*/
 542            mvwaddch(treescrn4, 11, 18, ' ');
 543            mvwaddch(treescrn4, 12, 14, ' ');
 544
 545
 546         /* treescrn5 */
 547
 548            overlay(treescrn, treescrn5);
 549
 550            /*balls*/
 551            mvwaddch(treescrn5, 3, 15, ' ');
 552            mvwaddch(treescrn5, 10, 20, ' ');
 553            mvwaddch(treescrn5, 12, 1, ' ');
 554
 555            /*star*/
 556            mvwaddch(treescrn5, 0, 12, '*');
 557
 558            /*strng1*/
 559            mvwaddch(treescrn5, 3, 11, ' ');
 560
 561            /*strng2*/
 562            mvwaddch(treescrn5, 5, 12, ' ');
 563
 564            /*strng3*/
 565            mvwaddch(treescrn5, 7, 14, ' ');
 566            mvwaddch(treescrn5, 8, 10, ' ');
 567
 568            /*strng4*/
 569            mvwaddch(treescrn5, 9, 15, ' ');
 570            mvwaddch(treescrn5, 10, 11, ' ');
 571            mvwaddch(treescrn5, 11, 7, ' ');
 572
 573            /*strng5*/
 574            mvwaddch(treescrn5, 11, 17, ' ');
 575            mvwaddch(treescrn5, 12, 13, ' ');
 576
 577         /* treescrn6 */
 578
 579            overlay(treescrn, treescrn6);
 580
 581            /*balls*/
 582            mvwaddch(treescrn6, 6, 7, ' ');
 583            mvwaddch(treescrn6, 7, 18, ' ');
 584            mvwaddch(treescrn6, 10, 4, ' ');
 585            mvwaddch(treescrn6, 11, 23, ' ');
 586
 587            /*star*/
 588            wstandout(treescrn6);
 589            mvwaddch(treescrn6, 0, 12, '*');
 590            wstandend(treescrn6);
 591
 592            /*strng1*/
 593
 594            /*strng2*/
 595            mvwaddch(treescrn6, 5, 11, ' ');
 596
 597            /*strng3*/
 598            mvwaddch(treescrn6, 7, 13, ' ');
 599            mvwaddch(treescrn6, 8, 9, ' ');
 600
 601            /*strng4*/
 602            mvwaddch(treescrn6, 9, 14, ' ');
 603            mvwaddch(treescrn6, 10, 10, ' ');
 604            mvwaddch(treescrn6, 11, 6, ' ');
 605
 606            /*strng5*/
 607            mvwaddch(treescrn6, 11, 16, ' ');
 608            mvwaddch(treescrn6, 12, 12, ' ');
 609
 610         /* treescrn7 */
 611
 612            overlay(treescrn, treescrn7);
 613
 614            /*balls*/
 615            mvwaddch(treescrn7, 3, 15, ' ');
 616            mvwaddch(treescrn7, 6, 7, ' ');
 617            mvwaddch(treescrn7, 7, 18, ' ');
 618            mvwaddch(treescrn7, 10, 4, ' ');
 619            mvwaddch(treescrn7, 11, 22, ' ');
 620
 621            /*star*/
 622            mvwaddch(treescrn7, 0, 12, '*');
 623
 624            /*strng1*/
 625            mvwaddch(treescrn7, 3, 12, ' ');
 626
 627            /*strng2*/
 628            mvwaddch(treescrn7, 5, 13, ' ');
 629            mvwaddch(treescrn7, 6, 9, ' ');
 630
 631            /*strng3*/
 632            mvwaddch(treescrn7, 7, 15, ' ');
 633            mvwaddch(treescrn7, 8, 11, ' ');
 634
 635            /*strng4*/
 636            mvwaddch(treescrn7, 9, 16, ' ');
 637            mvwaddch(treescrn7, 10, 12, ' ');
 638            mvwaddch(treescrn7, 11, 8, ' ');
 639
 640            /*strng5*/
 641            mvwaddch(treescrn7, 11, 18, ' ');
 642            mvwaddch(treescrn7, 12, 14, ' ');
 643
 644
 645            look_out(150);
 646            reindeer();
 647
 648            touchwin(w_holiday);
 649            wrefresh(w_holiday);
 650            wrefresh(w_del_msg);
 651
 652            look_out(500);
 653            for(loopy = 0;loopy < 100;loopy++) {
 654                 blinkit();
 655            }
 656
 657 #ifdef NOLOOP
 658            done(0);
 659 #endif
 660         }
 661         /*NOTREACHED*/
 662 }
 663
 664 static int boxit(void)
 665 {
 666  int x = 0;
 667
 668         while(x < 20) {
 669           mvaddch(x, 7, '|');
 670           ++x;
 671         }
 672
 673         x = 8;
 674
 675         while(x < 80) {
 676           mvaddch(19, x, '_');
 677           ++x;
 678         }
 679
 680         x = 0;
 681
 682         while(x < 80) {
 683           mvaddch(22, x, '_');
 684           ++x;
 685         }
 686
 687         return( 0 );
 688 }
 689
 690 static int seas(void)
 691 {
 692         mvaddch(4, 1, 'S');
 693         mvaddch(6, 1, 'E');
 694         mvaddch(8, 1, 'A');
 695         mvaddch(10, 1, 'S');
 696         mvaddch(12, 1, 'O');
 697         mvaddch(14, 1, 'N');
 698         mvaddch(16, 1, '`');
 699         mvaddch(18, 1, 'S');
 700
 701         return( 0 );
 702 }
 703
 704
 705 static int greet(void)
 706 {
 707         mvaddch(3, 5, 'G');
 708         mvaddch(5, 5, 'R');
 709         mvaddch(7, 5, 'E');
 710         mvaddch(9, 5, 'E');
 711         mvaddch(11, 5, 'T');
 712         mvaddch(13, 5, 'I');
 713         mvaddch(15, 5, 'N');
 714         mvaddch(17, 5, 'G');
 715         mvaddch(19, 5, 'S');
 716
 717         return( 0 );
 718 }
 719
 720
 721 static int fromwho(void)
 722 {
 723         mvaddstr(21, 13, FROMWHO);
 724         return( 0 );
 725 }
 726
 727 static int tree(void)
 728 {
 729         set_color(treescrn, COLOR_GREEN);
 730         mvwaddch(treescrn, 1, 11, (chtype)'/');
 731         mvwaddch(treescrn, 2, 11, (chtype)'/');
 732         mvwaddch(treescrn, 3, 10, (chtype)'/');
 733         mvwaddch(treescrn, 4, 9, (chtype)'/');
 734         mvwaddch(treescrn, 5, 9, (chtype)'/');
 735         mvwaddch(treescrn, 6, 8, (chtype)'/');
 736         mvwaddch(treescrn, 7, 7, (chtype)'/');
 737         mvwaddch(treescrn, 8, 6, (chtype)'/');
 738         mvwaddch(treescrn, 9, 6, (chtype)'/');
 739         mvwaddch(treescrn, 10, 5, (chtype)'/');
 740         mvwaddch(treescrn, 11, 3, (chtype)'/');
 741         mvwaddch(treescrn, 12, 2, (chtype)'/');
 742
 743         mvwaddch(treescrn, 1, 13, (chtype)'\\');
 744         mvwaddch(treescrn, 2, 13, (chtype)'\\');
 745         mvwaddch(treescrn, 3, 14, (chtype)'\\');
 746         mvwaddch(treescrn, 4, 15, (chtype)'\\');
 747         mvwaddch(treescrn, 5, 15, (chtype)'\\');
 748         mvwaddch(treescrn, 6, 16, (chtype)'\\');
 749         mvwaddch(treescrn, 7, 17, (chtype)'\\');
 750         mvwaddch(treescrn, 8, 18, (chtype)'\\');
 751         mvwaddch(treescrn, 9, 18, (chtype)'\\');
 752         mvwaddch(treescrn, 10, 19, (chtype)'\\');
 753         mvwaddch(treescrn, 11, 21, (chtype)'\\');
 754         mvwaddch(treescrn, 12, 22, (chtype)'\\');
 755
 756         mvwaddch(treescrn, 4, 10, (chtype)'_');
 757         mvwaddch(treescrn, 4, 14, (chtype)'_');
 758         mvwaddch(treescrn, 8, 7, (chtype)'_');
 759         mvwaddch(treescrn, 8, 17, (chtype)'_');
 760
 761         mvwaddstr(treescrn, 13, 0, "//////////// \\\\\\\\\\\\\\\\\\\\\\\\");
 762
 763         mvwaddstr(treescrn, 14, 11, "| |");
 764         mvwaddstr(treescrn, 15, 11, "|_|");
 765
 766         unset_color(treescrn);
 767         wrefresh(treescrn);
 768         wrefresh(w_del_msg);
 769
 770         return( 0 );
 771 }
 772
 773
 774 static int balls(void)
 775 {
 776         overlay(treescrn, treescrn2);
 777
 778         set_color(treescrn2, COLOR_BLUE);
 779         mvwaddch(treescrn2, 3, 9, (chtype)'@');
 780         mvwaddch(treescrn2, 3, 15, (chtype)'@');
 781         mvwaddch(treescrn2, 4, 8, (chtype)'@');
 782         mvwaddch(treescrn2, 4, 16, (chtype)'@');
 783         mvwaddch(treescrn2, 5, 7, (chtype)'@');
 784         mvwaddch(treescrn2, 5, 17, (chtype)'@');
 785         mvwaddch(treescrn2, 7, 6, (chtype)'@');
 786         mvwaddch(treescrn2, 7, 18, (chtype)'@');
 787         mvwaddch(treescrn2, 8, 5, (chtype)'@');
 788         mvwaddch(treescrn2, 8, 19, (chtype)'@');
 789         mvwaddch(treescrn2, 10, 4, (chtype)'@');
 790         mvwaddch(treescrn2, 10, 20, (chtype)'@');
 791         mvwaddch(treescrn2, 11, 2, (chtype)'@');
 792         mvwaddch(treescrn2, 11, 22, (chtype)'@');
 793         mvwaddch(treescrn2, 12, 1, (chtype)'@');
 794         mvwaddch(treescrn2, 12, 23, (chtype)'@');
 795
 796         unset_color(treescrn2);
 797         wrefresh(treescrn2);
 798         wrefresh(w_del_msg);
 799         return( 0 );
 800 }
 801
 802
 803 static int star(void)
 804 {
 805         wattrset(treescrn2, A_BOLD | A_BLINK);
 806         set_color(treescrn2, COLOR_YELLOW);
 807
 808         mvwaddch(treescrn2, 0, 12, (chtype)'*');
 809         wstandend(treescrn2);
 810
 811         unset_color(treescrn2);
 812         wrefresh(treescrn2);
 813         wrefresh(w_del_msg);
 814         return( 0 );
 815 }
 816
 817
 818 static int strng1(void)
 819 {
 820         wattrset(treescrn2, A_BOLD | A_BLINK);
 821         set_color(treescrn2, COLOR_WHITE);
 822
 823         mvwaddch(treescrn2, 3, 13, (chtype)'\'');
 824         mvwaddch(treescrn2, 3, 12, (chtype)':');
 825         mvwaddch(treescrn2, 3, 11, (chtype)'.');
 826
 827         wattroff(treescrn2, A_BOLD | A_BLINK);
 828         unset_color(treescrn2);
 829
 830         wrefresh(treescrn2);
 831         wrefresh(w_del_msg);
 832         return( 0 );
 833 }
 834
 835
 836 static int strng2(void)
 837 {
 838         wattrset(treescrn2, A_BOLD | A_BLINK);
 839         set_color(treescrn2, COLOR_WHITE);
 840
 841         mvwaddch(treescrn2, 5, 14, (chtype)'\'');
 842         mvwaddch(treescrn2, 5, 13, (chtype)':');
 843         mvwaddch(treescrn2, 5, 12, (chtype)'.');
 844         mvwaddch(treescrn2, 5, 11, (chtype)',');
 845         mvwaddch(treescrn2, 6, 10, (chtype)'\'');
 846         mvwaddch(treescrn2, 6, 9, (chtype)':');
 847
 848         wattroff(treescrn2, A_BOLD | A_BLINK);
 849         unset_color(treescrn2);
 850
 851         wrefresh(treescrn2);
 852         wrefresh(w_del_msg);
 853         return( 0 );
 854 }
 855
 856
 857 static int strng3(void)
 858 {
 859         wattrset(treescrn2, A_BOLD | A_BLINK);
 860         set_color(treescrn2, COLOR_WHITE);
 861
 862         mvwaddch(treescrn2, 7, 16, (chtype)'\'');
 863         mvwaddch(treescrn2, 7, 15, (chtype)':');
 864         mvwaddch(treescrn2, 7, 14, (chtype)'.');
 865         mvwaddch(treescrn2, 7, 13, (chtype)',');
 866         mvwaddch(treescrn2, 8, 12, (chtype)'\'');
 867         mvwaddch(treescrn2, 8, 11, (chtype)':');
 868         mvwaddch(treescrn2, 8, 10, (chtype)'.');
 869         mvwaddch(treescrn2, 8, 9, (chtype)',');
 870
 871         wattroff(treescrn2, A_BOLD | A_BLINK);
 872         unset_color(treescrn2);
 873
 874         wrefresh(treescrn2);
 875         wrefresh(w_del_msg);
 876         return( 0 );
 877 }
 878
 879
 880 static int strng4(void)
 881 {
 882         wattrset(treescrn2, A_BOLD | A_BLINK);
 883         set_color(treescrn2, COLOR_WHITE);
 884
 885         mvwaddch(treescrn2, 9, 17, (chtype)'\'');
 886         mvwaddch(treescrn2, 9, 16, (chtype)':');
 887         mvwaddch(treescrn2, 9, 15, (chtype)'.');
 888         mvwaddch(treescrn2, 9, 14, (chtype)',');
 889         mvwaddch(treescrn2, 10, 13, (chtype)'\'');
 890         mvwaddch(treescrn2, 10, 12, (chtype)':');
 891         mvwaddch(treescrn2, 10, 11, (chtype)'.');
 892         mvwaddch(treescrn2, 10, 10, (chtype)',');
 893         mvwaddch(treescrn2, 11, 9, (chtype)'\'');
 894         mvwaddch(treescrn2, 11, 8, (chtype)':');
 895         mvwaddch(treescrn2, 11, 7, (chtype)'.');
 896         mvwaddch(treescrn2, 11, 6, (chtype)',');
 897         mvwaddch(treescrn2, 12, 5, (chtype)'\'');
 898
 899         wattroff(treescrn2, A_BOLD | A_BLINK);
 900         unset_color(treescrn2);
 901
 902         wrefresh(treescrn2);
 903         wrefresh(w_del_msg);
 904         return( 0 );
 905 }
 906
 907
 908 static int strng5(void)
 909 {
 910         wattrset(treescrn2, A_BOLD | A_BLINK);
 911         set_color(treescrn2, COLOR_WHITE);
 912
 913         mvwaddch(treescrn2, 11, 19, (chtype)'\'');
 914         mvwaddch(treescrn2, 11, 18, (chtype)':');
 915         mvwaddch(treescrn2, 11, 17, (chtype)'.');
 916         mvwaddch(treescrn2, 11, 16, (chtype)',');
 917         mvwaddch(treescrn2, 12, 15, (chtype)'\'');
 918         mvwaddch(treescrn2, 12, 14, (chtype)':');
 919         mvwaddch(treescrn2, 12, 13, (chtype)'.');
 920         mvwaddch(treescrn2, 12, 12, (chtype)',');
 921
 922         wattroff(treescrn2, A_BOLD | A_BLINK);
 923         unset_color(treescrn2);
 924
 925         /* save a fully lit tree */
 926         overlay(treescrn2, treescrn);
 927
 928         wrefresh(treescrn2);
 929         wrefresh(w_del_msg);
 930         return( 0 );
 931 }
 932
 933
 934
 935 static int blinkit(void)
 936 {
 937 static int cycle;
 938
 939         if(cycle > 4) {
 940           cycle = 0;
 941         }
 942
 943
 944         touchwin(treescrn8);
 945
 946         switch(cycle) {
 947           case 0:
 948                      overlay(treescrn3, treescrn8);
 949                      wrefresh(treescrn8);
 950                      wrefresh(w_del_msg);
 951                      break;
 952           case 1:
 953                      overlay(treescrn4, treescrn8);
 954                      wrefresh(treescrn8);
 955                      wrefresh(w_del_msg);
 956                      break;
 957           case 2:
 958                      overlay(treescrn5, treescrn8);
 959                      wrefresh(treescrn8);
 960                      wrefresh(w_del_msg);
 961                      break;
 962           case 3:
 963                      overlay(treescrn6, treescrn8);
 964                      wrefresh(treescrn8);
 965                      wrefresh(w_del_msg);
 966                      break;
 967           case 4:
 968                      overlay(treescrn7, treescrn8);
 969                      wrefresh(treescrn8);
 970                      wrefresh(w_del_msg);
 971                      break;
 972         }
 973          touchwin(treescrn8);
 974
 975          /*ALL ON***************************************************/
 976
 977          overlay(treescrn, treescrn8);
 978          wrefresh(treescrn8);
 979          wrefresh(w_del_msg);
 980
 981         ++cycle;
 982         return( 0 );
 983 }
 984
 985 static void
 986 deer_step(WINDOW *win, int y, int x)
 987 {
 988             mvwin(win, y, x);
 989             wrefresh(win);
 990             wrefresh(w_del_msg);
 991             look_out(5);
 992 }
 993
 994 static int reindeer(void)
 995 {
 996  int looper;
 997  y_pos = 0;
 998
 999
1000         for(x_pos = 70; x_pos > 62; x_pos--) {
1001           if(x_pos < 62) {
1002             y_pos = 1;
1003           }
1004           for(looper = 0; looper < 4; looper++) {
1005             mvwaddch(dotdeer0, y_pos, x_pos, (chtype)'.');
1006             wrefresh(dotdeer0);
1007             wrefresh(w_del_msg);
1008             werase(dotdeer0);
1009             wrefresh(dotdeer0);
1010             wrefresh(w_del_msg);
1011             look_out(50);
1012           }
1013         }
1014
1015         y_pos = 2;
1016
1017         for(; x_pos > 50; x_pos--) {
1018           for(looper = 0; looper < 4; looper++) {
1019
1020             if(x_pos < 56) {
1021               y_pos = 3;
1022
1023               mvwaddch(stardeer0, y_pos, x_pos, (chtype)'*');
1024               wrefresh(stardeer0);
1025               wrefresh(w_del_msg);
1026               werase(stardeer0);
1027               wrefresh(stardeer0);
1028               wrefresh(w_del_msg);
1029             } else {
1030               mvwaddch(dotdeer0, y_pos, x_pos, (chtype)'*');
1031               wrefresh(dotdeer0);
1032               wrefresh(w_del_msg);
1033               werase(dotdeer0);
1034               wrefresh(dotdeer0);
1035               wrefresh(w_del_msg);
1036             }
1037           }
1038         }
1039
1040         x_pos = 58;
1041
1042         for(y_pos = 2; y_pos < 5; y_pos++) {
1043
1044           touchwin(lildeer0);
1045           wrefresh(lildeer0);
1046           wrefresh(w_del_msg);
1047
1048           for(looper = 0; looper < 4; looper++) {
1049             deer_step(lildeer3, y_pos, x_pos);
1050             deer_step(lildeer2, y_pos, x_pos);
1051             deer_step(lildeer1, y_pos, x_pos);
1052             deer_step(lildeer2, y_pos, x_pos);
1053             deer_step(lildeer3, y_pos, x_pos);
1054
1055             touchwin(lildeer0);
1056             wrefresh(lildeer0);
1057             wrefresh(w_del_msg);
1058
1059             x_pos -= 2;
1060           }
1061         }
1062
1063
1064         x_pos = 35;
1065
1066         for(y_pos = 5; y_pos < 10; y_pos++) {
1067
1068           touchwin(middeer0);
1069           wrefresh(middeer0);
1070           wrefresh(w_del_msg);
1071
1072           for(looper = 0; looper < 2; looper++) {
1073             deer_step(middeer3, y_pos, x_pos);
1074             deer_step(middeer2, y_pos, x_pos);
1075             deer_step(middeer1, y_pos, x_pos);
1076             deer_step(middeer2, y_pos, x_pos);
1077             deer_step(middeer3, y_pos, x_pos);
1078
1079             touchwin(middeer0);
1080             wrefresh(middeer0);
1081             wrefresh(w_del_msg);
1082
1083             x_pos -= 3;
1084           }
1085         }
1086
1087         look_out(300);
1088
1089         y_pos = 1;
1090
1091         for(x_pos = 8; x_pos < 16; x_pos++) {
1092             deer_step(bigdeer4, y_pos, x_pos);
1093             deer_step(bigdeer3, y_pos, x_pos);
1094             deer_step(bigdeer2, y_pos, x_pos);
1095             deer_step(bigdeer1, y_pos, x_pos);
1096             deer_step(bigdeer2, y_pos, x_pos);
1097             deer_step(bigdeer3, y_pos, x_pos);
1098             deer_step(bigdeer4, y_pos, x_pos);
1099             deer_step(bigdeer0, y_pos, x_pos);
1100         }
1101
1102           --x_pos;
1103
1104           for(looper = 0; looper < 6; looper++) {
1105             deer_step(lookdeer4, y_pos, x_pos);
1106             deer_step(lookdeer3, y_pos, x_pos);
1107             deer_step(lookdeer2, y_pos, x_pos);
1108             deer_step(lookdeer1, y_pos, x_pos);
1109             deer_step(lookdeer2, y_pos, x_pos);
1110             deer_step(lookdeer3, y_pos, x_pos);
1111             deer_step(lookdeer4, y_pos, x_pos);
1112           }
1113
1114           deer_step(lookdeer0, y_pos, x_pos);
1115
1116         for(; y_pos < 10; y_pos++) {
1117           for(looper = 0; looper < 2; looper++) {
1118             deer_step(bigdeer4, y_pos, x_pos);
1119             deer_step(bigdeer3, y_pos, x_pos);
1120             deer_step(bigdeer2, y_pos, x_pos);
1121             deer_step(bigdeer1, y_pos, x_pos);
1122             deer_step(bigdeer2, y_pos, x_pos);
1123             deer_step(bigdeer3, y_pos, x_pos);
1124             deer_step(bigdeer4, y_pos, x_pos);
1125           }
1126           deer_step(bigdeer0, y_pos, x_pos);
1127         }
1128
1129         --y_pos;
1130
1131         deer_step(lookdeer3, y_pos, x_pos);
1132         return( 0 );
1133 }
1134
1135 static RETSIGTYPE done(int sig GCC_UNUSED)
1136 {
1137         signal(SIGINT,done);
1138         signal(SIGTERM,done);
1139 #if !defined    DOS && !defined OS2
1140         signal(SIGHUP,done);
1141         signal(SIGQUIT,done);
1142 #endif
1143         move(LINES-1,0);
1144         refresh();
1145         endwin();
1146         curs_set(1);
1147         exit(EXIT_SUCCESS);
1148 }