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 #include <test.priv.h>
  95
  96 #include <signal.h>
  97
  98 #define FROMWHO "Mark Hessling - (M.Hessling@gu.edu.au)"
  99
 100 static int y_pos, x_pos;
 101
 102 static WINDOW
 103         *treescrn, *treescrn2,*treescrn3, *treescrn4,*treescrn5, *treescrn6,
 104         *treescrn7, *treescrn8,
 105         *dotdeer0,
 106         *stardeer0,
 107         *lildeer0, *lildeer1, *lildeer2, *lildeer3,
 108         *middeer0, *middeer1, *middeer2, *middeer3,
 109         *bigdeer0, *bigdeer1, *bigdeer2, *bigdeer3, *bigdeer4,
 110         *lookdeer0, *lookdeer1, *lookdeer2, *lookdeer3, *lookdeer4,
 111         *w_holiday,
 112         *w_del_msg;
 113
 114 static int boxit(void);
 115 static int seas(void);
 116 static int greet(void);
 117 static int fromwho(void);
 118 static int tree(void);
 119 static int balls(void);
 120 static int star(void);
 121 static int strng1(void);
 122 static int strng2(void);
 123 static int strng3(void);
 124 static int strng4(void);
 125 static int strng5(void);
 126 static int reindeer(void);
 127 static int blinkit(void);
 128 static RETSIGTYPE done(int sig) GCC_NORETURN ;
 129
 130 int main(
 131         int argc GCC_UNUSED,
 132         char **argv GCC_UNUSED)
 133 {
 134 int loopy;
 135
 136         initscr();
 137         noecho();
 138         nonl();
 139         refresh();
 140         signal(SIGINT,done);
 141         signal(SIGTERM,done);
 142 #if !defined    DOS && !defined OS2
 143         signal(SIGHUP,done);
 144         signal(SIGQUIT,done);
 145 #endif
 146
 147         treescrn = newwin(16,27,3,53);
 148         treescrn2 = newwin(16,27,3,53);
 149         treescrn3 = newwin(16,27,3,53);
 150         treescrn4 = newwin(16,27,3,53);
 151         treescrn5 = newwin(16,27,3,53);
 152         treescrn6 = newwin(16,27,3,53);
 153         treescrn7 = newwin(16,27,3,53);
 154         treescrn8 = newwin(16,27,3,53);
 155
 156         dotdeer0 = newwin(3,71,0,8);
 157
 158         stardeer0 = newwin(4,56,0,8);
 159
 160         lildeer0 = newwin(7,53,0,8);
 161         lildeer1 = newwin(2,4,0,0);
 162         lildeer2 = newwin(2,4,0,0);
 163         lildeer3 = newwin(2,4,0,0);
 164
 165         middeer0 = newwin(15,42,0,8);
 166         middeer1 = newwin(3,7,0,0);
 167         middeer2 = newwin(3,7,0,0);
 168         middeer3 = newwin(3,7,0,0);
 169
 170         bigdeer0 = newwin(10,23,0,0);
 171         bigdeer1 = newwin(10,23,0,0);
 172         bigdeer2 = newwin(10,23,0,0);
 173         bigdeer3 = newwin(10,23,0,0);
 174         bigdeer4 = newwin(10,23,0,0);
 175
 176         lookdeer0 = newwin(10,25,0,0);
 177         lookdeer1 = newwin(10,25,0,0);
 178         lookdeer2 = newwin(10,25,0,0);
 179         lookdeer3 = newwin(10,25,0,0);
 180         lookdeer4 = newwin(10,25,0,0);
 181
 182         w_holiday = newwin(1,26,3,27);
 183
 184         w_del_msg = newwin(1,19,23,60);
 185
 186         mvwaddstr(w_del_msg,0,0,"Hit any key to quit");
 187
 188         mvwaddstr(w_holiday,0,0,"H A P P Y  H O L I D A Y S");
 189
 190         /* set up the windows for our various reindeer */
 191
 192         /* lildeer1 */
 193         mvwaddch(lildeer1,0,0,(chtype)'V');
 194         mvwaddch(lildeer1,1,0,(chtype)'@');
 195         mvwaddch(lildeer1,1,1,(chtype)'<');
 196         mvwaddch(lildeer1,1,2,(chtype)'>');
 197         mvwaddch(lildeer1,1,3,(chtype)'~');
 198
 199         /* lildeer2 */
 200         mvwaddch(lildeer2,0,0,(chtype)'V');
 201         mvwaddch(lildeer2,1,0,(chtype)'@');
 202         mvwaddch(lildeer2,1,1,(chtype)'|');
 203         mvwaddch(lildeer2,1,2,(chtype)'|');
 204         mvwaddch(lildeer2,1,3,(chtype)'~');
 205
 206         /* lildeer3 */
 207         mvwaddch(lildeer3,0,0,(chtype)'V');
 208         mvwaddch(lildeer3,1,0,(chtype)'@');
 209         mvwaddch(lildeer3,1,1,(chtype)'>');
 210         mvwaddch(lildeer3,1,2,(chtype)'<');
 211         mvwaddch(lildeer2,1,3,(chtype)'~');
 212
 213
 214         /* middeer1 */
 215         mvwaddch(middeer1,0,2,(chtype)'y');
 216         mvwaddch(middeer1,0,3,(chtype)'y');
 217         mvwaddch(middeer1,1,2,(chtype)'0');
 218         mvwaddch(middeer1,1,3,(chtype)'(');
 219         mvwaddch(middeer1,1,4,(chtype)'=');
 220         mvwaddch(middeer1,1,5,(chtype)')');
 221         mvwaddch(middeer1,1,6,(chtype)'~');
 222         mvwaddch(middeer1,2,3,(chtype)'\\');
 223         mvwaddch(middeer1,2,4,(chtype)'/');
 224
 225         /* middeer2 */
 226         mvwaddch(middeer2,0,2,(chtype)'y');
 227         mvwaddch(middeer2,0,3,(chtype)'y');
 228         mvwaddch(middeer2,1,2,(chtype)'0');
 229         mvwaddch(middeer2,1,3,(chtype)'(');
 230         mvwaddch(middeer2,1,4,(chtype)'=');
 231         mvwaddch(middeer2,1,5,(chtype)')');
 232         mvwaddch(middeer2,1,6,(chtype)'~');
 233         mvwaddch(middeer2,2,3,(chtype)'|');
 234         mvwaddch(middeer2,2,5,(chtype)'|');
 235
 236         /* middeer3 */
 237         mvwaddch(middeer3,0,2,(chtype)'y');
 238         mvwaddch(middeer3,0,3,(chtype)'y');
 239         mvwaddch(middeer3,1,2,(chtype)'0');
 240         mvwaddch(middeer3,1,3,(chtype)'(');
 241         mvwaddch(middeer3,1,4,(chtype)'=');
 242         mvwaddch(middeer3,1,5,(chtype)')');
 243         mvwaddch(middeer3,1,6,(chtype)'~');
 244         mvwaddch(middeer3,2,2,(chtype)'/');
 245         mvwaddch(middeer3,2,6,(chtype)'\\');
 246
 247
 248         /* bigdeer1 */
 249         mvwaddch(bigdeer1,0,17,(chtype)'\\');
 250         mvwaddch(bigdeer1,0,18,(chtype)'/');
 251         mvwaddch(bigdeer1,0,20,(chtype)'\\');
 252         mvwaddch(bigdeer1,0,21,(chtype)'/');
 253         mvwaddch(bigdeer1,1,18,(chtype)'\\');
 254         mvwaddch(bigdeer1,1,20,(chtype)'/');
 255         mvwaddch(bigdeer1,2,19,(chtype)'|');
 256         mvwaddch(bigdeer1,2,20,(chtype)'_');
 257         mvwaddch(bigdeer1,3,18,(chtype)'/');
 258         mvwaddch(bigdeer1,3,19,(chtype)'^');
 259         mvwaddch(bigdeer1,3,20,(chtype)'0');
 260         mvwaddch(bigdeer1,3,21,(chtype)'\\');
 261         mvwaddch(bigdeer1,4,17,(chtype)'/');
 262         mvwaddch(bigdeer1,4,18,(chtype)'/');
 263         mvwaddch(bigdeer1,4,19,(chtype)'\\');
 264         mvwaddch(bigdeer1,4,22,(chtype)'\\');
 265         mvwaddstr(bigdeer1,5,7,"^~~~~~~~~//  ~~U");
 266         mvwaddstr(bigdeer1,6,7,"( \\_____( /");
 267         mvwaddstr(bigdeer1,7,8,"( )    /");
 268         mvwaddstr(bigdeer1,8,9,"\\\\   /");
 269         mvwaddstr(bigdeer1,9,11,"\\>/>");
 270
 271         /* bigdeer2 */
 272         mvwaddch(bigdeer2,0,17,(chtype)'\\');
 273         mvwaddch(bigdeer2,0,18,(chtype)'/');
 274         mvwaddch(bigdeer2,0,20,(chtype)'\\');
 275         mvwaddch(bigdeer2,0,21,(chtype)'/');
 276         mvwaddch(bigdeer2,1,18,(chtype)'\\');
 277         mvwaddch(bigdeer2,1,20,(chtype)'/');
 278         mvwaddch(bigdeer2,2,19,(chtype)'|');
 279         mvwaddch(bigdeer2,2,20,(chtype)'_');
 280         mvwaddch(bigdeer2,3,18,(chtype)'/');
 281         mvwaddch(bigdeer2,3,19,(chtype)'^');
 282         mvwaddch(bigdeer2,3,20,(chtype)'0');
 283         mvwaddch(bigdeer2,3,21,(chtype)'\\');
 284         mvwaddch(bigdeer2,4,17,(chtype)'/');
 285         mvwaddch(bigdeer2,4,18,(chtype)'/');
 286         mvwaddch(bigdeer2,4,19,(chtype)'\\');
 287         mvwaddch(bigdeer2,4,22,(chtype)'\\');
 288         mvwaddstr(bigdeer2,5,7,"^~~~~~~~~//  ~~U");
 289         mvwaddstr(bigdeer2,6,7,"(( )____( /");
 290         mvwaddstr(bigdeer2,7,7,"( /      |");
 291         mvwaddstr(bigdeer2,8,8,"\\/      |");
 292         mvwaddstr(bigdeer2,9,9,"|>     |>");
 293
 294         /* bigdeer3 */
 295         mvwaddch(bigdeer3,0,17,(chtype)'\\');
 296         mvwaddch(bigdeer3,0,18,(chtype)'/');
 297         mvwaddch(bigdeer3,0,20,(chtype)'\\');
 298         mvwaddch(bigdeer3,0,21,(chtype)'/');
 299         mvwaddch(bigdeer3,1,18,(chtype)'\\');
 300         mvwaddch(bigdeer3,1,20,(chtype)'/');
 301         mvwaddch(bigdeer3,2,19,(chtype)'|');
 302         mvwaddch(bigdeer3,2,20,(chtype)'_');
 303         mvwaddch(bigdeer3,3,18,(chtype)'/');
 304         mvwaddch(bigdeer3,3,19,(chtype)'^');
 305         mvwaddch(bigdeer3,3,20,(chtype)'0');
 306         mvwaddch(bigdeer3,3,21,(chtype)'\\');
 307         mvwaddch(bigdeer3,4,17,(chtype)'/');
 308         mvwaddch(bigdeer3,4,18,(chtype)'/');
 309         mvwaddch(bigdeer3,4,19,(chtype)'\\');
 310         mvwaddch(bigdeer3,4,22,(chtype)'\\');
 311         mvwaddstr(bigdeer3,5,7,"^~~~~~~~~//  ~~U");
 312         mvwaddstr(bigdeer3,6,6,"( ()_____( /");
 313         mvwaddstr(bigdeer3,7,6,"/ /       /");
 314         mvwaddstr(bigdeer3,8,5,"|/          \\");
 315         mvwaddstr(bigdeer3,9,5,"/>           \\>");
 316
 317         /* bigdeer4 */
 318         mvwaddch(bigdeer4,0,17,(chtype)'\\');
 319         mvwaddch(bigdeer4,0,18,(chtype)'/');
 320         mvwaddch(bigdeer4,0,20,(chtype)'\\');
 321         mvwaddch(bigdeer4,0,21,(chtype)'/');
 322         mvwaddch(bigdeer4,1,18,(chtype)'\\');
 323         mvwaddch(bigdeer4,1,20,(chtype)'/');
 324         mvwaddch(bigdeer4,2,19,(chtype)'|');
 325         mvwaddch(bigdeer4,2,20,(chtype)'_');
 326         mvwaddch(bigdeer4,3,18,(chtype)'/');
 327         mvwaddch(bigdeer4,3,19,(chtype)'^');
 328         mvwaddch(bigdeer4,3,20,(chtype)'0');
 329         mvwaddch(bigdeer4,3,21,(chtype)'\\');
 330         mvwaddch(bigdeer4,4,17,(chtype)'/');
 331         mvwaddch(bigdeer4,4,18,(chtype)'/');
 332         mvwaddch(bigdeer4,4,19,(chtype)'\\');
 333         mvwaddch(bigdeer4,4,22,(chtype)'\\');
 334         mvwaddstr(bigdeer4,5,7,"^~~~~~~~~//  ~~U");
 335         mvwaddstr(bigdeer4,6,6,"( )______( /");
 336         mvwaddstr(bigdeer4,7,5,"(/          \\");
 337         mvwaddstr(bigdeer4,8,0,"v___=             ----^");
 338
 339
 340         /* lookdeer1 */
 341         mvwaddstr(lookdeer1,0,16,"\\/     \\/");
 342         mvwaddstr(lookdeer1,1,17,"\\Y/ \\Y/");
 343         mvwaddstr(lookdeer1,2,19,"\\=/");
 344         mvwaddstr(lookdeer1,3,17,"^\\o o/^");
 345         mvwaddstr(lookdeer1,4,17,"//( )");
 346         mvwaddstr(lookdeer1,5,7,"^~~~~~~~~// \\O/");
 347         mvwaddstr(lookdeer1,6,7,"( \\_____( /");
 348         mvwaddstr(lookdeer1,7,8,"( )    /");
 349         mvwaddstr(lookdeer1,8,9,"\\\\   /");
 350         mvwaddstr(lookdeer1,9,11,"\\>/>");
 351
 352         /* lookdeer2 */
 353         mvwaddstr(lookdeer2,0,16,"\\/     \\/");
 354         mvwaddstr(lookdeer2,1,17,"\\Y/ \\Y/");
 355         mvwaddstr(lookdeer2,2,19,"\\=/");
 356         mvwaddstr(lookdeer2,3,17,"^\\o o/^");
 357         mvwaddstr(lookdeer2,4,17,"//( )");
 358         mvwaddstr(lookdeer2,5,7,"^~~~~~~~~// \\O/");
 359         mvwaddstr(lookdeer2,6,7,"(( )____( /");
 360         mvwaddstr(lookdeer2,7,7,"( /      |");
 361         mvwaddstr(lookdeer2,8,8,"\\/      |");
 362         mvwaddstr(lookdeer2,9,9,"|>     |>");
 363
 364         /* lookdeer3 */
 365         mvwaddstr(lookdeer3,0,16,"\\/     \\/");
 366         mvwaddstr(lookdeer3,1,17,"\\Y/ \\Y/");
 367         mvwaddstr(lookdeer3,2,19,"\\=/");
 368         mvwaddstr(lookdeer3,3,17,"^\\o o/^");
 369         mvwaddstr(lookdeer3,4,17,"//( )");
 370         mvwaddstr(lookdeer3,5,7,"^~~~~~~~~// \\O/");
 371         mvwaddstr(lookdeer3,6,6,"( ()_____( /");
 372         mvwaddstr(lookdeer3,7,6,"/ /       /");
 373         mvwaddstr(lookdeer3,8,5,"|/          \\");
 374         mvwaddstr(lookdeer3,9,5,"/>           \\>");
 375
 376         /* lookdeer4 */
 377         mvwaddstr(lookdeer4,0,16,"\\/     \\/");
 378         mvwaddstr(lookdeer4,1,17,"\\Y/ \\Y/");
 379         mvwaddstr(lookdeer4,2,19,"\\=/");
 380         mvwaddstr(lookdeer4,3,17,"^\\o o/^");
 381         mvwaddstr(lookdeer4,4,17,"//( )");
 382         mvwaddstr(lookdeer4,5,7,"^~~~~~~~~// \\O/");
 383         mvwaddstr(lookdeer4,6,6,"( )______( /");
 384         mvwaddstr(lookdeer4,7,5,"(/          \\");
 385         mvwaddstr(lookdeer4,8,0,"v___=             ----^");
 386
 387
 388
 389         /***********************************************/
 390         cbreak();
 391         nodelay(stdscr,TRUE);
 392         do {
 393           clear();
 394           werase(treescrn);
 395           touchwin(w_del_msg);
 396           touchwin(treescrn);
 397           werase(treescrn2);
 398           touchwin(treescrn2);
 399           werase(treescrn8);
 400           touchwin(treescrn8);
 401           refresh();
 402           napms(150);
 403           boxit();
 404           refresh();
 405           napms(150);
 406           seas();
 407           refresh();
 408           napms(150);
 409           greet();
 410           refresh();
 411           napms(150);
 412           fromwho();
 413           refresh();
 414           napms(150);
 415           tree();
 416           napms(150);
 417           balls();
 418           napms(150);
 419           star();
 420           napms(150);
 421           strng1();
 422           strng2();
 423           strng3();
 424           strng4();
 425           strng5();
 426
 427
 428         /* set up the windows for our blinking trees */
 429         /* **************************************** */
 430         /* treescrn3 */
 431
 432            overlay(treescrn, treescrn3);
 433
 434            /*balls*/
 435            mvwaddch(treescrn3, 4, 18, ' ');
 436            mvwaddch(treescrn3, 7, 6, ' ');
 437            mvwaddch(treescrn3, 8, 19, ' ');
 438            mvwaddch(treescrn3, 11, 22, ' ');
 439
 440            /*star*/
 441            mvwaddch(treescrn3, 0, 12, '*');
 442
 443            /*strng1*/
 444            mvwaddch(treescrn3, 3, 11, ' ');
 445
 446            /*strng2*/
 447            mvwaddch(treescrn3, 5, 13, ' ');
 448            mvwaddch(treescrn3, 6, 10, ' ');
 449
 450            /*strng3*/
 451            mvwaddch(treescrn3, 7, 16, ' ');
 452            mvwaddch(treescrn3, 7, 14, ' ');
 453
 454                    /*strng4*/
 455            mvwaddch(treescrn3, 10, 13, ' ');
 456            mvwaddch(treescrn3, 10, 10, ' ');
 457            mvwaddch(treescrn3, 11, 8, ' ');
 458
 459                    /*strng5*/
 460            mvwaddch(treescrn3, 11, 18, ' ');
 461            mvwaddch(treescrn3, 12, 13, ' ');
 462
 463
 464         /* treescrn4 */
 465
 466            overlay(treescrn, treescrn4);
 467
 468            /*balls*/
 469            mvwaddch(treescrn4, 3, 9, ' ');
 470            mvwaddch(treescrn4, 4, 16, ' ');
 471            mvwaddch(treescrn4, 7, 6, ' ');
 472            mvwaddch(treescrn4, 8, 19, ' ');
 473            mvwaddch(treescrn4, 11, 2, ' ');
 474            mvwaddch(treescrn4, 12, 23, ' ');
 475
 476            /*star*/
 477            wstandout(treescrn4);
 478            mvwaddch(treescrn4, 0, 12, '*');
 479            wstandend(treescrn4);
 480
 481            /*strng1*/
 482            mvwaddch(treescrn4, 3, 13, ' ');
 483
 484            /*strng2*/
 485
 486            /*strng3*/
 487            mvwaddch(treescrn4, 7, 15, ' ');
 488            mvwaddch(treescrn4, 8, 11, ' ');
 489
 490            /*strng4*/
 491            mvwaddch(treescrn4, 9, 16, ' ');
 492            mvwaddch(treescrn4, 10, 12, ' ');
 493            mvwaddch(treescrn4, 11, 8, ' ');
 494
 495            /*strng5*/
 496            mvwaddch(treescrn4, 11, 18, ' ');
 497            mvwaddch(treescrn4, 12, 14, ' ');
 498
 499
 500         /* treescrn5 */
 501
 502            overlay(treescrn, treescrn5);
 503
 504            /*balls*/
 505            mvwaddch(treescrn5, 3, 15, ' ');
 506            mvwaddch(treescrn5, 10, 20, ' ');
 507            mvwaddch(treescrn5, 12, 1, ' ');
 508
 509            /*star*/
 510            mvwaddch(treescrn5, 0, 12, '*');
 511
 512            /*strng1*/
 513            mvwaddch(treescrn5, 3, 11, ' ');
 514
 515            /*strng2*/
 516            mvwaddch(treescrn5, 5, 12, ' ');
 517
 518            /*strng3*/
 519            mvwaddch(treescrn5, 7, 14, ' ');
 520            mvwaddch(treescrn5, 8, 10, ' ');
 521
 522            /*strng4*/
 523            mvwaddch(treescrn5, 9, 15, ' ');
 524            mvwaddch(treescrn5, 10, 11, ' ');
 525            mvwaddch(treescrn5, 11, 7, ' ');
 526
 527            /*strng5*/
 528            mvwaddch(treescrn5, 11, 17, ' ');
 529            mvwaddch(treescrn5, 12, 13, ' ');
 530
 531         /* treescrn6 */
 532
 533            overlay(treescrn, treescrn6);
 534
 535            /*balls*/
 536            mvwaddch(treescrn6, 6, 7, ' ');
 537            mvwaddch(treescrn6, 7, 18, ' ');
 538            mvwaddch(treescrn6, 10, 4, ' ');
 539            mvwaddch(treescrn6, 11, 23, ' ');
 540
 541            /*star*/
 542            wstandout(treescrn6);
 543            mvwaddch(treescrn6, 0, 12, '*');
 544            wstandend(treescrn6);
 545
 546            /*strng1*/
 547
 548            /*strng2*/
 549            mvwaddch(treescrn6, 5, 11, ' ');
 550
 551            /*strng3*/
 552            mvwaddch(treescrn6, 7, 13, ' ');
 553            mvwaddch(treescrn6, 8, 9, ' ');
 554
 555            /*strng4*/
 556            mvwaddch(treescrn6, 9, 14, ' ');
 557            mvwaddch(treescrn6, 10, 10, ' ');
 558            mvwaddch(treescrn6, 11, 6, ' ');
 559
 560            /*strng5*/
 561            mvwaddch(treescrn6, 11, 16, ' ');
 562            mvwaddch(treescrn6, 12, 12, ' ');
 563
 564         /* treescrn7 */
 565
 566            overlay(treescrn, treescrn7);
 567
 568            /*balls*/
 569            mvwaddch(treescrn7, 3, 15, ' ');
 570            mvwaddch(treescrn7, 6, 7, ' ');
 571            mvwaddch(treescrn7, 7, 18, ' ');
 572            mvwaddch(treescrn7, 10, 4, ' ');
 573            mvwaddch(treescrn7, 11, 22, ' ');
 574
 575            /*star*/
 576            mvwaddch(treescrn7, 0, 12, '*');
 577
 578            /*strng1*/
 579            mvwaddch(treescrn7, 3, 12, ' ');
 580
 581            /*strng2*/
 582            mvwaddch(treescrn7, 5, 13, ' ');
 583            mvwaddch(treescrn7, 6, 9, ' ');
 584
 585            /*strng3*/
 586            mvwaddch(treescrn7, 7, 15, ' ');
 587            mvwaddch(treescrn7, 8, 11, ' ');
 588
 589            /*strng4*/
 590            mvwaddch(treescrn7, 9, 16, ' ');
 591            mvwaddch(treescrn7, 10, 12, ' ');
 592            mvwaddch(treescrn7, 11, 8, ' ');
 593
 594            /*strng5*/
 595            mvwaddch(treescrn7, 11, 18, ' ');
 596            mvwaddch(treescrn7, 12, 14, ' ');
 597
 598
 599            napms(150);
 600            reindeer();
 601
 602            touchwin(w_holiday);
 603            wrefresh(w_holiday);
 604            wrefresh(w_del_msg);
 605
 606            napms(500);
 607            for(loopy = 0;loopy < 100;loopy++) {
 608                 blinkit();
 609            }
 610
 611 #ifdef NOLOOP
 612            done(0);
 613 #endif
 614
 615         }
 616         while(getch() == (ERR));
 617 /*  while(!typeahead(stdin));*/
 618         done(0);
 619         /*NOTREACHED*/
 620 }
 621
 622 static int boxit(void)
 623 {
 624  int x = 0;
 625
 626         while(x < 20) {
 627           mvaddch(x, 7, '|');
 628           ++x;
 629         }
 630
 631         x = 8;
 632
 633         while(x < 80) {
 634           mvaddch(19, x, '_');
 635           ++x;
 636         }
 637
 638         x = 0;
 639
 640         while(x < 80) {
 641           mvaddch(22, x, '_');
 642           ++x;
 643         }
 644
 645         return( 0 );
 646 }
 647
 648 static int seas(void)
 649 {
 650         mvaddch(4, 1, 'S');
 651         mvaddch(6, 1, 'E');
 652         mvaddch(8, 1, 'A');
 653         mvaddch(10, 1, 'S');
 654         mvaddch(12, 1, 'O');
 655         mvaddch(14, 1, 'N');
 656         mvaddch(16, 1, '`');
 657         mvaddch(18, 1, 'S');
 658
 659         return( 0 );
 660 }
 661
 662
 663 static int greet(void)
 664 {
 665         mvaddch(3, 5, 'G');
 666         mvaddch(5, 5, 'R');
 667         mvaddch(7, 5, 'E');
 668         mvaddch(9, 5, 'E');
 669         mvaddch(11, 5, 'T');
 670         mvaddch(13, 5, 'I');
 671         mvaddch(15, 5, 'N');
 672         mvaddch(17, 5, 'G');
 673         mvaddch(19, 5, 'S');
 674
 675         return( 0 );
 676 }
 677
 678
 679 static int fromwho(void)
 680 {
 681         mvaddstr(21, 13, FROMWHO);
 682         return( 0 );
 683 }
 684
 685 static int tree(void)
 686 {
 687         mvwaddch(treescrn, 1, 11, (chtype)'/');
 688         mvwaddch(treescrn, 2, 11, (chtype)'/');
 689         mvwaddch(treescrn, 3, 10, (chtype)'/');
 690         mvwaddch(treescrn, 4, 9, (chtype)'/');
 691         mvwaddch(treescrn, 5, 9, (chtype)'/');
 692         mvwaddch(treescrn, 6, 8, (chtype)'/');
 693         mvwaddch(treescrn, 7, 7, (chtype)'/');
 694         mvwaddch(treescrn, 8, 6, (chtype)'/');
 695         mvwaddch(treescrn, 9, 6, (chtype)'/');
 696         mvwaddch(treescrn, 10, 5, (chtype)'/');
 697         mvwaddch(treescrn, 11, 3, (chtype)'/');
 698         mvwaddch(treescrn, 12, 2, (chtype)'/');
 699
 700         mvwaddch(treescrn, 1, 13, (chtype)'\\');
 701         mvwaddch(treescrn, 2, 13, (chtype)'\\');
 702         mvwaddch(treescrn, 3, 14, (chtype)'\\');
 703         mvwaddch(treescrn, 4, 15, (chtype)'\\');
 704         mvwaddch(treescrn, 5, 15, (chtype)'\\');
 705         mvwaddch(treescrn, 6, 16, (chtype)'\\');
 706         mvwaddch(treescrn, 7, 17, (chtype)'\\');
 707         mvwaddch(treescrn, 8, 18, (chtype)'\\');
 708         mvwaddch(treescrn, 9, 18, (chtype)'\\');
 709         mvwaddch(treescrn, 10, 19, (chtype)'\\');
 710         mvwaddch(treescrn, 11, 21, (chtype)'\\');
 711         mvwaddch(treescrn, 12, 22, (chtype)'\\');
 712
 713         mvwaddch(treescrn, 4, 10, (chtype)'_');
 714         mvwaddch(treescrn, 4, 14, (chtype)'_');
 715         mvwaddch(treescrn, 8, 7, (chtype)'_');
 716         mvwaddch(treescrn, 8, 17, (chtype)'_');
 717
 718         mvwaddstr(treescrn, 13, 0, "//////////// \\\\\\\\\\\\\\\\\\\\\\\\");
 719
 720         mvwaddstr(treescrn, 14, 11, "| |");
 721         mvwaddstr(treescrn, 15, 11, "|_|");
 722
 723         wrefresh(treescrn);
 724         wrefresh(w_del_msg);
 725
 726         return( 0 );
 727 }
 728
 729
 730 static int balls(void)
 731 {
 732
 733         overlay(treescrn, treescrn2);
 734
 735         mvwaddch(treescrn2, 3, 9, (chtype)'@');
 736         mvwaddch(treescrn2, 3, 15, (chtype)'@');
 737         mvwaddch(treescrn2, 4, 8, (chtype)'@');
 738         mvwaddch(treescrn2, 4, 16, (chtype)'@');
 739         mvwaddch(treescrn2, 5, 7, (chtype)'@');
 740         mvwaddch(treescrn2, 5, 17, (chtype)'@');
 741         mvwaddch(treescrn2, 7, 6, (chtype)'@');
 742         mvwaddch(treescrn2, 7, 18, (chtype)'@');
 743         mvwaddch(treescrn2, 8, 5, (chtype)'@');
 744         mvwaddch(treescrn2, 8, 19, (chtype)'@');
 745         mvwaddch(treescrn2, 10, 4, (chtype)'@');
 746         mvwaddch(treescrn2, 10, 20, (chtype)'@');
 747         mvwaddch(treescrn2, 11, 2, (chtype)'@');
 748         mvwaddch(treescrn2, 11, 22, (chtype)'@');
 749         mvwaddch(treescrn2, 12, 1, (chtype)'@');
 750         mvwaddch(treescrn2, 12, 23, (chtype)'@');
 751
 752         wrefresh(treescrn2);
 753         wrefresh(w_del_msg);
 754         return( 0 );
 755 }
 756
 757
 758 static int star(void)
 759 {
 760         wstandout(treescrn2);
 761         mvwaddch(treescrn2, 0, 12, (chtype)'*');
 762         wstandend(treescrn2);
 763
 764         wrefresh(treescrn2);
 765         wrefresh(w_del_msg);
 766         return( 0 );
 767 }
 768
 769
 770 static int strng1(void)
 771 {
 772         mvwaddch(treescrn2, 3, 13, (chtype)'\'');
 773         mvwaddch(treescrn2, 3, 12, (chtype)':');
 774         mvwaddch(treescrn2, 3, 11, (chtype)'.');
 775
 776         wrefresh(treescrn2);
 777         wrefresh(w_del_msg);
 778         return( 0 );
 779 }
 780
 781
 782 static int strng2(void)
 783 {
 784         mvwaddch(treescrn2, 5, 14, (chtype)'\'');
 785         mvwaddch(treescrn2, 5, 13, (chtype)':');
 786         mvwaddch(treescrn2, 5, 12, (chtype)'.');
 787         mvwaddch(treescrn2, 5, 11, (chtype)',');
 788         mvwaddch(treescrn2, 6, 10, (chtype)'\'');
 789         mvwaddch(treescrn2, 6, 9, (chtype)':');
 790
 791         wrefresh(treescrn2);
 792         wrefresh(w_del_msg);
 793         return( 0 );
 794 }
 795
 796
 797 static int strng3(void)
 798 {
 799         mvwaddch(treescrn2, 7, 16, (chtype)'\'');
 800         mvwaddch(treescrn2, 7, 15, (chtype)':');
 801         mvwaddch(treescrn2, 7, 14, (chtype)'.');
 802         mvwaddch(treescrn2, 7, 13, (chtype)',');
 803         mvwaddch(treescrn2, 8, 12, (chtype)'\'');
 804         mvwaddch(treescrn2, 8, 11, (chtype)':');
 805         mvwaddch(treescrn2, 8, 10, (chtype)'.');
 806         mvwaddch(treescrn2, 8, 9, (chtype)',');
 807
 808         wrefresh(treescrn2);
 809         wrefresh(w_del_msg);
 810         return( 0 );
 811 }
 812
 813
 814 static int strng4(void)
 815 {
 816         mvwaddch(treescrn2, 9, 17, (chtype)'\'');
 817         mvwaddch(treescrn2, 9, 16, (chtype)':');
 818         mvwaddch(treescrn2, 9, 15, (chtype)'.');
 819         mvwaddch(treescrn2, 9, 14, (chtype)',');
 820         mvwaddch(treescrn2, 10, 13, (chtype)'\'');
 821         mvwaddch(treescrn2, 10, 12, (chtype)':');
 822         mvwaddch(treescrn2, 10, 11, (chtype)'.');
 823         mvwaddch(treescrn2, 10, 10, (chtype)',');
 824         mvwaddch(treescrn2, 11, 9, (chtype)'\'');
 825         mvwaddch(treescrn2, 11, 8, (chtype)':');
 826         mvwaddch(treescrn2, 11, 7, (chtype)'.');
 827         mvwaddch(treescrn2, 11, 6, (chtype)',');
 828         mvwaddch(treescrn2, 12, 5, (chtype)'\'');
 829
 830         wrefresh(treescrn2);
 831         wrefresh(w_del_msg);
 832         return( 0 );
 833 }
 834
 835
 836 static int strng5(void)
 837 {
 838         mvwaddch(treescrn2, 11, 19, (chtype)'\'');
 839         mvwaddch(treescrn2, 11, 18, (chtype)':');
 840         mvwaddch(treescrn2, 11, 17, (chtype)'.');
 841         mvwaddch(treescrn2, 11, 16, (chtype)',');
 842         mvwaddch(treescrn2, 12, 15, (chtype)'\'');
 843         mvwaddch(treescrn2, 12, 14, (chtype)':');
 844         mvwaddch(treescrn2, 12, 13, (chtype)'.');
 845         mvwaddch(treescrn2, 12, 12, (chtype)',');
 846
 847         /* save a fully lit tree */
 848         overlay(treescrn2, treescrn);
 849
 850         wrefresh(treescrn2);
 851         wrefresh(w_del_msg);
 852         return( 0 );
 853 }
 854
 855
 856
 857 static int blinkit(void)
 858 {
 859 static int cycle;
 860
 861         if(cycle > 4) {
 862           cycle = 0;
 863         }
 864
 865
 866         touchwin(treescrn8);
 867
 868         switch(cycle) {
 869           case 0:
 870                      overlay(treescrn3, treescrn8);
 871                      wrefresh(treescrn8);
 872                      wrefresh(w_del_msg);
 873                      break;
 874           case 1:
 875                      overlay(treescrn4, treescrn8);
 876                      wrefresh(treescrn8);
 877                      wrefresh(w_del_msg);
 878                      break;
 879           case 2:
 880                      overlay(treescrn5, treescrn8);
 881                      wrefresh(treescrn8);
 882                      wrefresh(w_del_msg);
 883                      break;
 884           case 3:
 885                      overlay(treescrn6, treescrn8);
 886                      wrefresh(treescrn8);
 887                      wrefresh(w_del_msg);
 888                      break;
 889           case 4:
 890                      overlay(treescrn7, treescrn8);
 891                      wrefresh(treescrn8);
 892                      wrefresh(w_del_msg);
 893                      break;
 894         }
 895          touchwin(treescrn8);
 896
 897          /*ALL ON***************************************************/
 898
 899          overlay(treescrn, treescrn8);
 900          wrefresh(treescrn8);
 901          wrefresh(w_del_msg);
 902
 903         ++cycle;
 904         return( 0 );
 905 }
 906
 907 static void
 908 deer_step(WINDOW *win, int y, int x)
 909 {
 910             mvwin(win, y, x);
 911             wrefresh(win);
 912             wrefresh(w_del_msg);
 913             napms(5);
 914 }
 915
 916 static int reindeer(void)
 917 {
 918  int looper;
 919  y_pos = 0;
 920
 921
 922         for(x_pos = 70; x_pos > 62; x_pos--) {
 923           if(x_pos < 62) {
 924             y_pos = 1;
 925           }
 926           for(looper = 0; looper < 4; looper++) {
 927             mvwaddch(dotdeer0, y_pos, x_pos, (chtype)'.');
 928             wrefresh(dotdeer0);
 929             wrefresh(w_del_msg);
 930             werase(dotdeer0);
 931             wrefresh(dotdeer0);
 932             wrefresh(w_del_msg);
 933             napms(50);
 934           }
 935         }
 936
 937         y_pos = 2;
 938
 939         for(; x_pos > 50; x_pos--) {
 940           for(looper = 0; looper < 4; looper++) {
 941
 942             if(x_pos < 56) {
 943               y_pos = 3;
 944
 945               mvwaddch(stardeer0, y_pos, x_pos, (chtype)'*');
 946               wrefresh(stardeer0);
 947               wrefresh(w_del_msg);
 948               werase(stardeer0);
 949               wrefresh(stardeer0);
 950               wrefresh(w_del_msg);
 951             } else {
 952               mvwaddch(dotdeer0, y_pos, x_pos, (chtype)'*');
 953               wrefresh(dotdeer0);
 954               wrefresh(w_del_msg);
 955               werase(dotdeer0);
 956               wrefresh(dotdeer0);
 957               wrefresh(w_del_msg);
 958             }
 959           }
 960         }
 961
 962         x_pos = 58;
 963
 964         for(y_pos = 2; y_pos < 5; y_pos++) {
 965
 966           touchwin(lildeer0);
 967           wrefresh(lildeer0);
 968           wrefresh(w_del_msg);
 969
 970           for(looper = 0; looper < 4; looper++) {
 971             deer_step(lildeer3, y_pos, x_pos);
 972             deer_step(lildeer2, y_pos, x_pos);
 973             deer_step(lildeer1, y_pos, x_pos);
 974             deer_step(lildeer2, y_pos, x_pos);
 975             deer_step(lildeer3, y_pos, x_pos);
 976
 977             touchwin(lildeer0);
 978             wrefresh(lildeer0);
 979             wrefresh(w_del_msg);
 980
 981             x_pos -= 2;
 982           }
 983         }
 984
 985
 986         x_pos = 35;
 987
 988         for(y_pos = 5; y_pos < 10; y_pos++) {
 989
 990           touchwin(middeer0);
 991           wrefresh(middeer0);
 992           wrefresh(w_del_msg);
 993
 994           for(looper = 0; looper < 2; looper++) {
 995             deer_step(middeer3, y_pos, x_pos);
 996             deer_step(middeer2, y_pos, x_pos);
 997             deer_step(middeer1, y_pos, x_pos);
 998             deer_step(middeer2, y_pos, x_pos);
 999             deer_step(middeer3, y_pos, x_pos);
1000
1001             touchwin(middeer0);
1002             wrefresh(middeer0);
1003             wrefresh(w_del_msg);
1004
1005             x_pos -= 3;
1006           }
1007         }
1008
1009         napms(300);
1010
1011         y_pos = 1;
1012
1013         for(x_pos = 8; x_pos < 16; x_pos++) {
1014             deer_step(bigdeer4, y_pos, x_pos);
1015             deer_step(bigdeer3, y_pos, x_pos);
1016             deer_step(bigdeer2, y_pos, x_pos);
1017             deer_step(bigdeer1, y_pos, x_pos);
1018             deer_step(bigdeer2, y_pos, x_pos);
1019             deer_step(bigdeer3, y_pos, x_pos);
1020             deer_step(bigdeer4, y_pos, x_pos);
1021             deer_step(bigdeer0, y_pos, x_pos);
1022         }
1023
1024           --x_pos;
1025
1026           for(looper = 0; looper < 6; looper++) {
1027             deer_step(lookdeer4, y_pos, x_pos);
1028             deer_step(lookdeer3, y_pos, x_pos);
1029             deer_step(lookdeer2, y_pos, x_pos);
1030             deer_step(lookdeer1, y_pos, x_pos);
1031             deer_step(lookdeer2, y_pos, x_pos);
1032             deer_step(lookdeer3, y_pos, x_pos);
1033             deer_step(lookdeer4, y_pos, x_pos);
1034           }
1035
1036           deer_step(lookdeer0, y_pos, x_pos);
1037
1038         for(; y_pos < 10; y_pos++) {
1039           for(looper = 0; looper < 2; looper++) {
1040             deer_step(bigdeer4, y_pos, x_pos);
1041             deer_step(bigdeer3, y_pos, x_pos);
1042             deer_step(bigdeer2, y_pos, x_pos);
1043             deer_step(bigdeer1, y_pos, x_pos);
1044             deer_step(bigdeer2, y_pos, x_pos);
1045             deer_step(bigdeer3, y_pos, x_pos);
1046             deer_step(bigdeer4, y_pos, x_pos);
1047           }
1048           deer_step(bigdeer0, y_pos, x_pos);
1049         }
1050
1051         --y_pos;
1052
1053         deer_step(lookdeer3, y_pos, x_pos);
1054         return( 0 );
1055 }
1056
1057 static RETSIGTYPE done(int sig GCC_UNUSED)
1058 {
1059         signal(SIGINT,done);
1060         signal(SIGTERM,done);
1061 #if !defined    DOS && !defined OS2
1062         signal(SIGHUP,done);
1063         signal(SIGQUIT,done);
1064 #endif
1065         clear();
1066         refresh();
1067         endwin();
1068         exit(EXIT_SUCCESS);
1069 }