home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 October / usenetsourcesnewsgroupsinfomagicoctober1994disk2.iso / misc / volume9 / asciixmas < prev    next >
Text File  |  1989-12-16  |  35KB  |  1,210 lines
  1. Newsgroups: comp.sources.misc
  2. organization: Jolnet, Public access Unix, Orland Park (Joliet) IL
  3. keywords: fun, merry christmas
  4. subject: v09i067: asciixmas program
  5. from: allbery@uunet.UU.NET (Brandon S. Allbery - comp.sources.misc)
  6. Reply-To: rich@jolnet.ORPK.IL.US (Rich Andrews)
  7.  
  8. Posting-number: Volume 9, Issue 67
  9. Submitted-by: rich@jolnet.ORPK.IL.US (Rich Andrews)
  10. Archive-name: asciixmas
  11.  
  12. This is posted for a friend......
  13.  
  14.  
  15. Here's my Christmas gift to the netlanders from whom I've learned so much over
  16. the last few months. I just wanted to give something back. 
  17.  
  18.  
  19. --------cut here--------cut here--------cut here--------cut here-----cut here---
  20. #! /bin/sh
  21. # This file was wrapped with "dummyshar".  "sh" this file to extract.
  22. # Contents:  asciixmas.c
  23. echo extracting 'asciixmas.c'
  24. if test -f 'asciixmas.c' -a -z "$1"; then echo Not overwriting 'asciixmas.c'; else
  25. sed 's/^X//' << \EOF > 'asciixmas.c'
  26. X/******************************************************************************/
  27. X/* asciixmas                                                                  */
  28. X/* December 1989             Larry Bartz           Indianapolis, IN           */
  29. X/*                                                                            */
  30. X/*                                                                            */
  31. X/* I'm dreaming of an ascii character-based monochrome Christmas,             */
  32. X/* Just like the one's I used to know!                                        */
  33. X/* Via a full duplex communications channel,                                  */
  34. X/* At 9600 bits per second,                                                   */
  35. X/* Even though it's kinda slow.                                               */
  36. X/*                                                                            */
  37. X/* I'm dreaming of an ascii character-based monochrome Christmas,             */
  38. X/* With ev'ry C program I write!                                              */
  39. X/* May your screen be merry and bright!                                       */
  40. X/* And may all your Christmases be amber or green,                            */
  41. X/* (for reduced eyestrain and improved visibility)!                           */
  42. X/*                                                                            */
  43. X/*                                                                            */
  44. X/*                                                                            */
  45. X/*                                                                            */
  46. X/*                                                                            */
  47. X/* IMPLEMENTATION                                                             */
  48. X/*                                                                            */
  49. X/* Feel free to modify the defined string FROMWHO to reflect you, your        */
  50. X/* organization, your site, whatever.                                         */
  51. X/*                                                                            */
  52. X/* This really looks a lot better if you can turn off your cursor before      */
  53. X/* execution. I wanted to do that here but very few termcap entries or        */
  54. X/* terminfo definitions have the appropriate string defined. If you know      */
  55. X/* the string(s) for the terminal(s) you use or which your site supports,     */
  56. X/* you could call asciixmas from within a shell in which you issue the        */
  57. X/* string to the terminal. The cursor is distracting but it doesn't really    */
  58. X/* ruin the show.                                                             */
  59. X/*                                                                            */
  60. X/* At our site, we invoke this for our users just after login and the         */
  61. X/* determination of terminal type.                                            */
  62. X/*                                                                            */
  63. X/*                                                                            */
  64. X/* PORTABILITY                                                                */
  65. X/*                                                                            */
  66. X/* I wrote this using only the very simplest curses functions so that it      */
  67. X/* might be the most portable. I was personally able to test on five          */
  68. X/* different cpu/UNIX combinations.                                           */
  69. X/*                                                                            */
  70. X/*                                                                            */
  71. X/* COMPILE                                                                    */
  72. X/*                                                                            */
  73. X/* usually this:                                                              */
  74. X/*                                                                            */
  75. X/* cc -O asciixmas.c -lcurses -o asciixmas -s                                 */
  76. X/*                                                                            */
  77. X/*                                                                            */
  78. X/* Zilog S8000 models 11, 21, 31, etc with ZEUS variant of SYSTEM III         */
  79. X/* maybe other SYSTEM III also:                                               */
  80. X/*                                                                            */
  81. X/* cc asciixmas.c -lcurses -ltermlib -o asciixmas -s                          */
  82. X/*                                                                            */
  83. X/* as above with optional "peephole optimizer" installed:                     */
  84. X/*                                                                            */
  85. X/* cc -O asciixmas.c -lcurses -ltermlib -o asciixmas -s                       */
  86. X/*                                                                            */
  87. X/*                                                                            */
  88. X/* Zilog S8000 models 32, 130 with WE32100 chip and SYS V, REL2               */
  89. X/* maybe 3B2 also?                                                            */
  90. X/*                                                                            */
  91. X/* cc -f -O -K sd asciixmas.c -lcurses -o asciixmas -s                        */
  92. X/*                                                                            */
  93. X/*                                                                            */
  94. X/* Pyramid, Sequent, any other "dual universe" types compile and execute      */
  95. X/* under either universe. The compile line for the ucb universe (as you       */
  96. X/* might expect) is the same as for SYS III UNIX:                             */
  97. X/*                                                                            */
  98. X/* cc -O asciixmas.c -lcurses -ltermlib -o asciixmas -s                       */
  99. X/*                                                                            */
  100. X/* The above compile will also hold true for other BSD systems. (I hope)      */
  101. X/*                                                                            */
  102. X/*                                                                            */
  103. X/*                                                                            */
  104. X/*                                                                            */
  105. X/* For the Scrooges out there among you who don't want this thing to loop     */
  106. X/* forever (or until the user hits DEL), insert this into your compile        */
  107. X/* line just after "cc" :                                                     */
  108. X/*                                                                            */
  109. X/* -DNOLOOP                                                                   */
  110. X/*                                                                            */
  111. X/* like so:                                                                   */
  112. X/*                                                                            */
  113. X/* cc -DNOLOOP -O asciixmas.c -lcurses -o asciixmas -s                        */
  114. X/*                                                                            */
  115. X/*                                                                            */
  116. X/*                                                                            */
  117. X/******************************************************************************/
  118. X
  119. X#include <curses.h>
  120. X#include <signal.h>
  121. X
  122. X#define FROMWHO "I N F O R M A T I O N  S Y S T E M S  D I V I S I O N"
  123. X/* #define FROMWHO "from  L A R R Y,  C O L L E E N,  S E A N,  &  H A L E Y" */
  124. X
  125. Xint y_pos, x_pos; 
  126. X
  127. XWINDOW
  128. X       *treescrn, *treescrn2,*treescrn3, *treescrn4,*treescrn5, *treescrn6,
  129. X       *treescrn7, *treescrn8,
  130. X       *dotdeer0,
  131. X       *stardeer0,
  132. X       *lildeer0, *lildeer1, *lildeer2, *lildeer3,
  133. X       *middeer0, *middeer1, *middeer2, *middeer3,
  134. X       *bigdeer0, *bigdeer1, *bigdeer2, *bigdeer3, *bigdeer4,
  135. X       *lookdeer0, *lookdeer1, *lookdeer2, *lookdeer3, *lookdeer4,
  136. X       *w_holiday,
  137. X       *w_del_msg;
  138. X
  139. Xmain()
  140. X{
  141. X void done();
  142. X int loopy;
  143. X
  144. X  initscr();
  145. X  noecho();
  146. X  nonl();
  147. X  refresh();
  148. X  signal(SIGINT,done);
  149. X  signal(SIGHUP,done);
  150. X  signal(SIGTERM,done);
  151. X  signal(SIGQUIT,done);
  152. X
  153. X
  154. X
  155. X  treescrn = newwin(16,27,3,53);
  156. X  treescrn2 = newwin(16,27,3,53);
  157. X  treescrn3 = newwin(16,27,3,53);
  158. X  treescrn4 = newwin(16,27,3,53);
  159. X  treescrn5 = newwin(16,27,3,53);
  160. X  treescrn6 = newwin(16,27,3,53);
  161. X  treescrn7 = newwin(16,27,3,53);
  162. X  treescrn8 = newwin(16,27,3,53);
  163. X
  164. X  dotdeer0 = newwin(3,71,0,8);
  165. X
  166. X  stardeer0 = newwin(4,56,0,8);
  167. X
  168. X  lildeer0 = newwin(7,53,0,8);
  169. X  lildeer1 = newwin(2,4,0,0);
  170. X  lildeer2 = newwin(2,4,0,0);
  171. X  lildeer3 = newwin(2,4,0,0);
  172. X
  173. X  middeer0 = newwin(15,42,0,8);
  174. X  middeer1 = newwin(3,7,0,0);
  175. X  middeer2 = newwin(3,7,0,0);
  176. X  middeer3 = newwin(3,7,0,0);
  177. X
  178. X  bigdeer0 = newwin(10,23,0,0);
  179. X  bigdeer1 = newwin(10,23,0,0);
  180. X  bigdeer2 = newwin(10,23,0,0);
  181. X  bigdeer3 = newwin(10,23,0,0);
  182. X  bigdeer4 = newwin(10,23,0,0);
  183. X
  184. X  lookdeer0 = newwin(10,25,0,0);
  185. X  lookdeer1 = newwin(10,25,0,0);
  186. X  lookdeer2 = newwin(10,25,0,0);
  187. X  lookdeer3 = newwin(10,25,0,0);
  188. X  lookdeer4 = newwin(10,25,0,0);
  189. X
  190. X  w_holiday = newwin(1,26,3,27);
  191. X
  192. X  w_del_msg = newwin(1,12,23,68);
  193. X
  194. X  mvwaddstr(w_del_msg,0,0,"DEL to quit");
  195. X
  196. X  mvwaddstr(w_holiday,0,0,"H A P P Y  H O L I D A Y S");
  197. X
  198. X  /* set up the windows for our various reindeer */
  199. X
  200. X  /* lildeer1 */
  201. X  mvwaddch(lildeer1,0,0,'V');
  202. X  mvwaddch(lildeer1,1,0,'@');
  203. X  mvwaddch(lildeer1,1,1,'<');
  204. X  mvwaddch(lildeer1,1,2,'>');
  205. X  mvwaddch(lildeer1,1,3,'~');
  206. X
  207. X  /* lildeer2 */
  208. X  mvwaddch(lildeer2,0,0,'V');
  209. X  mvwaddch(lildeer2,1,0,'@');
  210. X  mvwaddch(lildeer2,1,1,'|');
  211. X  mvwaddch(lildeer2,1,2,'|');
  212. X  mvwaddch(lildeer2,1,3,'~');
  213. X
  214. X  /* lildeer3 */
  215. X  mvwaddch(lildeer3,0,0,'V');
  216. X  mvwaddch(lildeer3,1,0,'@');
  217. X  mvwaddch(lildeer3,1,1,'>');
  218. X  mvwaddch(lildeer3,1,2,'<');
  219. X  mvwaddch(lildeer2,1,3,'~');
  220. X
  221. X
  222. X  /* middeer1 */
  223. X  mvwaddch(middeer1,0,2,'y');
  224. X  mvwaddch(middeer1,0,3,'y');
  225. X  mvwaddch(middeer1,1,2,'0');
  226. X  mvwaddch(middeer1,1,3,'(');
  227. X  mvwaddch(middeer1,1,4,'=');
  228. X  mvwaddch(middeer1,1,5,')');
  229. X  mvwaddch(middeer1,1,6,'~');
  230. X  mvwaddch(middeer1,2,3,'\\');
  231. X  mvwaddch(middeer1,2,4,'/');
  232. X
  233. X  /* middeer2 */
  234. X  mvwaddch(middeer2,0,2,'y');
  235. X  mvwaddch(middeer2,0,3,'y');
  236. X  mvwaddch(middeer2,1,2,'0');
  237. X  mvwaddch(middeer2,1,3,'(');
  238. X  mvwaddch(middeer2,1,4,'=');
  239. X  mvwaddch(middeer2,1,5,')');
  240. X  mvwaddch(middeer2,1,6,'~');
  241. X  mvwaddch(middeer2,2,3,'|');
  242. X  mvwaddch(middeer2,2,5,'|');
  243. X
  244. X  /* middeer3 */
  245. X  mvwaddch(middeer3,0,2,'y');
  246. X  mvwaddch(middeer3,0,3,'y');
  247. X  mvwaddch(middeer3,1,2,'0');
  248. X  mvwaddch(middeer3,1,3,'(');
  249. X  mvwaddch(middeer3,1,4,'=');
  250. X  mvwaddch(middeer3,1,5,')');
  251. X  mvwaddch(middeer3,1,6,'~');
  252. X  mvwaddch(middeer3,2,2,'/');
  253. X  mvwaddch(middeer3,2,6,'\\');
  254. X
  255. X
  256. X  /* bigdeer1 */
  257. X  mvwaddch(bigdeer1,0,17,'\\');
  258. X  mvwaddch(bigdeer1,0,18,'/');
  259. X  mvwaddch(bigdeer1,0,20,'\\');
  260. X  mvwaddch(bigdeer1,0,21,'/');
  261. X  mvwaddch(bigdeer1,1,18,'\\');
  262. X  mvwaddch(bigdeer1,1,20,'/');
  263. X  mvwaddch(bigdeer1,2,19,'|');
  264. X  mvwaddch(bigdeer1,2,20,'_');
  265. X  mvwaddch(bigdeer1,3,18,'/');
  266. X  mvwaddch(bigdeer1,3,19,'^');
  267. X  mvwaddch(bigdeer1,3,20,'0');
  268. X  mvwaddch(bigdeer1,3,21,'\\');
  269. X  mvwaddch(bigdeer1,4,17,'/');
  270. X  mvwaddch(bigdeer1,4,18,'/');
  271. X  mvwaddch(bigdeer1,4,19,'\\');
  272. X  mvwaddch(bigdeer1,4,22,'\\');
  273. X  mvwaddstr(bigdeer1,5,7,"^~~~~~~~~//  ~~U");
  274. X  mvwaddstr(bigdeer1,6,7,"( \\_____( /");
  275. X  mvwaddstr(bigdeer1,7,8,"( )    /");
  276. X  mvwaddstr(bigdeer1,8,9,"\\\\   /");
  277. X  mvwaddstr(bigdeer1,9,11,"\\>/>");
  278. X
  279. X  /* bigdeer2 */
  280. X  mvwaddch(bigdeer2,0,17,'\\');
  281. X  mvwaddch(bigdeer2,0,18,'/');
  282. X  mvwaddch(bigdeer2,0,20,'\\');
  283. X  mvwaddch(bigdeer2,0,21,'/');
  284. X  mvwaddch(bigdeer2,1,18,'\\');
  285. X  mvwaddch(bigdeer2,1,20,'/');
  286. X  mvwaddch(bigdeer2,2,19,'|');
  287. X  mvwaddch(bigdeer2,2,20,'_');
  288. X  mvwaddch(bigdeer2,3,18,'/');
  289. X  mvwaddch(bigdeer2,3,19,'^');
  290. X  mvwaddch(bigdeer2,3,20,'0');
  291. X  mvwaddch(bigdeer2,3,21,'\\');
  292. X  mvwaddch(bigdeer2,4,17,'/');
  293. X  mvwaddch(bigdeer2,4,18,'/');
  294. X  mvwaddch(bigdeer2,4,19,'\\');
  295. X  mvwaddch(bigdeer2,4,22,'\\');
  296. X  mvwaddstr(bigdeer2,5,7,"^~~~~~~~~//  ~~U");
  297. X  mvwaddstr(bigdeer2,6,7,"(( )____( /");
  298. X  mvwaddstr(bigdeer2,7,7,"( /      |");
  299. X  mvwaddstr(bigdeer2,8,8,"\\/      |");
  300. X  mvwaddstr(bigdeer2,9,9,"|>     |>");
  301. X
  302. X  /* bigdeer3 */
  303. X  mvwaddch(bigdeer3,0,17,'\\');
  304. X  mvwaddch(bigdeer3,0,18,'/');
  305. X  mvwaddch(bigdeer3,0,20,'\\');
  306. X  mvwaddch(bigdeer3,0,21,'/');
  307. X  mvwaddch(bigdeer3,1,18,'\\');
  308. X  mvwaddch(bigdeer3,1,20,'/');
  309. X  mvwaddch(bigdeer3,2,19,'|');
  310. X  mvwaddch(bigdeer3,2,20,'_');
  311. X  mvwaddch(bigdeer3,3,18,'/');
  312. X  mvwaddch(bigdeer3,3,19,'^');
  313. X  mvwaddch(bigdeer3,3,20,'0');
  314. X  mvwaddch(bigdeer3,3,21,'\\');
  315. X  mvwaddch(bigdeer3,4,17,'/');
  316. X  mvwaddch(bigdeer3,4,18,'/');
  317. X  mvwaddch(bigdeer3,4,19,'\\');
  318. X  mvwaddch(bigdeer3,4,22,'\\');
  319. X  mvwaddstr(bigdeer3,5,7,"^~~~~~~~~//  ~~U");
  320. X  mvwaddstr(bigdeer3,6,6,"( ()_____( /");
  321. X  mvwaddstr(bigdeer3,7,6,"/ /       /");
  322. X  mvwaddstr(bigdeer3,8,5,"|/          \\");
  323. X  mvwaddstr(bigdeer3,9,5,"/>           \\>");
  324. X
  325. X  /* bigdeer4 */
  326. X  mvwaddch(bigdeer4,0,17,'\\');
  327. X  mvwaddch(bigdeer4,0,18,'/');
  328. X  mvwaddch(bigdeer4,0,20,'\\');
  329. X  mvwaddch(bigdeer4,0,21,'/');
  330. X  mvwaddch(bigdeer4,1,18,'\\');
  331. X  mvwaddch(bigdeer4,1,20,'/');
  332. X  mvwaddch(bigdeer4,2,19,'|');
  333. X  mvwaddch(bigdeer4,2,20,'_');
  334. X  mvwaddch(bigdeer4,3,18,'/');
  335. X  mvwaddch(bigdeer4,3,19,'^');
  336. X  mvwaddch(bigdeer4,3,20,'0');
  337. X  mvwaddch(bigdeer4,3,21,'\\');
  338. X  mvwaddch(bigdeer4,4,17,'/');
  339. X  mvwaddch(bigdeer4,4,18,'/');
  340. X  mvwaddch(bigdeer4,4,19,'\\');
  341. X  mvwaddch(bigdeer4,4,22,'\\');
  342. X  mvwaddstr(bigdeer4,5,7,"^~~~~~~~~//  ~~U");
  343. X  mvwaddstr(bigdeer4,6,6,"( )______( /");
  344. X  mvwaddstr(bigdeer4,7,5,"(/          \\");
  345. X  mvwaddstr(bigdeer4,8,0,"v___=             ----^");
  346. X
  347. X
  348. X  /* lookdeer1 */
  349. X  mvwaddstr(lookdeer1,0,16,"\\/     \\/");
  350. X  mvwaddstr(lookdeer1,1,17,"\\Y/ \\Y/");
  351. X  mvwaddstr(lookdeer1,2,19,"\\=/");
  352. X  mvwaddstr(lookdeer1,3,17,"^\\o o/^");
  353. X  mvwaddstr(lookdeer1,4,17,"//( )");
  354. X  mvwaddstr(lookdeer1,5,7,"^~~~~~~~~// \\O/");
  355. X  mvwaddstr(lookdeer1,6,7,"( \\_____( /");
  356. X  mvwaddstr(lookdeer1,7,8,"( )    /");
  357. X  mvwaddstr(lookdeer1,8,9,"\\\\   /");
  358. X  mvwaddstr(lookdeer1,9,11,"\\>/>");
  359. X
  360. X  /* lookdeer2 */
  361. X  mvwaddstr(lookdeer2,0,16,"\\/     \\/");
  362. X  mvwaddstr(lookdeer2,1,17,"\\Y/ \\Y/");
  363. X  mvwaddstr(lookdeer2,2,19,"\\=/");
  364. X  mvwaddstr(lookdeer2,3,17,"^\\o o/^");
  365. X  mvwaddstr(lookdeer2,4,17,"//( )");
  366. X  mvwaddstr(lookdeer2,5,7,"^~~~~~~~~// \\O/");
  367. X  mvwaddstr(lookdeer2,6,7,"(( )____( /");
  368. X  mvwaddstr(lookdeer2,7,7,"( /      |");
  369. X  mvwaddstr(lookdeer2,8,8,"\\/      |");
  370. X  mvwaddstr(lookdeer2,9,9,"|>     |>");
  371. X
  372. X  /* lookdeer3 */
  373. X  mvwaddstr(lookdeer3,0,16,"\\/     \\/");
  374. X  mvwaddstr(lookdeer3,1,17,"\\Y/ \\Y/");
  375. X  mvwaddstr(lookdeer3,2,19,"\\=/");
  376. X  mvwaddstr(lookdeer3,3,17,"^\\o o/^");
  377. X  mvwaddstr(lookdeer3,4,17,"//( )");
  378. X  mvwaddstr(lookdeer3,5,7,"^~~~~~~~~// \\O/");
  379. X  mvwaddstr(lookdeer3,6,6,"( ()_____( /");
  380. X  mvwaddstr(lookdeer3,7,6,"/ /       /");
  381. X  mvwaddstr(lookdeer3,8,5,"|/          \\");
  382. X  mvwaddstr(lookdeer3,9,5,"/>           \\>");
  383. X
  384. X  /* lookdeer4 */
  385. X  mvwaddstr(lookdeer4,0,16,"\\/     \\/");
  386. X  mvwaddstr(lookdeer4,1,17,"\\Y/ \\Y/");
  387. X  mvwaddstr(lookdeer4,2,19,"\\=/");
  388. X  mvwaddstr(lookdeer4,3,17,"^\\o o/^");
  389. X  mvwaddstr(lookdeer4,4,17,"//( )");
  390. X  mvwaddstr(lookdeer4,5,7,"^~~~~~~~~// \\O/");
  391. X  mvwaddstr(lookdeer4,6,6,"( )______( /");
  392. X  mvwaddstr(lookdeer4,7,5,"(/          \\");
  393. X  mvwaddstr(lookdeer4,8,0,"v___=             ----^");
  394. X
  395. X
  396. X
  397. X  /***********************************************/
  398. X
  399. X  while(1)
  400. X  {
  401. X    clear();
  402. X    werase(treescrn);
  403. X    touchwin(treescrn);
  404. X    werase(treescrn2);
  405. X    touchwin(treescrn2);
  406. X    werase(treescrn8);
  407. X    touchwin(treescrn8);
  408. X    refresh();
  409. X    sleep(1);
  410. X    boxit();
  411. X    del_msg();
  412. X    sleep(1);
  413. X    seas();
  414. X    del_msg();
  415. X    sleep(1);
  416. X    greet();
  417. X    del_msg();
  418. X    sleep(1);
  419. X    fromwho();
  420. X    del_msg();
  421. X    sleep(1);
  422. X    tree();
  423. X    sleep(1);
  424. X    balls();
  425. X    sleep(1);
  426. X    star();
  427. X    sleep(1);
  428. X    strng1();
  429. X    strng2();
  430. X    strng3();
  431. X    strng4();
  432. X    strng5();
  433. X
  434. X
  435. X  /* set up the windows for our blinking trees */
  436. X  /* **************************************** */
  437. X  /* treescrn3 */
  438. X
  439. X               overwrite(treescrn, treescrn3);
  440. X
  441. X             /*balls*/
  442. X               mvwaddch(treescrn3, 4, 18, ' ');
  443. X               mvwaddch(treescrn3, 7, 6, ' ');
  444. X               mvwaddch(treescrn3, 8, 19, ' ');
  445. X               mvwaddch(treescrn3, 11, 22, ' ');
  446. X             
  447. X             /*star*/
  448. X               mvwaddch(treescrn3, 0, 12, '*');
  449. X             
  450. X             /*strng1*/
  451. X               mvwaddch(treescrn3, 3, 11, ' ');
  452. X             
  453. X             /*strng2*/
  454. X               mvwaddch(treescrn3, 5, 13, ' ');
  455. X               mvwaddch(treescrn3, 6, 10, ' ');
  456. X             
  457. X             /*strng3*/
  458. X               mvwaddch(treescrn3, 7, 16, ' ');
  459. X               mvwaddch(treescrn3, 7, 14, ' ');
  460. X             
  461. X             /*strng4*/
  462. X               mvwaddch(treescrn3, 10, 13, ' ');
  463. X               mvwaddch(treescrn3, 10, 10, ' ');
  464. X               mvwaddch(treescrn3, 11, 8, ' ');
  465. X             
  466. X             /*strng5*/
  467. X               mvwaddch(treescrn3, 11, 18, ' ');
  468. X               mvwaddch(treescrn3, 12, 13, ' ');
  469. X             
  470. X             
  471. X  /* treescrn4 */
  472. X
  473. X               overwrite(treescrn, treescrn4);
  474. X
  475. X             /*balls*/
  476. X               mvwaddch(treescrn4, 3, 9, ' ');
  477. X               mvwaddch(treescrn4, 4, 16, ' ');
  478. X               mvwaddch(treescrn4, 7, 6, ' ');
  479. X               mvwaddch(treescrn4, 8, 19, ' ');
  480. X               mvwaddch(treescrn4, 11, 2, ' ');
  481. X               mvwaddch(treescrn4, 12, 23, ' ');
  482. X             
  483. X             /*star*/
  484. X               wstandout(treescrn4);
  485. X               mvwaddch(treescrn4, 0, 12, '*');
  486. X               wstandend(treescrn4);
  487. X             
  488. X             /*strng1*/
  489. X               mvwaddch(treescrn4, 3, 13, ' ');
  490. X             
  491. X             /*strng2*/
  492. X             
  493. X             /*strng3*/
  494. X               mvwaddch(treescrn4, 7, 15, ' ');
  495. X               mvwaddch(treescrn4, 8, 11, ' ');
  496. X             
  497. X             /*strng4*/
  498. X               mvwaddch(treescrn4, 9, 16, ' ');
  499. X               mvwaddch(treescrn4, 10, 12, ' ');
  500. X               mvwaddch(treescrn4, 11, 8, ' ');
  501. X             
  502. X             /*strng5*/
  503. X               mvwaddch(treescrn4, 11, 18, ' ');
  504. X               mvwaddch(treescrn4, 12, 14, ' ');
  505. X             
  506. X             
  507. X  /* treescrn5 */
  508. X
  509. X               overwrite(treescrn, treescrn5);
  510. X
  511. X             /*balls*/
  512. X               mvwaddch(treescrn5, 3, 15, ' ');
  513. X               mvwaddch(treescrn5, 10, 20, ' ');
  514. X               mvwaddch(treescrn5, 12, 1, ' ');
  515. X             
  516. X             /*star*/
  517. X               mvwaddch(treescrn5, 0, 12, '*');
  518. X             
  519. X             /*strng1*/
  520. X               mvwaddch(treescrn5, 3, 11, ' ');
  521. X             
  522. X             /*strng2*/
  523. X               mvwaddch(treescrn5, 5, 12, ' ');
  524. X             
  525. X             /*strng3*/
  526. X               mvwaddch(treescrn5, 7, 14, ' ');
  527. X               mvwaddch(treescrn5, 8, 10, ' ');
  528. X             
  529. X             /*strng4*/
  530. X               mvwaddch(treescrn5, 9, 15, ' ');
  531. X               mvwaddch(treescrn5, 10, 11, ' ');
  532. X               mvwaddch(treescrn5, 11, 7, ' ');
  533. X             
  534. X             /*strng5*/
  535. X               mvwaddch(treescrn5, 11, 17, ' ');
  536. X               mvwaddch(treescrn5, 12, 13, ' ');
  537. X             
  538. X  /* treescrn6 */
  539. X
  540. X               overwrite(treescrn, treescrn6);
  541. X
  542. X             /*balls*/
  543. X               mvwaddch(treescrn6, 6, 7, ' ');
  544. X               mvwaddch(treescrn6, 7, 18, ' ');
  545. X               mvwaddch(treescrn6, 10, 4, ' ');
  546. X               mvwaddch(treescrn6, 11, 23, ' ');
  547. X             
  548. X             /*star*/
  549. X               wstandout(treescrn6);
  550. X               mvwaddch(treescrn6, 0, 12, '*');
  551. X               wstandend(treescrn6);
  552. X             
  553. X             /*strng1*/
  554. X             
  555. X             /*strng2*/
  556. X               mvwaddch(treescrn6, 5, 11, ' ');
  557. X             
  558. X             /*strng3*/
  559. X               mvwaddch(treescrn6, 7, 13, ' ');
  560. X               mvwaddch(treescrn6, 8, 9, ' ');
  561. X             
  562. X             /*strng4*/
  563. X               mvwaddch(treescrn6, 9, 14, ' ');
  564. X               mvwaddch(treescrn6, 10, 10, ' ');
  565. X               mvwaddch(treescrn6, 11, 6, ' ');
  566. X             
  567. X             /*strng5*/
  568. X               mvwaddch(treescrn6, 11, 16, ' ');
  569. X               mvwaddch(treescrn6, 12, 12, ' ');
  570. X             
  571. X  /* treescrn7 */
  572. X
  573. X               overwrite(treescrn, treescrn7);
  574. X
  575. X             /*balls*/
  576. X               mvwaddch(treescrn7, 3, 15, ' ');
  577. X               mvwaddch(treescrn7, 6, 7, ' ');
  578. X               mvwaddch(treescrn7, 7, 18, ' ');
  579. X               mvwaddch(treescrn7, 10, 4, ' ');
  580. X               mvwaddch(treescrn7, 11, 22, ' ');
  581. X             
  582. X             /*star*/
  583. X               mvwaddch(treescrn7, 0, 12, '*');
  584. X             
  585. X             /*strng1*/
  586. X               mvwaddch(treescrn7, 3, 12, ' ');
  587. X             
  588. X             /*strng2*/
  589. X               mvwaddch(treescrn7, 5, 13, ' ');
  590. X               mvwaddch(treescrn7, 6, 9, ' ');
  591. X             
  592. X             /*strng3*/
  593. X               mvwaddch(treescrn7, 7, 15, ' ');
  594. X               mvwaddch(treescrn7, 8, 11, ' ');
  595. X             
  596. X             /*strng4*/
  597. X               mvwaddch(treescrn7, 9, 16, ' ');
  598. X               mvwaddch(treescrn7, 10, 12, ' ');
  599. X               mvwaddch(treescrn7, 11, 8, ' ');
  600. X             
  601. X             /*strng5*/
  602. X               mvwaddch(treescrn7, 11, 18, ' ');
  603. X               mvwaddch(treescrn7, 12, 14, ' ');
  604. X             
  605. X
  606. X    sleep(1);
  607. X    reindeer();
  608. X
  609. X    touchwin(w_holiday);
  610. X    wrefresh(w_holiday);
  611. X    wrefresh(w_del_msg);
  612. X
  613. X    sleep(1);
  614. X    for(loopy = 0;loopy < 100;loopy++)
  615. X    {
  616. X      blinkit();
  617. X    }
  618. X
  619. X#ifdef NOLOOP
  620. X    done();
  621. X#endif
  622. X
  623. X  }
  624. X}
  625. X
  626. Xboxit()
  627. X{
  628. X int x = 0;
  629. X
  630. X  while(x < 20)
  631. X  {
  632. X    mvaddch(x, 7, '|');
  633. X    ++x;
  634. X  }
  635. X  
  636. X  x = 8;
  637. X
  638. X  while(x < 80)
  639. X  {
  640. X    mvaddch(19, x, '_');
  641. X    ++x;
  642. X  }
  643. X  
  644. X  x = 0;
  645. X
  646. X  while(x < 80)
  647. X  {
  648. X    mvaddch(22, x, '_');
  649. X    ++x;
  650. X  }
  651. X  
  652. X
  653. X}
  654. X
  655. Xseas()
  656. X{
  657. X  mvaddch(4, 1, 'S');
  658. X  mvaddch(6, 1, 'E');
  659. X  mvaddch(8, 1, 'A');
  660. X  mvaddch(10, 1, 'S');
  661. X  mvaddch(12, 1, 'O');
  662. X  mvaddch(14, 1, 'N');
  663. X  mvaddch(16, 1, '`');
  664. X  mvaddch(18, 1, 'S');
  665. X
  666. X}
  667. X
  668. X
  669. Xgreet()
  670. X{
  671. X  mvaddch(3, 5, 'G');
  672. X  mvaddch(5, 5, 'R');
  673. X  mvaddch(7, 5, 'E');
  674. X  mvaddch(9, 5, 'E');
  675. X  mvaddch(11, 5, 'T');
  676. X  mvaddch(13, 5, 'I');
  677. X  mvaddch(15, 5, 'N');
  678. X  mvaddch(17, 5, 'G');
  679. X  mvaddch(19, 5, 'S');
  680. X
  681. X}
  682. X
  683. X
  684. Xfromwho()
  685. X{
  686. X  mvaddstr(21, 13, FROMWHO);
  687. X
  688. X}
  689. X
  690. X
  691. Xdel_msg()
  692. X{
  693. X  mvaddstr(23, 68, "DEL to quit");
  694. X
  695. X  refresh();
  696. X
  697. X}
  698. X
  699. X
  700. Xtree()
  701. X{
  702. X  mvwaddch(treescrn, 1, 11, '/');
  703. X  mvwaddch(treescrn, 2, 11, '/');
  704. X  mvwaddch(treescrn, 3, 10, '/');
  705. X  mvwaddch(treescrn, 4, 9, '/');
  706. X  mvwaddch(treescrn, 5, 9, '/');
  707. X  mvwaddch(treescrn, 6, 8, '/');
  708. X  mvwaddch(treescrn, 7, 7, '/');
  709. X  mvwaddch(treescrn, 8, 6, '/');
  710. X  mvwaddch(treescrn, 9, 6, '/');
  711. X  mvwaddch(treescrn, 10, 5, '/');
  712. X  mvwaddch(treescrn, 11, 3, '/');
  713. X  mvwaddch(treescrn, 12, 2, '/');
  714. X
  715. X  mvwaddch(treescrn, 1, 13, '\\');
  716. X  mvwaddch(treescrn, 2, 13, '\\');
  717. X  mvwaddch(treescrn, 3, 14, '\\');
  718. X  mvwaddch(treescrn, 4, 15, '\\');
  719. X  mvwaddch(treescrn, 5, 15, '\\');
  720. X  mvwaddch(treescrn, 6, 16, '\\');
  721. X  mvwaddch(treescrn, 7, 17, '\\');
  722. X  mvwaddch(treescrn, 8, 18, '\\');
  723. X  mvwaddch(treescrn, 9, 18, '\\');
  724. X  mvwaddch(treescrn, 10, 19, '\\');
  725. X  mvwaddch(treescrn, 11, 21, '\\');
  726. X  mvwaddch(treescrn, 12, 22, '\\');
  727. X
  728. X  mvwaddch(treescrn, 4, 10, '_');
  729. X  mvwaddch(treescrn, 4, 14, '_');
  730. X  mvwaddch(treescrn, 8, 7, '_');
  731. X  mvwaddch(treescrn, 8, 17, '_');
  732. X
  733. X  mvwaddstr(treescrn, 13, 0, "//////////// \\\\\\\\\\\\\\\\\\\\\\\\");
  734. X
  735. X  mvwaddstr(treescrn, 14, 11, "| |");
  736. X  mvwaddstr(treescrn, 15, 11, "|_|");
  737. X
  738. X  wrefresh(treescrn);
  739. X  wrefresh(w_del_msg);
  740. X
  741. X}
  742. X
  743. X
  744. Xballs()
  745. X{
  746. X
  747. X  overwrite(treescrn, treescrn2);
  748. X
  749. X  mvwaddch(treescrn2, 3, 9, '@');
  750. X  mvwaddch(treescrn2, 3, 15, '@');
  751. X  mvwaddch(treescrn2, 4, 8, '@');
  752. X  mvwaddch(treescrn2, 4, 16, '@');
  753. X  mvwaddch(treescrn2, 5, 7, '@');
  754. X  mvwaddch(treescrn2, 5, 17, '@');
  755. X  mvwaddch(treescrn2, 7, 6, '@');
  756. X  mvwaddch(treescrn2, 7, 18, '@');
  757. X  mvwaddch(treescrn2, 8, 5, '@');
  758. X  mvwaddch(treescrn2, 8, 19, '@');
  759. X  mvwaddch(treescrn2, 10, 4, '@');
  760. X  mvwaddch(treescrn2, 10, 20, '@');
  761. X  mvwaddch(treescrn2, 11, 2, '@');
  762. X  mvwaddch(treescrn2, 11, 22, '@');
  763. X  mvwaddch(treescrn2, 12, 1, '@');
  764. X  mvwaddch(treescrn2, 12, 23, '@');
  765. X
  766. X  wrefresh(treescrn2);
  767. X  wrefresh(w_del_msg);
  768. X}
  769. X
  770. X
  771. Xstar()
  772. X{
  773. X  wstandout(treescrn2);
  774. X  mvwaddch(treescrn2, 0, 12, '*');
  775. X  wstandend(treescrn2);
  776. X
  777. X  wrefresh(treescrn2);
  778. X  wrefresh(w_del_msg);
  779. X}
  780. X
  781. X
  782. Xstrng1()
  783. X{
  784. X  mvwaddch(treescrn2, 3, 13, '\'');
  785. X  mvwaddch(treescrn2, 3, 12, ':');
  786. X  mvwaddch(treescrn2, 3, 11, '.');
  787. X
  788. X  wrefresh(treescrn2);
  789. X  wrefresh(w_del_msg);
  790. X}
  791. X
  792. X
  793. Xstrng2()
  794. X{
  795. X  mvwaddch(treescrn2, 5, 14, '\'');
  796. X  mvwaddch(treescrn2, 5, 13, ':');
  797. X  mvwaddch(treescrn2, 5, 12, '.');
  798. X  mvwaddch(treescrn2, 5, 11, ',');
  799. X  mvwaddch(treescrn2, 6, 10, '\'');
  800. X  mvwaddch(treescrn2, 6, 9, ':');
  801. X
  802. X  wrefresh(treescrn2);
  803. X  wrefresh(w_del_msg);
  804. X}
  805. X
  806. X
  807. Xstrng3()
  808. X{
  809. X  mvwaddch(treescrn2, 7, 16, '\'');
  810. X  mvwaddch(treescrn2, 7, 15, ':');
  811. X  mvwaddch(treescrn2, 7, 14, '.');
  812. X  mvwaddch(treescrn2, 7, 13, ',');
  813. X  mvwaddch(treescrn2, 8, 12, '\'');
  814. X  mvwaddch(treescrn2, 8, 11, ':');
  815. X  mvwaddch(treescrn2, 8, 10, '.');
  816. X  mvwaddch(treescrn2, 8, 9, ',');
  817. X
  818. X  wrefresh(treescrn2);
  819. X  wrefresh(w_del_msg);
  820. X}
  821. X
  822. X
  823. Xstrng4()
  824. X{
  825. X  mvwaddch(treescrn2, 9, 17, '\'');
  826. X  mvwaddch(treescrn2, 9, 16, ':');
  827. X  mvwaddch(treescrn2, 9, 15, '.');
  828. X  mvwaddch(treescrn2, 9, 14, ',');
  829. X  mvwaddch(treescrn2, 10, 13, '\'');
  830. X  mvwaddch(treescrn2, 10, 12, ':');
  831. X  mvwaddch(treescrn2, 10, 11, '.');
  832. X  mvwaddch(treescrn2, 10, 10, ',');
  833. X  mvwaddch(treescrn2, 11, 9, '\'');
  834. X  mvwaddch(treescrn2, 11, 8, ':');
  835. X  mvwaddch(treescrn2, 11, 7, '.');
  836. X  mvwaddch(treescrn2, 11, 6, ',');
  837. X  mvwaddch(treescrn2, 12, 5, '\'');
  838. X
  839. X  wrefresh(treescrn2);
  840. X  wrefresh(w_del_msg);
  841. X}
  842. X
  843. X
  844. Xstrng5()
  845. X{
  846. X  mvwaddch(treescrn2, 11, 19, '\'');
  847. X  mvwaddch(treescrn2, 11, 18, ':');
  848. X  mvwaddch(treescrn2, 11, 17, '.');
  849. X  mvwaddch(treescrn2, 11, 16, ',');
  850. X  mvwaddch(treescrn2, 12, 15, '\'');
  851. X  mvwaddch(treescrn2, 12, 14, ':');
  852. X  mvwaddch(treescrn2, 12, 13, '.');
  853. X  mvwaddch(treescrn2, 12, 12, ',');
  854. X
  855. X  /* save a fully lit tree */
  856. X  overwrite(treescrn2, treescrn);
  857. X
  858. X  wrefresh(treescrn2);
  859. X  wrefresh(w_del_msg);
  860. X}
  861. X
  862. X
  863. X
  864. Xblinkit()
  865. X{
  866. X static int cycle;
  867. X
  868. X  if(cycle > 4)
  869. X  {
  870. X    cycle = 0;
  871. X  }
  872. X
  873. X
  874. X  touchwin(treescrn8);
  875. X
  876. X  switch(cycle)
  877. X  {
  878. X
  879. X    case 0:
  880. X               overwrite(treescrn3,treescrn8);
  881. X               wrefresh(treescrn8);
  882. X               wrefresh(w_del_msg);
  883. X               
  884. X               break;
  885. X    case 1:
  886. X               overwrite(treescrn4,treescrn8);
  887. X               wrefresh(treescrn8);
  888. X               wrefresh(w_del_msg);
  889. X               
  890. X               break;
  891. X    case 2:
  892. X               overwrite(treescrn5,treescrn8);
  893. X               wrefresh(treescrn8);
  894. X               wrefresh(w_del_msg);
  895. X               
  896. X               break;
  897. X    case 3:
  898. X               overwrite(treescrn6,treescrn8);
  899. X               wrefresh(treescrn8);
  900. X               wrefresh(w_del_msg);
  901. X               
  902. X               break;
  903. X    case 4:
  904. X               overwrite(treescrn7,treescrn8);
  905. X               wrefresh(treescrn8);
  906. X               wrefresh(w_del_msg);
  907. X               
  908. X               break;
  909. X  }
  910. X
  911. X   touchwin(treescrn8);
  912. X
  913. X
  914. X
  915. X   /*ALL ON***************************************************/
  916. X
  917. X
  918. X   overwrite(treescrn,treescrn8);
  919. X   wrefresh(treescrn8);
  920. X   wrefresh(w_del_msg);
  921. X             
  922. X
  923. X  ++cycle;
  924. X}
  925. X
  926. X
  927. Xreindeer()
  928. X{
  929. X int looper;
  930. X
  931. X  y_pos = 0;
  932. X
  933. X
  934. X  for(x_pos = 70; x_pos > 62; x_pos--)
  935. X  {
  936. X    if(x_pos < 62)
  937. X    {
  938. X      y_pos = 1;
  939. X    }
  940. X    for(looper = 0; looper < 4; looper++)
  941. X    {
  942. X      mvwaddch(dotdeer0, y_pos, x_pos, '.');
  943. X      wrefresh(dotdeer0);
  944. X      wrefresh(w_del_msg);
  945. X      werase(dotdeer0);
  946. X      wrefresh(dotdeer0);
  947. X      wrefresh(w_del_msg);
  948. X    }
  949. X  }
  950. X
  951. X  y_pos = 2;
  952. X
  953. X  for(x_pos; x_pos > 50; x_pos--)
  954. X  {
  955. X
  956. X    for(looper = 0; looper < 4; looper++)
  957. X    {
  958. X
  959. X      if(x_pos < 56)
  960. X      {
  961. X        y_pos = 3;
  962. X
  963. X        mvwaddch(stardeer0, y_pos, x_pos, '*');
  964. X        wrefresh(stardeer0);
  965. X        wrefresh(w_del_msg);
  966. X        werase(stardeer0);
  967. X        wrefresh(stardeer0);
  968. X        wrefresh(w_del_msg);
  969. X      }
  970. X      else
  971. X      {
  972. X        mvwaddch(dotdeer0, y_pos, x_pos, '*');
  973. X        wrefresh(dotdeer0);
  974. X        wrefresh(w_del_msg);
  975. X        werase(dotdeer0);
  976. X        wrefresh(dotdeer0);
  977. X        wrefresh(w_del_msg);
  978. X      }
  979. X    }
  980. X  }
  981. X
  982. X  x_pos = 58;
  983. X
  984. X  for(y_pos = 2; y_pos < 5; y_pos++)
  985. X  {
  986. X    
  987. X    touchwin(lildeer0);
  988. X    wrefresh(lildeer0);
  989. X    wrefresh(w_del_msg);
  990. X
  991. X    for(looper = 0; looper < 4; looper++)
  992. X    {
  993. X      mvwin(lildeer3, y_pos, x_pos);
  994. X      wrefresh(lildeer3);
  995. X      wrefresh(w_del_msg);
  996. X
  997. X      mvwin(lildeer2, y_pos, x_pos);
  998. X      wrefresh(lildeer2);
  999. X      wrefresh(w_del_msg);
  1000. X
  1001. X      mvwin(lildeer1, y_pos, x_pos);
  1002. X      wrefresh(lildeer1);
  1003. X      wrefresh(w_del_msg);
  1004. X
  1005. X      mvwin(lildeer2, y_pos, x_pos);
  1006. X      wrefresh(lildeer2);
  1007. X      wrefresh(w_del_msg);
  1008. X
  1009. X      mvwin(lildeer3, y_pos, x_pos);
  1010. X      wrefresh(lildeer3);
  1011. X      wrefresh(w_del_msg);
  1012. X
  1013. X      touchwin(lildeer0);
  1014. X      wrefresh(lildeer0);
  1015. X      wrefresh(w_del_msg);
  1016. X
  1017. X      x_pos -= 2;
  1018. X    }
  1019. X  }
  1020. X
  1021. X
  1022. X  x_pos = 35;
  1023. X
  1024. X  for(y_pos = 5; y_pos < 10; y_pos++)
  1025. X  {
  1026. X    
  1027. X    touchwin(middeer0);
  1028. X    wrefresh(middeer0);
  1029. X    wrefresh(w_del_msg);
  1030. X
  1031. X    for(looper = 0; looper < 2; looper++)
  1032. X    {
  1033. X      mvwin(middeer3, y_pos, x_pos);
  1034. X      wrefresh(middeer3);
  1035. X      wrefresh(w_del_msg);
  1036. X
  1037. X      mvwin(middeer2, y_pos, x_pos);
  1038. X      wrefresh(middeer2);
  1039. X      wrefresh(w_del_msg);
  1040. X
  1041. X      mvwin(middeer1, y_pos, x_pos);
  1042. X      wrefresh(middeer1);
  1043. X      wrefresh(w_del_msg);
  1044. X
  1045. X      mvwin(middeer2, y_pos, x_pos);
  1046. X      wrefresh(middeer2);
  1047. X      wrefresh(w_del_msg);
  1048. X
  1049. X      mvwin(middeer3, y_pos, x_pos);
  1050. X      wrefresh(middeer3);
  1051. X      wrefresh(w_del_msg);
  1052. X
  1053. X      touchwin(middeer0);
  1054. X      wrefresh(middeer0);
  1055. X      wrefresh(w_del_msg);
  1056. X
  1057. X      x_pos -= 3;
  1058. X    }
  1059. X  }
  1060. X
  1061. X  sleep(2);
  1062. X
  1063. X  y_pos = 1;
  1064. X
  1065. X  for(x_pos = 8; x_pos < 16; x_pos++)
  1066. X  {
  1067. X  
  1068. X      mvwin(bigdeer4, y_pos, x_pos);
  1069. X      wrefresh(bigdeer4);
  1070. X      wrefresh(w_del_msg);
  1071. X
  1072. X      mvwin(bigdeer3, y_pos, x_pos);
  1073. X      wrefresh(bigdeer3);
  1074. X      wrefresh(w_del_msg);
  1075. X
  1076. X      mvwin(bigdeer2, y_pos, x_pos);
  1077. X      wrefresh(bigdeer2);
  1078. X      wrefresh(w_del_msg);
  1079. X
  1080. X      mvwin(bigdeer1, y_pos, x_pos);
  1081. X      wrefresh(bigdeer1);
  1082. X      wrefresh(w_del_msg);
  1083. X
  1084. X      mvwin(bigdeer2, y_pos, x_pos);
  1085. X      wrefresh(bigdeer2);
  1086. X      wrefresh(w_del_msg);
  1087. X
  1088. X      mvwin(bigdeer3, y_pos, x_pos);
  1089. X      wrefresh(bigdeer3);
  1090. X      wrefresh(w_del_msg);
  1091. X
  1092. X      mvwin(bigdeer4, y_pos, x_pos);
  1093. X      wrefresh(bigdeer4);
  1094. X      wrefresh(w_del_msg);
  1095. X
  1096. X      mvwin(bigdeer0, y_pos, x_pos);
  1097. X      wrefresh(bigdeer0);
  1098. X      wrefresh(w_del_msg);
  1099. X  }
  1100. X
  1101. X    --x_pos;
  1102. X
  1103. X    for(looper = 0; looper < 6; looper++)
  1104. X    {
  1105. X      mvwin(lookdeer4, y_pos, x_pos);
  1106. X      wrefresh(lookdeer4);
  1107. X      wrefresh(w_del_msg);
  1108. X
  1109. X      mvwin(lookdeer3, y_pos, x_pos);
  1110. X      wrefresh(lookdeer3);
  1111. X      wrefresh(w_del_msg);
  1112. X
  1113. X      mvwin(lookdeer2, y_pos, x_pos);
  1114. X      wrefresh(lookdeer2);
  1115. X      wrefresh(w_del_msg);
  1116. X
  1117. X      mvwin(lookdeer1, y_pos, x_pos);
  1118. X      wrefresh(lookdeer1);
  1119. X      wrefresh(w_del_msg);
  1120. X
  1121. X      mvwin(lookdeer2, y_pos, x_pos);
  1122. X      wrefresh(lookdeer2);
  1123. X      wrefresh(w_del_msg);
  1124. X
  1125. X      mvwin(lookdeer3, y_pos, x_pos);
  1126. X      wrefresh(lookdeer3);
  1127. X      wrefresh(w_del_msg);
  1128. X
  1129. X      mvwin(lookdeer4, y_pos, x_pos);
  1130. X      wrefresh(lookdeer4);
  1131. X      wrefresh(w_del_msg);
  1132. X
  1133. X    }
  1134. X
  1135. X    mvwin(lookdeer0, y_pos, x_pos);
  1136. X    wrefresh(lookdeer0);
  1137. X    wrefresh(w_del_msg);
  1138. X
  1139. X  for(y_pos; y_pos < 10; y_pos++)
  1140. X  {
  1141. X
  1142. X    for(looper = 0; looper < 2; looper++)
  1143. X    {
  1144. X      mvwin(bigdeer4, y_pos, x_pos);
  1145. X      wrefresh(bigdeer4);
  1146. X      wrefresh(w_del_msg);
  1147. X
  1148. X      mvwin(bigdeer3, y_pos, x_pos);
  1149. X      wrefresh(bigdeer3);
  1150. X      wrefresh(w_del_msg);
  1151. X
  1152. X      mvwin(bigdeer2, y_pos, x_pos);
  1153. X      wrefresh(bigdeer2);
  1154. X      wrefresh(w_del_msg);
  1155. X
  1156. X      mvwin(bigdeer1, y_pos, x_pos);
  1157. X      wrefresh(bigdeer1);
  1158. X      wrefresh(w_del_msg);
  1159. X
  1160. X      mvwin(bigdeer2, y_pos, x_pos);
  1161. X      wrefresh(bigdeer2);
  1162. X      wrefresh(w_del_msg);
  1163. X
  1164. X      mvwin(bigdeer3, y_pos, x_pos);
  1165. X      wrefresh(bigdeer3);
  1166. X      wrefresh(w_del_msg);
  1167. X
  1168. X      mvwin(bigdeer4, y_pos, x_pos);
  1169. X      wrefresh(bigdeer4);
  1170. X      wrefresh(w_del_msg);
  1171. X    }
  1172. X      mvwin(bigdeer0, y_pos, x_pos);
  1173. X      wrefresh(bigdeer0);
  1174. X      wrefresh(w_del_msg);
  1175. X  }
  1176. X
  1177. X  --y_pos;
  1178. X
  1179. X  mvwin(lookdeer3, y_pos, x_pos);
  1180. X  wrefresh(lookdeer3);
  1181. X  wrefresh(w_del_msg);
  1182. X
  1183. X}
  1184. X
  1185. X
  1186. X
  1187. Xvoid done()
  1188. X{
  1189. X  signal(SIGINT,done);
  1190. X  signal(SIGHUP,done);
  1191. X  signal(SIGTERM,done);
  1192. X  signal(SIGQUIT,done);
  1193. X  clear();
  1194. X  refresh();
  1195. X  endwin();
  1196. X  exit(0);
  1197. X}
  1198. EOF
  1199. chars=`wc -c < 'asciixmas.c'`
  1200. if test $chars !=    32310; then echo 'asciixmas.c' is $chars characters, should be    32310 characters!; fi
  1201. fi
  1202. exit 0
  1203. -----------------------snip-------------------------------
  1204. -- 
  1205. "Hey Rocky, watch me pull a rabbit out of my hat."         Bullwinkle Moose
  1206.     "oh...a wise guy....Come here....I'll murder ya..."      Moe Howard
  1207.         "I'm hunting wabbits...."                        Elmer Fudd
  1208.             "If I could typ I'd be dangerous"      Rich Andrews
  1209.  
  1210.