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