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