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