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