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