home *** CD-ROM | disk | FTP | other *** search
/ Source Code 1994 March / Source_Code_CD-ROM_Walnut_Creek_March_1994.iso / compsrcs / x / volume20 / xboing / part24 < prev    next >
Encoding:
Text File  |  1993-09-03  |  54.3 KB  |  1,517 lines
  1. Newsgroups: comp.sources.x
  2. From: jck@kimba.catt.citri.edu.au (Justin Kibell)
  3. Subject: v20i131:  xboing - a simple blockout type game, Part24/26
  4. Message-ID: <1993Sep3.123633.8615@sparky.sterling.com>
  5. X-Md4-Signature: 3f4dce49785ac64cd8c18b61b86199a8
  6. Sender: chris@sparky.sterling.com (Chris Olson)
  7. Organization: Sterling Software
  8. Date: Fri, 3 Sep 1993 12:36:33 GMT
  9. Approved: chris@sterling.com
  10.  
  11. Submitted-by: jck@kimba.catt.citri.edu.au (Justin Kibell)
  12. Posting-number: Volume 20, Issue 131
  13. Archive-name: xboing/part24
  14. Environment: X11, xpm, color
  15.  
  16. #! /bin/sh
  17. # This is a shell archive.  Remove anything before this line, then feed it
  18. # into a shell via "sh file" or similar.  To overwrite existing files,
  19. # type "sh file -c".
  20. # Contents:  audio/README.audio bitmaps/blueblock.xpm
  21. #   bitmaps/bullet.xpm bitmaps/counterblock.xpm
  22. #   bitmaps/counterblock1.xpm bitmaps/counterblock3.xpm
  23. #   bitmaps/exblueblock1.xpm bitmaps/exblueblock2.xpm
  24. #   bitmaps/exblueblock3.xpm bitmaps/exgreenblock1.xpm
  25. #   bitmaps/exgreenblock2.xpm bitmaps/exgreenblock3.xpm
  26. #   bitmaps/expurpleblock1.xpm bitmaps/expurpleblock2.xpm
  27. #   bitmaps/expurpleblock3.xpm bitmaps/exredblock1.xpm
  28. #   bitmaps/exredblock2.xpm bitmaps/exredblock3.xpm
  29. #   bitmaps/extanblock1.xpm bitmaps/extanblock2.xpm
  30. #   bitmaps/extanblock3.xpm bitmaps/exx2bonus3.xpm
  31. #   bitmaps/exyellowblock1.xpm bitmaps/exyellowblock2.xpm
  32. #   bitmaps/exyellowblock3.xpm bitmaps/greenblock.xpm bitmaps/life.xpm
  33. #   bitmaps/paddlemedium.xpm bitmaps/purpleblock.xpm
  34. #   bitmaps/redblock.xpm bitmaps/tanblock.xpm bitmaps/xtraball.xpm
  35. #   bitmaps/xtraball2.xpm bitmaps/yellowblock.xpm intro.h misc.h
  36. # Wrapped by chris@sparky on Fri Sep  3 07:14:58 1993
  37. PATH=/bin:/usr/bin:/usr/ucb:/usr/local/bin:/usr/lbin ; export PATH
  38. echo If this archive is complete, you will see the following message:
  39. echo '          "shar: End of archive 24 (of 26)."'
  40. if test -f 'audio/README.audio' -a "${1}" != "-c" ; then 
  41.   echo shar: Will not clobber existing file \"'audio/README.audio'\"
  42. else
  43.   echo shar: Extracting \"'audio/README.audio'\" \(987 characters\)
  44.   sed "s/^X//" >'audio/README.audio' <<'END_OF_FILE'
  45. XThese source files are used in the X11 game called xboing. These source files
  46. Xshould replace the audio.c in the main source tree. If you are using a machine
  47. Xthat supports sound and there is a sound player source file in this directory
  48. Xthen copy it to the main source tree and call it audio.c
  49. X
  50. XI have only tested the SUNaudio.c so I cannot verify the other code, however,
  51. Xseveral other people on the net have tested it on their machines. Thanks for
  52. Xall those people who have sent me code to play sound on their machine type.
  53. X
  54. XThe sound code will only play .au Sun audio format files or treat them as a
  55. Xbinary raw audio file - may click a bit on playing.
  56. X
  57. X      ___
  58. X     (o o)
  59. X+-oo0-\_/-0oo---------------------------------------------------------------+
  60. X|Justin Kibell - Systems Programmer - VICSES Rescuer - Chief Fire Warden ;-)|
  61. X|   email: jck@citri.edu.au   Phone: +61 3 282 2456  Fax: +61 3 282 2490    |
  62. X+---------------------------------------------------------------------------+
  63. END_OF_FILE
  64.   if test 987 -ne `wc -c <'audio/README.audio'`; then
  65.     echo shar: \"'audio/README.audio'\" unpacked with wrong size!
  66.   fi
  67.   # end of 'audio/README.audio'
  68. fi
  69. if test -f 'bitmaps/blueblock.xpm' -a "${1}" != "-c" ; then 
  70.   echo shar: Will not clobber existing file \"'bitmaps/blueblock.xpm'\"
  71. else
  72.   echo shar: Extracting \"'bitmaps/blueblock.xpm'\" \(997 characters\)
  73.   sed "s/^X//" >'bitmaps/blueblock.xpm' <<'END_OF_FILE'
  74. X/* XPM */
  75. Xstatic char * blueblock_xpm[] = {
  76. X"40 20 4 1",
  77. X"     c None",
  78. X".    c #49499898FFFF",
  79. X"X    c blue1",
  80. X"o    c blue3",
  81. X"  ....................................  ",
  82. X" ...................................... ",
  83. X"...XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX.oo",
  84. X"..XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXoo",
  85. X"..XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXoo",
  86. X"..XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXoo",
  87. X"..XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXoo",
  88. X"..XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXoo",
  89. X"..XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXoo",
  90. X"..XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXoo",
  91. X"..XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXoo",
  92. X"..XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXoo",
  93. X"..XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXoo",
  94. X"..XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXoo",
  95. X"..XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXoo",
  96. X"..XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXoo",
  97. X"..XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXoo",
  98. X"..oXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXooo",
  99. X" oooooooooooooooooooooooooooooooooooooo ",
  100. X"  oooooooooooooooooooooooooooooooooooo  "};
  101. END_OF_FILE
  102.   if test 997 -ne `wc -c <'bitmaps/blueblock.xpm'`; then
  103.     echo shar: \"'bitmaps/blueblock.xpm'\" unpacked with wrong size!
  104.   fi
  105.   # end of 'bitmaps/blueblock.xpm'
  106. fi
  107. if test -f 'bitmaps/bullet.xpm' -a "${1}" != "-c" ; then 
  108.   echo shar: Will not clobber existing file \"'bitmaps/bullet.xpm'\"
  109. else
  110.   echo shar: Extracting \"'bitmaps/bullet.xpm'\" \(367 characters\)
  111.   sed "s/^X//" >'bitmaps/bullet.xpm' <<'END_OF_FILE'
  112. X/* XPM */
  113. Xstatic char * bullet_xpm[] = {
  114. X"7 16 8 1",
  115. X"     s None    c None",
  116. X".    c black",
  117. X"X    c #C6C6D5D5E2E2",
  118. X"o    c gray80",
  119. X"O    c #8B8B9999B5B5",
  120. X"+    c gray40",
  121. X"@    c #B7B7B7B7B7B7",
  122. X"#    c gray50",
  123. X"   .   ",
  124. X"  .X.  ",
  125. X" .XoO. ",
  126. X".XoOO+.",
  127. X".......",
  128. X".Xo@#+.",
  129. X".Xo@#+.",
  130. X".Xo@#+.",
  131. X".Xo@#+.",
  132. X".Xo@#+.",
  133. X".Xo@#+.",
  134. X".Xo@#+.",
  135. X".Xo@#+.",
  136. X".Xo@#+.",
  137. X".......",
  138. X" ..... "};
  139. END_OF_FILE
  140.   if test 367 -ne `wc -c <'bitmaps/bullet.xpm'`; then
  141.     echo shar: \"'bitmaps/bullet.xpm'\" unpacked with wrong size!
  142.   fi
  143.   # end of 'bitmaps/bullet.xpm'
  144. fi
  145. if test -f 'bitmaps/counterblock.xpm' -a "${1}" != "-c" ; then 
  146.   echo shar: Will not clobber existing file \"'bitmaps/counterblock.xpm'\"
  147. else
  148.   echo shar: Extracting \"'bitmaps/counterblock.xpm'\" \(998 characters\)
  149.   sed "s/^X//" >'bitmaps/counterblock.xpm' <<'END_OF_FILE'
  150. X/* XPM */
  151. Xstatic char * counterblock_xpm[] = {
  152. X"40 20 4 1",
  153. X"     s None    c None",
  154. X".    c pink",
  155. X"X    c pink2",
  156. X"o    c pink3",
  157. X"  ....................................  ",
  158. X" ...................................... ",
  159. X"...XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXooo",
  160. X"..XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXoo",
  161. X"..XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXoo",
  162. X"..XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXoo",
  163. X"..XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXoo",
  164. X"..XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXoo",
  165. X"..XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXoo",
  166. X"..XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXoo",
  167. X"..XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXoo",
  168. X"..XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXoo",
  169. X"..XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXoo",
  170. X"..XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXoo",
  171. X"..XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXoo",
  172. X"..XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXoo",
  173. X"..XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXoo",
  174. X"..oXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXooo",
  175. X" .ooooooooooooooooooooooooooooooooooooo ",
  176. X"  oooooooooooooooooooooooooooooooooooo  "};
  177. END_OF_FILE
  178.   if test 998 -ne `wc -c <'bitmaps/counterblock.xpm'`; then
  179.     echo shar: \"'bitmaps/counterblock.xpm'\" unpacked with wrong size!
  180.   fi
  181.   # end of 'bitmaps/counterblock.xpm'
  182. fi
  183. if test -f 'bitmaps/counterblock1.xpm' -a "${1}" != "-c" ; then 
  184.   echo shar: Will not clobber existing file \"'bitmaps/counterblock1.xpm'\"
  185. else
  186.   echo shar: Extracting \"'bitmaps/counterblock1.xpm'\" \(1012 characters\)
  187.   sed "s/^X//" >'bitmaps/counterblock1.xpm' <<'END_OF_FILE'
  188. X/* XPM */
  189. Xstatic char * counterblock1_xpm[] = {
  190. X"40 20 5 1",
  191. X"     s None    c None",
  192. X".    c pink",
  193. X"X    c pink2",
  194. X"o    c pink3",
  195. X"O    c pink4",
  196. X"  ....................................  ",
  197. X" ...................................... ",
  198. X"...XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXooo",
  199. X"..XXXXXXXXXXXXXXXXXOOOXXXXXXXXXXXXXXXXoo",
  200. X"..XXXXXXXXXXXXXXXXOOOOXXXXXXXXXXXXXXXXoo",
  201. X"..XXXXXXXXXXXXXXOOOOOOXXXXXXXXXXXXXXXXoo",
  202. X"..XXXXXXXXXXXXXXOOOOOOXXXXXXXXXXXXXXXXoo",
  203. X"..XXXXXXXXXXXXXXXXXOOOXXXXXXXXXXXXXXXXoo",
  204. X"..XXXXXXXXXXXXXXXXXOOOXXXXXXXXXXXXXXXXoo",
  205. X"..XXXXXXXXXXXXXXXXXOOOXXXXXXXXXXXXXXXXoo",
  206. X"..XXXXXXXXXXXXXXXXXOOOXXXXXXXXXXXXXXXXoo",
  207. X"..XXXXXXXXXXXXXXXXXOOOXXXXXXXXXXXXXXXXoo",
  208. X"..XXXXXXXXXXXXXXXXXOOOXXXXXXXXXXXXXXXXoo",
  209. X"..XXXXXXXXXXXXXXXXXOOOXXXXXXXXXXXXXXXXoo",
  210. X"..XXXXXXXXXXXXXXXXXOOOXXXXXXXXXXXXXXXXoo",
  211. X"..XXXXXXXXXXXXXXXXXOOOXXXXXXXXXXXXXXXXoo",
  212. X"..XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXoo",
  213. X"..oXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXooo",
  214. X" .ooooooooooooooooooooooooooooooooooooo ",
  215. X"  oooooooooooooooooooooooooooooooooooo  "};
  216. END_OF_FILE
  217.   if test 1012 -ne `wc -c <'bitmaps/counterblock1.xpm'`; then
  218.     echo shar: \"'bitmaps/counterblock1.xpm'\" unpacked with wrong size!
  219.   fi
  220.   # end of 'bitmaps/counterblock1.xpm'
  221. fi
  222. if test -f 'bitmaps/counterblock3.xpm' -a "${1}" != "-c" ; then 
  223.   echo shar: Will not clobber existing file \"'bitmaps/counterblock3.xpm'\"
  224. else
  225.   echo shar: Extracting \"'bitmaps/counterblock3.xpm'\" \(1012 characters\)
  226.   sed "s/^X//" >'bitmaps/counterblock3.xpm' <<'END_OF_FILE'
  227. X/* XPM */
  228. Xstatic char * counterblock3_xpm[] = {
  229. X"40 20 5 1",
  230. X"     s None    c None",
  231. X".    c pink",
  232. X"X    c pink2",
  233. X"o    c pink3",
  234. X"O    c pink4",
  235. X"  ....................................  ",
  236. X" ...................................... ",
  237. X"...XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXooo",
  238. X"..XXXXXXXXXXXXXXXXOOOOOXXXXXXXXXXXXXXXoo",
  239. X"..XXXXXXXXXXXXXXXOOOOOOOXXXXXXXXXXXXXXoo",
  240. X"..XXXXXXXXXXXXXXOOOXXOOOXXXXXXXXXXXXXXoo",
  241. X"..XXXXXXXXXXXXXXOOOXXXOOXXXXXXXXXXXXXXoo",
  242. X"..XXXXXXXXXXXXXXXXXXXOOOXXXXXXXXXXXXXXoo",
  243. X"..XXXXXXXXXXXXXXXXXOOOOXXXXXXXXXXXXXXXoo",
  244. X"..XXXXXXXXXXXXXXXXXOOOOOXXXXXXXXXXXXXXoo",
  245. X"..XXXXXXXXXXXXXXXXXXXOOOOXXXXXXXXXXXXXoo",
  246. X"..XXXXXXXXXXXXXXXXXXXXOOOXXXXXXXXXXXXXoo",
  247. X"..XXXXXXXXXXXXXXOOOXXXOOOXXXXXXXXXXXXXoo",
  248. X"..XXXXXXXXXXXXXXOOOXXOOOOXXXXXXXXXXXXXoo",
  249. X"..XXXXXXXXXXXXXXXOOOOOOOXXXXXXXXXXXXXXoo",
  250. X"..XXXXXXXXXXXXXXXXOOOOOXXXXXXXXXXXXXXXoo",
  251. X"..XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXoo",
  252. X"..oXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXooo",
  253. X" .ooooooooooooooooooooooooooooooooooooo ",
  254. X"  oooooooooooooooooooooooooooooooooooo  "};
  255. END_OF_FILE
  256.   if test 1012 -ne `wc -c <'bitmaps/counterblock3.xpm'`; then
  257.     echo shar: \"'bitmaps/counterblock3.xpm'\" unpacked with wrong size!
  258.   fi
  259.   # end of 'bitmaps/counterblock3.xpm'
  260. fi
  261. if test -f 'bitmaps/exblueblock1.xpm' -a "${1}" != "-c" ; then 
  262.   echo shar: Will not clobber existing file \"'bitmaps/exblueblock1.xpm'\"
  263. else
  264.   echo shar: Extracting \"'bitmaps/exblueblock1.xpm'\" \(1005 characters\)
  265.   sed "s/^X//" >'bitmaps/exblueblock1.xpm' <<'END_OF_FILE'
  266. X/* XPM */
  267. Xstatic char * exblueblock1_xpm[] = {
  268. X"40 20 4 1",
  269. X"     c None",
  270. X".    c #49499898FFFF",
  271. X"X    c blue",
  272. X"o    c medium blue",
  273. X"    ......  ....  ....  ...  ....  ...  ",
  274. X"  .....   ....  ....  ...  ....  ...  . ",
  275. X"...XX  XXXX   XXXX  XXX  XXXX  XXX  X.o ",
  276. X"..   XXXX  XXXX   XXX  XXXX  XXX  XXX  o",
  277. X"  XXXXX  XXXX  XXXX  XXXX  XXX  XXX  Xoo",
  278. X"..XX   XXXX  XXXX  XXXX  XXX  XXX  XXX  ",
  279. X"..  XXXXX  XXXX  XXXX  XXX  XXX  XXX  oo",
  280. X"  XXXX   XXX   XXXX  XXX  XXX  XXX  XXoo",
  281. X"..XX  XXXX  XXXX   XXX  XXX  XXX  XXXX  ",
  282. X"..  XXXX  XXXX  XXXX  XXX  XXX  XXXX  oo",
  283. X"  XXXX  XXXX  XXXX  XXX  XXX  XXXX  XXoo",
  284. X"..XX  XXXX  XXXX  XXX  XXX  XXXX  XXXX  ",
  285. X"..  XXXX  XXXX  XXX  XXX  XXXX  XXXX  oo",
  286. X"  XXXX  XXXX  XXX  XXX  XXXX  XXXX  XXoo",
  287. X"..XX  XXXX  XXX  XXX  XXXX  XXXX  XXXX  ",
  288. X"..  XXXX  XXX  XXX  XXXX  XXX   XXXX  oo",
  289. X"  XXXX  XXX  XXX  XXXX  XXX  XXXXX  XXoo",
  290. X"..oX  XXX  XXX  XXXX  XXX  XXXX   XXXo  ",
  291. X" o  ooo  ooo  oooo  ooo  oooo  oooo   o ",
  292. X"  oooo ooo  oooo  ooo  oooo  oooo  ooo  "};
  293. END_OF_FILE
  294.   if test 1005 -ne `wc -c <'bitmaps/exblueblock1.xpm'`; then
  295.     echo shar: \"'bitmaps/exblueblock1.xpm'\" unpacked with wrong size!
  296.   fi
  297.   # end of 'bitmaps/exblueblock1.xpm'
  298. fi
  299. if test -f 'bitmaps/exblueblock2.xpm' -a "${1}" != "-c" ; then 
  300.   echo shar: Will not clobber existing file \"'bitmaps/exblueblock2.xpm'\"
  301. else
  302.   echo shar: Extracting \"'bitmaps/exblueblock2.xpm'\" \(1005 characters\)
  303.   sed "s/^X//" >'bitmaps/exblueblock2.xpm' <<'END_OF_FILE'
  304. X/* XPM */
  305. Xstatic char * exblueblock2_xpm[] = {
  306. X"40 20 4 1",
  307. X"     c None",
  308. X".    c #49499898FFFF",
  309. X"X    c blue",
  310. X"o    c medium blue",
  311. X"    ....    ..    ..    .    ..    ..   ",
  312. X"  ...     ..    ..    .    ..    ..   . ",
  313. X"..     XX     XX    X    XX    XX   X   ",
  314. X"     XX    XX     X    XX    XX   X    o",
  315. X"  XX     XX    XX    XX    XX   X    Xo ",
  316. X"..     XX    XX    XX    XX   X    XX   ",
  317. X"    XX     X     XX    XX   X    XX   oo",
  318. X"  XX     X     XX    XX   X    XX   XXo ",
  319. X"..    XX    XX     XX   X    XX   XXX   ",
  320. X"    XX    XX    XXX   X    XX   XXX   oo",
  321. X"  XX    XX    XXX   XX   XX   XXX   XX  ",
  322. X"..    XX    XXX   XX   XX   XXX   XX    ",
  323. X"    XX    XXX   XX   XX   XXX   XX    oo",
  324. X"  XX    XXX   XX   XX   XXX   XX    XX  ",
  325. X"..    XXX   XX   XX   XXX   XX    XX    ",
  326. X"    XXX   XX   XX   XXX   XX    XX    oo",
  327. X"  XXX   XX   XX   XXX   XX   XXX    XX  ",
  328. X"..o   XX   XX   XXX   XX   XXX    XX    ",
  329. X"    oo   oo   ooo   oo   ooo   ooo    o ",
  330. X"  ooo  oo   ooo   oo   ooo   ooo   oo   "};
  331. END_OF_FILE
  332.   if test 1005 -ne `wc -c <'bitmaps/exblueblock2.xpm'`; then
  333.     echo shar: \"'bitmaps/exblueblock2.xpm'\" unpacked with wrong size!
  334.   fi
  335.   # end of 'bitmaps/exblueblock2.xpm'
  336. fi
  337. if test -f 'bitmaps/exblueblock3.xpm' -a "${1}" != "-c" ; then 
  338.   echo shar: Will not clobber existing file \"'bitmaps/exblueblock3.xpm'\"
  339. else
  340.   echo shar: Extracting \"'bitmaps/exblueblock3.xpm'\" \(1005 characters\)
  341.   sed "s/^X//" >'bitmaps/exblueblock3.xpm' <<'END_OF_FILE'
  342. X/* XPM */
  343. Xstatic char * exblueblock3_xpm[] = {
  344. X"40 20 4 1",
  345. X"     c None",
  346. X".    c #49499898FFFF",
  347. X"X    c blue",
  348. X"o    c medium blue",
  349. X"    .  .           .    .     .         ",
  350. X"  .                        .          . ",
  351. X".                        XX         X   ",
  352. X"           X            X         X    o",
  353. X"  X      X     XX    X          X    X  ",
  354. X".            XX    XX         X         ",
  355. X"    X      X     XX                   o ",
  356. X"  X      X     XX                   X   ",
  357. X".     XX    XX                    X     ",
  358. X"     X    XX      X             X     o ",
  359. X"  XX     X      X             X     X   ",
  360. X"..     X      X             X     X     ",
  361. X"            X             X     X     o ",
  362. X"  X       X   X         X     X     X   ",
  363. X"..          X               X     X     ",
  364. X"      X   X               X     X      o",
  365. X"    X   X               X    XX      X  ",
  366. X"  o                   X    XX     X     ",
  367. X"    o               o    oo    o      o ",
  368. X"  oo   o    o     o    oo    oo    oo   "};
  369. END_OF_FILE
  370.   if test 1005 -ne `wc -c <'bitmaps/exblueblock3.xpm'`; then
  371.     echo shar: \"'bitmaps/exblueblock3.xpm'\" unpacked with wrong size!
  372.   fi
  373.   # end of 'bitmaps/exblueblock3.xpm'
  374. fi
  375. if test -f 'bitmaps/exgreenblock1.xpm' -a "${1}" != "-c" ; then 
  376.   echo shar: Will not clobber existing file \"'bitmaps/exgreenblock1.xpm'\"
  377. else
  378.   echo shar: Extracting \"'bitmaps/exgreenblock1.xpm'\" \(1007 characters\)
  379.   sed "s/^X//" >'bitmaps/exgreenblock1.xpm' <<'END_OF_FILE'
  380. X/* XPM */
  381. Xstatic char * exgreenblock1_xpm[] = {
  382. X"40 20 4 1",
  383. X"     c None",
  384. X".    c #9292FFFFAAAA",
  385. X"X    c green",
  386. X"o    c aquamarine4",
  387. X"  . ... ... ... ... ... ... ... ... ..  ",
  388. X" .. ... ... ... ... ... ... ... ... ... ",
  389. X"... XXX XXX XXX XXX XXX XXX XXX XXX Xoo ",
  390. X"..X XXX XXX XXX XXX XXX XXX XXX XXX XXo ",
  391. X"..X XXX XXX XXX XXX XXX XXX XXX XXX XXo ",
  392. X"..X XXX XXX XXX XXX XXX XXX XXX XXX XXo ",
  393. X"..X XXX XXX XXX XXX XXX XXX XXX XXX XXo ",
  394. X"..X XXX XXX XXX XXX XXX XXX XXX XXX XXo ",
  395. X"..X XXX XXX XXX XXX XXX XXX XXX XXX XXo ",
  396. X"..X XXX XXX XXX XXX XXX XXX XXX XXX XXo ",
  397. X"..X XXX XXX XXX XXX XXX XXX XXX XXX XXo ",
  398. X"..X XXX XXX XXX XXX XXX XXX XXX XXX XXo ",
  399. X"..X XXX XXX XXX XXX XXX XXX XXX XXX XXo ",
  400. X"..X XXX XXX XXX XXX XXX XXX XXX XXX XXo ",
  401. X"..X XXX XXX XXX XXX XXX XXX XXX XXX XXo ",
  402. X"..X XXX XXX XXX XXX XXX XXX XXX XXX XXo ",
  403. X"..X XXX XXX XXX XXX XXX XXX XXX XXX XXo ",
  404. X"..o XXX XXX XXX XXX XXX XXX XXX XXX Xoo ",
  405. X" oo ooo ooo ooo ooo ooo ooo ooo ooo ooo ",
  406. X"  o ooo ooo ooo ooo ooo ooo ooo ooo oo  "};
  407. END_OF_FILE
  408.   if test 1007 -ne `wc -c <'bitmaps/exgreenblock1.xpm'`; then
  409.     echo shar: \"'bitmaps/exgreenblock1.xpm'\" unpacked with wrong size!
  410.   fi
  411.   # end of 'bitmaps/exgreenblock1.xpm'
  412. fi
  413. if test -f 'bitmaps/exgreenblock2.xpm' -a "${1}" != "-c" ; then 
  414.   echo shar: Will not clobber existing file \"'bitmaps/exgreenblock2.xpm'\"
  415. else
  416.   echo shar: Extracting \"'bitmaps/exgreenblock2.xpm'\" \(1007 characters\)
  417.   sed "s/^X//" >'bitmaps/exgreenblock2.xpm' <<'END_OF_FILE'
  418. X/* XPM */
  419. Xstatic char * exgreenblock2_xpm[] = {
  420. X"40 20 4 1",
  421. X"     c None",
  422. X".    c #9292FFFFAAAA",
  423. X"X    c green",
  424. X"o    c aquamarine4",
  425. X"    ..  ..  ..  ..  ..  ..  ..  ..  ..  ",
  426. X" .  ..  ..  ..  ..  ..  ..  ..  ..  ..  ",
  427. X"..  XX  XX  XX  XX  XX  XX  XX  XX  Xo  ",
  428. X"..  XX  XX  XX  XX  XX  XX  XX  XX  XX  ",
  429. X"..  XX  XX  XX  XX  XX  XX  XX  XX  XX  ",
  430. X"..  XX  XX  XX  XX  XX  XX  XX  XX  XX  ",
  431. X"..  XX  XX  XX  XX  XX  XX  XX  XX  XX  ",
  432. X"..  XX  XX  XX  XX  XX  XX  XX  XX  XX  ",
  433. X"..  XX  XX  XX  XX  XX  XX  XX  XX  XX  ",
  434. X"..  XX  XX  XX  XX  XX  XX  XX  XX  XX  ",
  435. X"..  XX  XX  XX  XX  XX  XX  XX  XX  XX  ",
  436. X"..  XX  XX  XX  XX  XX  XX  XX  XX  XX  ",
  437. X"..  XX  XX  XX  XX  XX  XX  XX  XX  XX  ",
  438. X"..  XX  XX  XX  XX  XX  XX  XX  XX  XX  ",
  439. X"..  XX  XX  XX  XX  XX  XX  XX  XX  XX  ",
  440. X"..  XX  XX  XX  XX  XX  XX  XX  XX  XX  ",
  441. X"..  XX  XX  XX  XX  XX  XX  XX  XX  XX  ",
  442. X"..  XX  XX  XX  XX  XX  XX  XX  XX  Xo  ",
  443. X" o  oo  oo  oo  oo  oo  oo  oo  oo  oo  ",
  444. X"    oo  oo  oo  oo  oo  oo  oo  oo  oo  "};
  445. END_OF_FILE
  446.   if test 1007 -ne `wc -c <'bitmaps/exgreenblock2.xpm'`; then
  447.     echo shar: \"'bitmaps/exgreenblock2.xpm'\" unpacked with wrong size!
  448.   fi
  449.   # end of 'bitmaps/exgreenblock2.xpm'
  450. fi
  451. if test -f 'bitmaps/exgreenblock3.xpm' -a "${1}" != "-c" ; then 
  452.   echo shar: Will not clobber existing file \"'bitmaps/exgreenblock3.xpm'\"
  453. else
  454.   echo shar: Extracting \"'bitmaps/exgreenblock3.xpm'\" \(1007 characters\)
  455.   sed "s/^X//" >'bitmaps/exgreenblock3.xpm' <<'END_OF_FILE'
  456. X/* XPM */
  457. Xstatic char * exgreenblock3_xpm[] = {
  458. X"40 20 4 1",
  459. X"     c None",
  460. X".    c #9292FFFFAAAA",
  461. X"X    c green",
  462. X"o    c aquamarine4",
  463. X"    .   .   .   .   .   .   .   .   .   ",
  464. X"    .   .   .   .   .   .   .   .   .   ",
  465. X".   X   X   X   X   X   X   X   X   X   ",
  466. X".   X   X   X   X   X   X   X   X   X   ",
  467. X".   X   X   X   X   X   X   X   X   X   ",
  468. X".   X   X   X   X   X   X   X   X   X   ",
  469. X".   X   X   X   X   X   X   X   X   X   ",
  470. X".   X   X   X   X   X   X   X   X   X   ",
  471. X".   X   X   X   X   X   X   X   X   X   ",
  472. X".   X   X   X   X   X   X   X   X   X   ",
  473. X".   X   X   X   X   X   X   X   X   X   ",
  474. X".   X   X   X   X   X   X   X   X   X   ",
  475. X".   X   X   X   X   X   X   X   X   X   ",
  476. X".   X   X   X   X   X   X   X   X   X   ",
  477. X".   X   X   X   X   X   X   X   X   X   ",
  478. X".   X   X   X   X   X   X   X   X   X   ",
  479. X".   X   X   X   X   X   X   X   X   X   ",
  480. X".   X   X   X   X   X   X   X   X   X   ",
  481. X"    o   o   o   o   o   o   o   o   o   ",
  482. X"    o   o   o   o   o   o   o   o   o   "};
  483. END_OF_FILE
  484.   if test 1007 -ne `wc -c <'bitmaps/exgreenblock3.xpm'`; then
  485.     echo shar: \"'bitmaps/exgreenblock3.xpm'\" unpacked with wrong size!
  486.   fi
  487.   # end of 'bitmaps/exgreenblock3.xpm'
  488. fi
  489. if test -f 'bitmaps/expurpleblock1.xpm' -a "${1}" != "-c" ; then 
  490.   echo shar: Will not clobber existing file \"'bitmaps/expurpleblock1.xpm'\"
  491. else
  492.   echo shar: Extracting \"'bitmaps/expurpleblock1.xpm'\" \(999 characters\)
  493.   sed "s/^X//" >'bitmaps/expurpleblock1.xpm' <<'END_OF_FILE'
  494. X/* XPM */
  495. Xstatic char * expurpleblock1_xpm[] = {
  496. X"40 20 4 1",
  497. X"     c None",
  498. X".    c purple1",
  499. X"X    c purple",
  500. X"o    c purple4",
  501. X"  .............        ...............  ",
  502. X" ..............        ................ ",
  503. X"...XXXXXXXXXXXX        XXXXXXXXXXXXXX.oo",
  504. X"..XXXXXXXXXXXXX        XXXXXXXXXXXXXXXoo",
  505. X"..XXXXXXXXXXXXX        XXXXXXXXXXXXXXXoo",
  506. X"..XXXXXXXXXXXXX        XXXXXXXXXXXXXXXoo",
  507. X"..XXXXXXXXXXXXX        XXXXXXXXXXXXXXXoo",
  508. X"..XXXXXXXXXXXXX        XXXXXXXXXXXXXXXoo",
  509. X"..XXXXXXXXXXXXX        XXXXXXXXXXXXXXXoo",
  510. X"..XXXXXXXXXXXXX        XXXXXXXXXXXXXXXoo",
  511. X"..XXXXXXXXXXXXX        XXXXXXXXXXXXXXXoo",
  512. X"..XXXXXXXXXXXXX        XXXXXXXXXXXXXXXoo",
  513. X"..XXXXXXXXXXXXX        XXXXXXXXXXXXXXXoo",
  514. X"..XXXXXXXXXXXXX        XXXXXXXXXXXXXXXoo",
  515. X"..XXXXXXXXXXXXX        XXXXXXXXXXXXXXXoo",
  516. X"..XXXXXXXXXXXXX        XXXXXXXXXXXXXXXoo",
  517. X"..XXXXXXXXXXXXX        XXXXXXXXXXXXXXXoo",
  518. X"..oXXXXXXXXXXXX        XXXXXXXXXXXXXXooo",
  519. X" oooooooooooooo        oooooooooooooooo ",
  520. X"  ooooooooooooo        ooooooooooooooo  "};
  521. END_OF_FILE
  522.   if test 999 -ne `wc -c <'bitmaps/expurpleblock1.xpm'`; then
  523.     echo shar: \"'bitmaps/expurpleblock1.xpm'\" unpacked with wrong size!
  524.   fi
  525.   # end of 'bitmaps/expurpleblock1.xpm'
  526. fi
  527. if test -f 'bitmaps/expurpleblock2.xpm' -a "${1}" != "-c" ; then 
  528.   echo shar: Will not clobber existing file \"'bitmaps/expurpleblock2.xpm'\"
  529. else
  530.   echo shar: Extracting \"'bitmaps/expurpleblock2.xpm'\" \(999 characters\)
  531.   sed "s/^X//" >'bitmaps/expurpleblock2.xpm' <<'END_OF_FILE'
  532. X/* XPM */
  533. Xstatic char * expurpleblock2_xpm[] = {
  534. X"40 20 4 1",
  535. X"     c None",
  536. X".    c purple1",
  537. X"X    c purple",
  538. X"o    c purple4",
  539. X"  ......                       .......  ",
  540. X" .......                       ........ ",
  541. X"...XXXXX                       XXXXXX.oo",
  542. X"..XXXXXX                       XXXXXXXoo",
  543. X"..XXXXXX                       XXXXXXXoo",
  544. X"..XXXXXX                       XXXXXXXoo",
  545. X"..XXXXXX                       XXXXXXXoo",
  546. X"..XXXXXX                       XXXXXXXoo",
  547. X"..XXXXXX                       XXXXXXXoo",
  548. X"..XXXXXX                       XXXXXXXoo",
  549. X"..XXXXXX                       XXXXXXXoo",
  550. X"..XXXXXX                       XXXXXXXoo",
  551. X"..XXXXXX                       XXXXXXXoo",
  552. X"..XXXXXX                       XXXXXXXoo",
  553. X"..XXXXXX                       XXXXXXXoo",
  554. X"..XXXXXX                       XXXXXXXoo",
  555. X"..XXXXXX                       XXXXXXXoo",
  556. X"..oXXXXX                       XXXXXXooo",
  557. X" ooooooo                       oooooooo ",
  558. X"  oooooo                       ooooooo  "};
  559. END_OF_FILE
  560.   if test 999 -ne `wc -c <'bitmaps/expurpleblock2.xpm'`; then
  561.     echo shar: \"'bitmaps/expurpleblock2.xpm'\" unpacked with wrong size!
  562.   fi
  563.   # end of 'bitmaps/expurpleblock2.xpm'
  564. fi
  565. if test -f 'bitmaps/expurpleblock3.xpm' -a "${1}" != "-c" ; then 
  566.   echo shar: Will not clobber existing file \"'bitmaps/expurpleblock3.xpm'\"
  567. else
  568.   echo shar: Extracting \"'bitmaps/expurpleblock3.xpm'\" \(999 characters\)
  569.   sed "s/^X//" >'bitmaps/expurpleblock3.xpm' <<'END_OF_FILE'
  570. X/* XPM */
  571. Xstatic char * expurpleblock3_xpm[] = {
  572. X"40 20 4 1",
  573. X"     c None",
  574. X".    c purple1",
  575. X"X    c purple4",
  576. X"o    c purple",
  577. X"  .                                  .  ",
  578. X" ..                                  .. ",
  579. X"...                                  .XX",
  580. X"..o                                  oXX",
  581. X"..o                                  oXX",
  582. X"..o                                  oXX",
  583. X"..o                                  oXX",
  584. X"..o                                  oXX",
  585. X"..o                                  oXX",
  586. X"..o                                  oXX",
  587. X"..o                                  oXX",
  588. X"..o                                  oXX",
  589. X"..o                                  oXX",
  590. X"..o                                  oXX",
  591. X"..o                                  oXX",
  592. X"..o                                  oXX",
  593. X"..o                                  oXX",
  594. X"..X                                  XXX",
  595. X" XX                                  XX ",
  596. X"  X                                  X  "};
  597. END_OF_FILE
  598.   if test 999 -ne `wc -c <'bitmaps/expurpleblock3.xpm'`; then
  599.     echo shar: \"'bitmaps/expurpleblock3.xpm'\" unpacked with wrong size!
  600.   fi
  601.   # end of 'bitmaps/expurpleblock3.xpm'
  602. fi
  603. if test -f 'bitmaps/exredblock1.xpm' -a "${1}" != "-c" ; then 
  604.   echo shar: Will not clobber existing file \"'bitmaps/exredblock1.xpm'\"
  605. else
  606.   echo shar: Extracting \"'bitmaps/exredblock1.xpm'\" \(988 characters\)
  607.   sed "s/^X//" >'bitmaps/exredblock1.xpm' <<'END_OF_FILE'
  608. X/* XPM */
  609. Xstatic char * exredblock1_xpm[] = {
  610. X"40 20 4 1",
  611. X"     c None",
  612. X".    c red1",
  613. X"X    c red4",
  614. X"o    c red3",
  615. X"                                        ",
  616. X"                                        ",
  617. X"                                        ",
  618. X"    ................................    ",
  619. X"   ................................XX   ",
  620. X"   ..ooooooooooooooooooooooooooooooXX   ",
  621. X"   ..ooooooooooooooooooooooooooooooXX   ",
  622. X"   ..ooooooooooooooooooooooooooooooXX   ",
  623. X"   ..ooooooooooooooooooooooooooooooXX   ",
  624. X"   ..ooooooooooooooooooooooooooooooXX   ",
  625. X"   ..ooooooooooooooooooooooooooooooXX   ",
  626. X"   ..ooooooooooooooooooooooooooooooXX   ",
  627. X"   ..ooooooooooooooooooooooooooooooXX   ",
  628. X"   ..ooooooooooooooooooooooooooooooXX   ",
  629. X"   ..ooooooooooooooooooooooooooooooXX   ",
  630. X"   .XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX   ",
  631. X"    XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX    ",
  632. X"                                        ",
  633. X"                                        ",
  634. X"                                        "};
  635. END_OF_FILE
  636.   if test 988 -ne `wc -c <'bitmaps/exredblock1.xpm'`; then
  637.     echo shar: \"'bitmaps/exredblock1.xpm'\" unpacked with wrong size!
  638.   fi
  639.   # end of 'bitmaps/exredblock1.xpm'
  640. fi
  641. if test -f 'bitmaps/exredblock2.xpm' -a "${1}" != "-c" ; then 
  642.   echo shar: Will not clobber existing file \"'bitmaps/exredblock2.xpm'\"
  643. else
  644.   echo shar: Extracting \"'bitmaps/exredblock2.xpm'\" \(988 characters\)
  645.   sed "s/^X//" >'bitmaps/exredblock2.xpm' <<'END_OF_FILE'
  646. X/* XPM */
  647. Xstatic char * exredblock2_xpm[] = {
  648. X"40 20 4 1",
  649. X"     c None",
  650. X".    c red1",
  651. X"X    c red4",
  652. X"o    c red3",
  653. X"                                        ",
  654. X"                                        ",
  655. X"                                        ",
  656. X"                                        ",
  657. X"                                        ",
  658. X"                                        ",
  659. X"                                        ",
  660. X"        ........................        ",
  661. X"       .........................X       ",
  662. X"       ..ooooooooooooooooooooooXX       ",
  663. X"       ..ooooooooooooooooooooooXX       ",
  664. X"       .XXXXXXXXXXXXXXXXXXXXXXXXX       ",
  665. X"        XXXXXXXXXXXXXXXXXXXXXXXX        ",
  666. X"                                        ",
  667. X"                                        ",
  668. X"                                        ",
  669. X"                                        ",
  670. X"                                        ",
  671. X"                                        ",
  672. X"                                        "};
  673. END_OF_FILE
  674.   if test 988 -ne `wc -c <'bitmaps/exredblock2.xpm'`; then
  675.     echo shar: \"'bitmaps/exredblock2.xpm'\" unpacked with wrong size!
  676.   fi
  677.   # end of 'bitmaps/exredblock2.xpm'
  678. fi
  679. if test -f 'bitmaps/exredblock3.xpm' -a "${1}" != "-c" ; then 
  680.   echo shar: Will not clobber existing file \"'bitmaps/exredblock3.xpm'\"
  681. else
  682.   echo shar: Extracting \"'bitmaps/exredblock3.xpm'\" \(988 characters\)
  683.   sed "s/^X//" >'bitmaps/exredblock3.xpm' <<'END_OF_FILE'
  684. X/* XPM */
  685. Xstatic char * exredblock3_xpm[] = {
  686. X"40 20 4 1",
  687. X"     c None",
  688. X".    c red1",
  689. X"X    c red3",
  690. X"o    c red4",
  691. X"                                        ",
  692. X"                                        ",
  693. X"                                        ",
  694. X"                                        ",
  695. X"                                        ",
  696. X"                                        ",
  697. X"                                        ",
  698. X"                                        ",
  699. X"                ........                ",
  700. X"               .XXXXXXXXo               ",
  701. X"               .XXXXXXXXo               ",
  702. X"                oooooooo                ",
  703. X"                                        ",
  704. X"                                        ",
  705. X"                                        ",
  706. X"                                        ",
  707. X"                                        ",
  708. X"                                        ",
  709. X"                                        ",
  710. X"                                        "};
  711. END_OF_FILE
  712.   if test 988 -ne `wc -c <'bitmaps/exredblock3.xpm'`; then
  713.     echo shar: \"'bitmaps/exredblock3.xpm'\" unpacked with wrong size!
  714.   fi
  715.   # end of 'bitmaps/exredblock3.xpm'
  716. fi
  717. if test -f 'bitmaps/extanblock1.xpm' -a "${1}" != "-c" ; then 
  718.   echo shar: Will not clobber existing file \"'bitmaps/extanblock1.xpm'\"
  719. else
  720.   echo shar: Extracting \"'bitmaps/extanblock1.xpm'\" \(987 characters\)
  721.   sed "s/^X//" >'bitmaps/extanblock1.xpm' <<'END_OF_FILE'
  722. X/* XPM */
  723. Xstatic char * extanblock1_xpm[] = {
  724. X"40 20 4 1",
  725. X"     c None",
  726. X".    c tan",
  727. X"X    c tan2",
  728. X"o    c tan4",
  729. X"  ....................................  ",
  730. X" ...................................... ",
  731. X"...XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXooo",
  732. X"                                        ",
  733. X"..XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXoo",
  734. X"..XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXoo",
  735. X"..XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXoo",
  736. X"                                        ",
  737. X"..XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXoo",
  738. X"..XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXoo",
  739. X"..XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXoo",
  740. X"                                        ",
  741. X"..XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXoo",
  742. X"..XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXoo",
  743. X"..XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXoo",
  744. X"                                        ",
  745. X"..XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXoo",
  746. X"..oXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXooo",
  747. X" .ooooooooooooooooooooooooooooooooooooo ",
  748. X"                                        "};
  749. END_OF_FILE
  750.   if test 987 -ne `wc -c <'bitmaps/extanblock1.xpm'`; then
  751.     echo shar: \"'bitmaps/extanblock1.xpm'\" unpacked with wrong size!
  752.   fi
  753.   # end of 'bitmaps/extanblock1.xpm'
  754. fi
  755. if test -f 'bitmaps/extanblock2.xpm' -a "${1}" != "-c" ; then 
  756.   echo shar: Will not clobber existing file \"'bitmaps/extanblock2.xpm'\"
  757. else
  758.   echo shar: Extracting \"'bitmaps/extanblock2.xpm'\" \(987 characters\)
  759.   sed "s/^X//" >'bitmaps/extanblock2.xpm' <<'END_OF_FILE'
  760. X/* XPM */
  761. Xstatic char * extanblock2_xpm[] = {
  762. X"40 20 4 1",
  763. X"     c None",
  764. X".    c tan",
  765. X"X    c tan2",
  766. X"o    c tan4",
  767. X"  ....................................  ",
  768. X" ...................................... ",
  769. X"                                        ",
  770. X"                                        ",
  771. X"..XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXoo",
  772. X"..XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXoo",
  773. X"                                        ",
  774. X"                                        ",
  775. X"..XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXoo",
  776. X"..XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXoo",
  777. X"                                        ",
  778. X"                                        ",
  779. X"..XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXoo",
  780. X"..XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXoo",
  781. X"                                        ",
  782. X"                                        ",
  783. X"..XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXoo",
  784. X"..oXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXooo",
  785. X"                                        ",
  786. X"                                        "};
  787. END_OF_FILE
  788.   if test 987 -ne `wc -c <'bitmaps/extanblock2.xpm'`; then
  789.     echo shar: \"'bitmaps/extanblock2.xpm'\" unpacked with wrong size!
  790.   fi
  791.   # end of 'bitmaps/extanblock2.xpm'
  792. fi
  793. if test -f 'bitmaps/extanblock3.xpm' -a "${1}" != "-c" ; then 
  794.   echo shar: Will not clobber existing file \"'bitmaps/extanblock3.xpm'\"
  795. else
  796.   echo shar: Extracting \"'bitmaps/extanblock3.xpm'\" \(987 characters\)
  797.   sed "s/^X//" >'bitmaps/extanblock3.xpm' <<'END_OF_FILE'
  798. X/* XPM */
  799. Xstatic char * extanblock3_xpm[] = {
  800. X"40 20 4 1",
  801. X"     c None",
  802. X".    c tan",
  803. X"X    c tan2",
  804. X"o    c tan4",
  805. X"  ....................................  ",
  806. X"                                        ",
  807. X"                                        ",
  808. X"                                        ",
  809. X"..XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXoo",
  810. X"                                        ",
  811. X"                                        ",
  812. X"                                        ",
  813. X"..XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXoo",
  814. X"                                        ",
  815. X"                                        ",
  816. X"                                        ",
  817. X"..XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXoo",
  818. X"                                        ",
  819. X"                                        ",
  820. X"                                        ",
  821. X"..XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXoo",
  822. X"                                        ",
  823. X"                                        ",
  824. X"                                        "};
  825. END_OF_FILE
  826.   if test 987 -ne `wc -c <'bitmaps/extanblock3.xpm'`; then
  827.     echo shar: \"'bitmaps/extanblock3.xpm'\" unpacked with wrong size!
  828.   fi
  829.   # end of 'bitmaps/extanblock3.xpm'
  830. fi
  831. if test -f 'bitmaps/exx2bonus3.xpm' -a "${1}" != "-c" ; then 
  832.   echo shar: Will not clobber existing file \"'bitmaps/exx2bonus3.xpm'\"
  833. else
  834.   echo shar: Extracting \"'bitmaps/exx2bonus3.xpm'\" \(927 characters\)
  835.   sed "s/^X//" >'bitmaps/exx2bonus3.xpm' <<'END_OF_FILE'
  836. X/* XPM */
  837. Xstatic char * exx2bonus3_xpm[] = {
  838. X"27 27 2 1",
  839. X"     s None    c None",
  840. X".    c gold",
  841. X"                           ",
  842. X"                           ",
  843. X"                           ",
  844. X"                           ",
  845. X"                           ",
  846. X"                           ",
  847. X"                           ",
  848. X"                           ",
  849. X"                           ",
  850. X"                           ",
  851. X"            ...            ",
  852. X"           .....           ",
  853. X"          .......          ",
  854. X"          .......          ",
  855. X"          .......          ",
  856. X"           .....           ",
  857. X"            ...            ",
  858. X"                           ",
  859. X"                           ",
  860. X"                           ",
  861. X"                           ",
  862. X"                           ",
  863. X"                           ",
  864. X"                           ",
  865. X"                           ",
  866. X"                           ",
  867. X"                           "};
  868. END_OF_FILE
  869.   if test 927 -ne `wc -c <'bitmaps/exx2bonus3.xpm'`; then
  870.     echo shar: \"'bitmaps/exx2bonus3.xpm'\" unpacked with wrong size!
  871.   fi
  872.   # end of 'bitmaps/exx2bonus3.xpm'
  873. fi
  874. if test -f 'bitmaps/exyellowblock1.xpm' -a "${1}" != "-c" ; then 
  875.   echo shar: Will not clobber existing file \"'bitmaps/exyellowblock1.xpm'\"
  876. else
  877.   echo shar: Extracting \"'bitmaps/exyellowblock1.xpm'\" \(999 characters\)
  878.   sed "s/^X//" >'bitmaps/exyellowblock1.xpm' <<'END_OF_FILE'
  879. X/* XPM */
  880. Xstatic char * exyellowblock1_xpm[] = {
  881. X"40 20 4 1",
  882. X"     c None",
  883. X".    c yellow",
  884. X"X    c yellow3",
  885. X"o    c yellow4",
  886. X"  .  .. ..... ..... ..........  ......  ",
  887. X"  .................... . .... .....  .. ",
  888. X"...X XX XX XXXX XXX XXXXXXXXXXXXXX XXooo",
  889. X"..X XXXXXXXXXX X XXXXXX X   XXXXX XX  oo",
  890. X" .XX X X     XX X XX  XXXXXX  XX XX XXoo",
  891. X"..XXXXXXXXX  X  XXXXXXXX XXXXX   X XX oo",
  892. X"..X X XXX XX XXXXXXXXX XXXXXX XXXXXXXXoo",
  893. X". XXXX XXXXX  XXXX XXXXXXX XX XXXX X Xo ",
  894. X"..XXXX X X XX   XX XXX XXXXXXXXX XXXXXoo",
  895. X" .X X XXXXXXXXX  XXXX XXXXXX   X  X  Xoo",
  896. X" .XX XXXXX XX X   XXXXX  X X X XX XXXXoo",
  897. X"..XXXXX  X XXXXXXXXX XXXXXXXX XXXXXXXXoo",
  898. X".. XXXX X XXXXXXX   X XXX XXXX  XXXX X o",
  899. X"..XXX   X X XX   XXX XXXXXX XXX  X  XXoo",
  900. X" .XXXX XXXXXXXXXXXXXX  XXX XXXX XXXXXXoo",
  901. X"..XXX XXXX XXX XXXXXX X  XXXXXX XXXXXX o",
  902. X"..XX  XXX XXXXX X XX  XXX  X XXXX X  Xoo",
  903. X".  XX XXXXX  XXXXXXXXXXXX  XXX XXXXXXoo ",
  904. X"   ooooooooooooooo ooooooo oo ooooooooo ",
  905. X"  oooo ooo ooo oooooooo oooooooo ooo o  "};
  906. END_OF_FILE
  907.   if test 999 -ne `wc -c <'bitmaps/exyellowblock1.xpm'`; then
  908.     echo shar: \"'bitmaps/exyellowblock1.xpm'\" unpacked with wrong size!
  909.   fi
  910.   # end of 'bitmaps/exyellowblock1.xpm'
  911. fi
  912. if test -f 'bitmaps/exyellowblock2.xpm' -a "${1}" != "-c" ; then 
  913.   echo shar: Will not clobber existing file \"'bitmaps/exyellowblock2.xpm'\"
  914. else
  915.   echo shar: Extracting \"'bitmaps/exyellowblock2.xpm'\" \(999 characters\)
  916.   sed "s/^X//" >'bitmaps/exyellowblock2.xpm' <<'END_OF_FILE'
  917. X/* XPM */
  918. Xstatic char * exyellowblock2_xpm[] = {
  919. X"40 20 4 1",
  920. X"     c None",
  921. X".    c yellow",
  922. X"X    c yellow3",
  923. X"o    c yellow4",
  924. X"  .  .. ... .   .   . ..  . ..  ... .   ",
  925. X"  .    ..  . . ..  ..         ..      . ",
  926. X"..   X      XX   X    X X        X XXooo",
  927. X".    XX  X     X XXX        XX  X XX  o ",
  928. X" .X             X      XX X   XX XX X o ",
  929. X".  XX   XX      XX    X   XXXX   X X    ",
  930. X". X   XX   X X XX   X   X  X  X XX  X  o",
  931. X".  X    XXX   X  X  X X    X  XX X X Xo ",
  932. X"..X  X X X XX   XX XXX X    X X  XXXX  o",
  933. X" .     XX   XX   X  X   X  X      X    o",
  934. X"     XX XX        X  X   X   X XX X  X  ",
  935. X".. X  X  X  XX X XXX XX  XX X XX XX  Xo ",
  936. X".. XXX  X XX X X      X X X XX  X  X   o",
  937. X" .X     X X XX   X   XX X X   X     X   ",
  938. X"  XX X X   XX  X XX X  XXX X XX XXXXX   ",
  939. X"    X XX    XX X    X X  XX XX  X  XXX  ",
  940. X"..     XX XX      X   X X  X X XX    X  ",
  941. X".        XX  X XXX X  X          X X    ",
  942. X"   o o   ooo       oo  ooo    o   o   o ",
  943. X"  oo   ooo oo  ooo  o o o  o ooo  oo o  "};
  944. END_OF_FILE
  945.   if test 999 -ne `wc -c <'bitmaps/exyellowblock2.xpm'`; then
  946.     echo shar: \"'bitmaps/exyellowblock2.xpm'\" unpacked with wrong size!
  947.   fi
  948.   # end of 'bitmaps/exyellowblock2.xpm'
  949. fi
  950. if test -f 'bitmaps/exyellowblock3.xpm' -a "${1}" != "-c" ; then 
  951.   echo shar: Will not clobber existing file \"'bitmaps/exyellowblock3.xpm'\"
  952. else
  953.   echo shar: Extracting \"'bitmaps/exyellowblock3.xpm'\" \(999 characters\)
  954.   sed "s/^X//" >'bitmaps/exyellowblock3.xpm' <<'END_OF_FILE'
  955. X/* XPM */
  956. Xstatic char * exyellowblock3_xpm[] = {
  957. X"40 20 4 1",
  958. X"     c None",
  959. X".    c yellow",
  960. X"X    c yellow3",
  961. X"o    c yellow4",
  962. X"     .  .             .   . .   .       ",
  963. X"                .                       ",
  964. X".    X      X         X               o ",
  965. X"         X     X             X  X       ",
  966. X"                       X         X      ",
  967. X"    X    X                         X    ",
  968. X"  X    X   X X          X     X  X      ",
  969. X"   X          X     X X                 ",
  970. X"  X        X     X            X     X   ",
  971. X"                           X           o",
  972. X"                  X      X   X X  X     ",
  973. X".           X                    X    o ",
  974. X"    XX                X                o",
  975. X"             X   X            X         ",
  976. X"   X X                     X    X  X    ",
  977. X"       X              X     XX  X   X   ",
  978. X".                       X            X  ",
  979. X".               X                X X    ",
  980. X"                         o    o         ",
  981. X"  o              o  o      o       o o  "};
  982. END_OF_FILE
  983.   if test 999 -ne `wc -c <'bitmaps/exyellowblock3.xpm'`; then
  984.     echo shar: \"'bitmaps/exyellowblock3.xpm'\" unpacked with wrong size!
  985.   fi
  986.   # end of 'bitmaps/exyellowblock3.xpm'
  987. fi
  988. if test -f 'bitmaps/greenblock.xpm' -a "${1}" != "-c" ; then 
  989.   echo shar: Will not clobber existing file \"'bitmaps/greenblock.xpm'\"
  990. else
  991.   echo shar: Extracting \"'bitmaps/greenblock.xpm'\" \(1004 characters\)
  992.   sed "s/^X//" >'bitmaps/greenblock.xpm' <<'END_OF_FILE'
  993. X/* XPM */
  994. Xstatic char * greenblock_xpm[] = {
  995. X"40 20 4 1",
  996. X"     c None",
  997. X".    c #9292FFFFAAAA",
  998. X"X    c green",
  999. X"o    c aquamarine4",
  1000. X"  ....................................  ",
  1001. X" ...................................... ",
  1002. X"...XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXooo",
  1003. X"..XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXoo",
  1004. X"..XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXoo",
  1005. X"..XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXoo",
  1006. X"..XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXoo",
  1007. X"..XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXoo",
  1008. X"..XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXoo",
  1009. X"..XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXoo",
  1010. X"..XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXoo",
  1011. X"..XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXoo",
  1012. X"..XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXoo",
  1013. X"..XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXoo",
  1014. X"..XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXoo",
  1015. X"..XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXoo",
  1016. X"..XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXoo",
  1017. X"..oXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXooo",
  1018. X" oooooooooooooooooooooooooooooooooooooo ",
  1019. X"  oooooooooooooooooooooooooooooooooooo  "};
  1020. END_OF_FILE
  1021.   if test 1004 -ne `wc -c <'bitmaps/greenblock.xpm'`; then
  1022.     echo shar: \"'bitmaps/greenblock.xpm'\" unpacked with wrong size!
  1023.   fi
  1024.   # end of 'bitmaps/greenblock.xpm'
  1025. fi
  1026. if test -f 'bitmaps/life.xpm' -a "${1}" != "-c" ; then 
  1027.   echo shar: Will not clobber existing file \"'bitmaps/life.xpm'\"
  1028. else
  1029.   echo shar: Extracting \"'bitmaps/life.xpm'\" \(987 characters\)
  1030.   sed "s/^X//" >'bitmaps/life.xpm' <<'END_OF_FILE'
  1031. X/* XPM */
  1032. Xstatic char *life_xpm[] = {
  1033. X/* width height ncolors chars_per_pixel */
  1034. X"25 24 11 1",
  1035. X/* colors */
  1036. X"     s None    c None",
  1037. X".    c #1A0084",
  1038. X"X    c #840000",
  1039. X"o    c #3000A9",
  1040. X"O    c #A91700",
  1041. X"+    c #2C00DC",
  1042. X"@    c #CC2C00",
  1043. X"#    c #3D00F2",
  1044. X"$    c #E83E00",
  1045. X"%    c #F85F00",
  1046. X"&    c #4400FE",
  1047. X/* pixels */
  1048. X"       .........XX       ",
  1049. X"       .........XX       ",
  1050. X"    ...oooooOOOO.....    ",
  1051. X"   .ooo+++@@+++oooo...   ",
  1052. X" ..o+++##$##++++++ooo... ",
  1053. X" ..o+++##$##++++++ooo... ",
  1054. X" ..o++#%%&#####+++ooo.XX ",
  1055. X" ..o++#%%&#####+++ooo.XX ",
  1056. X"Xoo+##&%%&&&####+++oooXX.",
  1057. X"Xoo+##&&&%&&####+++ooO...",
  1058. X".OO+###%%&$$####++@ooO...",
  1059. X".OO+###%%&$$####++@ooO...",
  1060. X".OO+++$#####$$$@@@+OOO...",
  1061. X".OO+++$#####$$$@@@+OOO...",
  1062. X".oo@+++$$###++++++ooooXX.",
  1063. X"...@++$@@+++++++++ooo.XX.",
  1064. X" ..o@@o++@+++++oooooo... ",
  1065. X" ..o@@o++@+++++oooooo... ",
  1066. X" ...ooooooOOooooooo..... ",
  1067. X" ...ooooooOOooooooo..... ",
  1068. X"   ....oooOOoooo......   ",
  1069. X"    .....X...........    ",
  1070. X"       ..X........       ",
  1071. X"       ..X........       "};
  1072. END_OF_FILE
  1073.   if test 987 -ne `wc -c <'bitmaps/life.xpm'`; then
  1074.     echo shar: \"'bitmaps/life.xpm'\" unpacked with wrong size!
  1075.   fi
  1076.   # end of 'bitmaps/life.xpm'
  1077. fi
  1078. if test -f 'bitmaps/paddlemedium.xpm' -a "${1}" != "-c" ; then 
  1079.   echo shar: Will not clobber existing file \"'bitmaps/paddlemedium.xpm'\"
  1080. else
  1081.   echo shar: Extracting \"'bitmaps/paddlemedium.xpm'\" \(985 characters\)
  1082.   sed "s/^X//" >'bitmaps/paddlemedium.xpm' <<'END_OF_FILE'
  1083. X/* XPM */
  1084. Xstatic char * paddlemedium_xpm[] = {
  1085. X"50 15 7 1",
  1086. X"     s None    c None",
  1087. X".    c red",
  1088. X"X    c grey30",
  1089. X"o    c gray40",
  1090. X"O    c #B7B7B7B7B7B7",
  1091. X"+    c gray80",
  1092. X"@    c #F4F4F4F4F4F4",
  1093. X"                                                  ",
  1094. X"   ............................................   ",
  1095. X"  ..............................................  ",
  1096. X" ...XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX... ",
  1097. X" ..XXooooooooooooooooooooooooooooooooooooooooXX.. ",
  1098. X" ..XOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOX.. ",
  1099. X" ..X++++++++++++++++++++++++++++++++++++++++++X.. ",
  1100. X" ..X@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@X.. ",
  1101. X" ..X++++++++++++++++++++++++++++++++++++++++++X.. ",
  1102. X" ..XOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOX.. ",
  1103. X" ..XXooooooooooooooooooooooooooooooooooooooooXX.. ",
  1104. X" ...XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX... ",
  1105. X"  ..............................................  ",
  1106. X"   ............................................   ",
  1107. X"                                                  "};
  1108. END_OF_FILE
  1109.   if test 985 -ne `wc -c <'bitmaps/paddlemedium.xpm'`; then
  1110.     echo shar: \"'bitmaps/paddlemedium.xpm'\" unpacked with wrong size!
  1111.   fi
  1112.   # end of 'bitmaps/paddlemedium.xpm'
  1113. fi
  1114. if test -f 'bitmaps/purpleblock.xpm' -a "${1}" != "-c" ; then 
  1115.   echo shar: Will not clobber existing file \"'bitmaps/purpleblock.xpm'\"
  1116. else
  1117.   echo shar: Extracting \"'bitmaps/purpleblock.xpm'\" \(996 characters\)
  1118.   sed "s/^X//" >'bitmaps/purpleblock.xpm' <<'END_OF_FILE'
  1119. X/* XPM */
  1120. Xstatic char * purpleblock_xpm[] = {
  1121. X"40 20 4 1",
  1122. X"     c None",
  1123. X".    c purple1",
  1124. X"X    c purple",
  1125. X"o    c purple4",
  1126. X"  ....................................  ",
  1127. X" ...................................... ",
  1128. X"...XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX.oo",
  1129. X"..XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXoo",
  1130. X"..XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXoo",
  1131. X"..XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXoo",
  1132. X"..XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXoo",
  1133. X"..XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXoo",
  1134. X"..XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXoo",
  1135. X"..XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXoo",
  1136. X"..XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXoo",
  1137. X"..XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXoo",
  1138. X"..XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXoo",
  1139. X"..XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXoo",
  1140. X"..XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXoo",
  1141. X"..XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXoo",
  1142. X"..XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXoo",
  1143. X"..oXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXooo",
  1144. X" oooooooooooooooooooooooooooooooooooooo ",
  1145. X"  oooooooooooooooooooooooooooooooooooo  "};
  1146. END_OF_FILE
  1147.   if test 996 -ne `wc -c <'bitmaps/purpleblock.xpm'`; then
  1148.     echo shar: \"'bitmaps/purpleblock.xpm'\" unpacked with wrong size!
  1149.   fi
  1150.   # end of 'bitmaps/purpleblock.xpm'
  1151. fi
  1152. if test -f 'bitmaps/redblock.xpm' -a "${1}" != "-c" ; then 
  1153.   echo shar: Will not clobber existing file \"'bitmaps/redblock.xpm'\"
  1154. else
  1155.   echo shar: Extracting \"'bitmaps/redblock.xpm'\" \(985 characters\)
  1156.   sed "s/^X//" >'bitmaps/redblock.xpm' <<'END_OF_FILE'
  1157. X/* XPM */
  1158. Xstatic char * redblock_xpm[] = {
  1159. X"40 20 4 1",
  1160. X"     c None",
  1161. X".    c red1",
  1162. X"X    c red4",
  1163. X"o    c red3",
  1164. X"  ....................................  ",
  1165. X" .....................................X ",
  1166. X"...oooooooooooooooooooooooooooooooooo.XX",
  1167. X"..ooooooooooooooooooooooooooooooooooooXX",
  1168. X"..ooooooooooooooooooooooooooooooooooooXX",
  1169. X"..ooooooooooooooooooooooooooooooooooooXX",
  1170. X"..ooooooooooooooooooooooooooooooooooooXX",
  1171. X"..ooooooooooooooooooooooooooooooooooooXX",
  1172. X"..ooooooooooooooooooooooooooooooooooooXX",
  1173. X"..ooooooooooooooooooooooooooooooooooooXX",
  1174. X"..ooooooooooooooooooooooooooooooooooooXX",
  1175. X"..ooooooooooooooooooooooooooooooooooooXX",
  1176. X"..ooooooooooooooooooooooooooooooooooooXX",
  1177. X"..ooooooooooooooooooooooooooooooooooooXX",
  1178. X"..ooooooooooooooooooooooooooooooooooooXX",
  1179. X"..ooooooooooooooooooooooooooooooooooooXX",
  1180. X"..ooooooooooooooooooooooooooooooooooooXX",
  1181. X"..XooooooooooooooooooooooooooooooooooXXX",
  1182. X" XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX ",
  1183. X"  XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX  "};
  1184. END_OF_FILE
  1185.   if test 985 -ne `wc -c <'bitmaps/redblock.xpm'`; then
  1186.     echo shar: \"'bitmaps/redblock.xpm'\" unpacked with wrong size!
  1187.   fi
  1188.   # end of 'bitmaps/redblock.xpm'
  1189. fi
  1190. if test -f 'bitmaps/tanblock.xpm' -a "${1}" != "-c" ; then 
  1191.   echo shar: Will not clobber existing file \"'bitmaps/tanblock.xpm'\"
  1192. else
  1193.   echo shar: Extracting \"'bitmaps/tanblock.xpm'\" \(984 characters\)
  1194.   sed "s/^X//" >'bitmaps/tanblock.xpm' <<'END_OF_FILE'
  1195. X/* XPM */
  1196. Xstatic char * tanblock_xpm[] = {
  1197. X"40 20 4 1",
  1198. X"     c None",
  1199. X".    c tan",
  1200. X"X    c tan2",
  1201. X"o    c tan4",
  1202. X"  ....................................  ",
  1203. X" ...................................... ",
  1204. X"...XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXooo",
  1205. X"..XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXoo",
  1206. X"..XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXoo",
  1207. X"..XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXoo",
  1208. X"..XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXoo",
  1209. X"..XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXoo",
  1210. X"..XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXoo",
  1211. X"..XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXoo",
  1212. X"..XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXoo",
  1213. X"..XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXoo",
  1214. X"..XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXoo",
  1215. X"..XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXoo",
  1216. X"..XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXoo",
  1217. X"..XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXoo",
  1218. X"..XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXoo",
  1219. X"..oXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXooo",
  1220. X" .ooooooooooooooooooooooooooooooooooooo ",
  1221. X"  oooooooooooooooooooooooooooooooooooo  "};
  1222. END_OF_FILE
  1223.   if test 984 -ne `wc -c <'bitmaps/tanblock.xpm'`; then
  1224.     echo shar: \"'bitmaps/tanblock.xpm'\" unpacked with wrong size!
  1225.   fi
  1226.   # end of 'bitmaps/tanblock.xpm'
  1227. fi
  1228. if test -f 'bitmaps/xtraball.xpm' -a "${1}" != "-c" ; then 
  1229.   echo shar: Will not clobber existing file \"'bitmaps/xtraball.xpm'\"
  1230. else
  1231.   echo shar: Extracting \"'bitmaps/xtraball.xpm'\" \(955 characters\)
  1232.   sed "s/^X//" >'bitmaps/xtraball.xpm' <<'END_OF_FILE'
  1233. X/* XPM */
  1234. Xstatic char * xtraball_xpm[] = {
  1235. X/* width height ncolors chars_per_pixel */
  1236. X"30 19 12 1",
  1237. X/* colors */
  1238. X"     s None    c None",
  1239. X".    c #1A0084",
  1240. X"X    c #840000",
  1241. X"o    c #3000A9",
  1242. X"O    c #A91700",
  1243. X"+    c #2C00DC",
  1244. X"@    c #3D00F2",
  1245. X"#    c #CC2C00",
  1246. X"$    c white",
  1247. X"%    c #4400FE",
  1248. X"&    c #E83E00",
  1249. X"*    c #F85F00",
  1250. X/* pixels */
  1251. X"           ...XXX..           ",
  1252. X"         ..ooooooO...         ",
  1253. X"       ..oo++++++Ooo...       ",
  1254. X"       ..oo++++++Ooo...       ",
  1255. X"      .oo++@@@#$$++oo...      ",
  1256. X"      .oo+@%%&@$$++oo...      ",
  1257. X" $$$$Xo$$@%$$%$$$$+$$o$$.$$$$ ",
  1258. X"$$  $$O$$@%$$*@$$@+$$$$$$$  $$",
  1259. X"$$  $$o#$$$$%@&$$@+$$$O..   $$",
  1260. X"$$$$$$o##$$%%@&$$@+$$OO..$$$$$",
  1261. X"$$   .o+$$$$@@@$$#+$$ooX$$  $$",
  1262. X"$$  $$o$$#+$$@+$$#$$$oo.$$  $$",
  1263. X" $$$$..$$++$$+##$$+$$....$$$ $",
  1264. X"      Xoooo++++++Oooo...      ",
  1265. X"      ...ooooooooOoo....      ",
  1266. X"       ....oooooooXX...       ",
  1267. X"       ....oooooooXX...       ",
  1268. X"         ...........X         ",
  1269. X"           ........           "};
  1270. END_OF_FILE
  1271.   if test 955 -ne `wc -c <'bitmaps/xtraball.xpm'`; then
  1272.     echo shar: \"'bitmaps/xtraball.xpm'\" unpacked with wrong size!
  1273.   fi
  1274.   # end of 'bitmaps/xtraball.xpm'
  1275. fi
  1276. if test -f 'bitmaps/xtraball2.xpm' -a "${1}" != "-c" ; then 
  1277.   echo shar: Will not clobber existing file \"'bitmaps/xtraball2.xpm'\"
  1278. else
  1279.   echo shar: Extracting \"'bitmaps/xtraball2.xpm'\" \(957 characters\)
  1280.   sed "s/^X//" >'bitmaps/xtraball2.xpm' <<'END_OF_FILE'
  1281. X/* XPM */
  1282. Xstatic char * xtraball2_xpm[] = {
  1283. X/* width height ncolors chars_per_pixel */
  1284. X"30 19 12 1",
  1285. X/* colors */
  1286. X"     s None    c None",
  1287. X".    c #1A0084",
  1288. X"X    c #840000",
  1289. X"o    c #3000A9",
  1290. X"O    c #A91700",
  1291. X"+    c #2C00DC",
  1292. X"@    c #3D00F2",
  1293. X"#    c #CC2C00",
  1294. X"$    c orange",
  1295. X"%    c #4400FE",
  1296. X"&    c #E83E00",
  1297. X"*    c #F85F00",
  1298. X/* pixels */
  1299. X"           ...XXX..           ",
  1300. X"         ..ooooooO...         ",
  1301. X"       ..oo++++++Ooo...       ",
  1302. X"       ..oo++++++Ooo...       ",
  1303. X"      .oo++@@@#$$++oo...      ",
  1304. X"      .oo+@%%&@$$++oo...      ",
  1305. X" $$$$Xo$$@%$$%$$$$+$$o$$.$$$$ ",
  1306. X"$$  $$O$$@%$$*@$$@+$$$$$$$  $$",
  1307. X"$$  $$o#$$$$%@&$$@+$$$O..   $$",
  1308. X"$$$$$$o##$$%%@&$$@+$$OO..$$$$$",
  1309. X"$$   .o+$$$$@@@$$#+$$ooX$$  $$",
  1310. X"$$  $$o$$#+$$@+$$#$$$oo.$$  $$",
  1311. X" $$$$..$$++$$+##$$+$$....$$$ $",
  1312. X"      Xoooo++++++Oooo...      ",
  1313. X"      ...ooooooooOoo....      ",
  1314. X"       ....oooooooXX...       ",
  1315. X"       ....oooooooXX...       ",
  1316. X"         ...........X         ",
  1317. X"           ........           "};
  1318. END_OF_FILE
  1319.   if test 957 -ne `wc -c <'bitmaps/xtraball2.xpm'`; then
  1320.     echo shar: \"'bitmaps/xtraball2.xpm'\" unpacked with wrong size!
  1321.   fi
  1322.   # end of 'bitmaps/xtraball2.xpm'
  1323. fi
  1324. if test -f 'bitmaps/yellowblock.xpm' -a "${1}" != "-c" ; then 
  1325.   echo shar: Will not clobber existing file \"'bitmaps/yellowblock.xpm'\"
  1326. else
  1327.   echo shar: Extracting \"'bitmaps/yellowblock.xpm'\" \(996 characters\)
  1328.   sed "s/^X//" >'bitmaps/yellowblock.xpm' <<'END_OF_FILE'
  1329. X/* XPM */
  1330. Xstatic char * yellowblock_xpm[] = {
  1331. X"40 20 4 1",
  1332. X"     c None",
  1333. X".    c yellow",
  1334. X"X    c yellow3",
  1335. X"o    c yellow4",
  1336. X"  ....................................  ",
  1337. X" ...................................... ",
  1338. X"...XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXooo",
  1339. X"..XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXoo",
  1340. X"..XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXoo",
  1341. X"..XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXoo",
  1342. X"..XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXoo",
  1343. X"..XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXoo",
  1344. X"..XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXoo",
  1345. X"..XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXoo",
  1346. X"..XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXoo",
  1347. X"..XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXoo",
  1348. X"..XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXoo",
  1349. X"..XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXoo",
  1350. X"..XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXoo",
  1351. X"..XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXoo",
  1352. X"..XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXoo",
  1353. X"..oXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXooo",
  1354. X" .ooooooooooooooooooooooooooooooooooooo ",
  1355. X"  oooooooooooooooooooooooooooooooooooo  "};
  1356. END_OF_FILE
  1357.   if test 996 -ne `wc -c <'bitmaps/yellowblock.xpm'`; then
  1358.     echo shar: \"'bitmaps/yellowblock.xpm'\" unpacked with wrong size!
  1359.   fi
  1360.   # end of 'bitmaps/yellowblock.xpm'
  1361. fi
  1362. if test -f 'intro.h' -a "${1}" != "-c" ; then 
  1363.   echo shar: Will not clobber existing file \"'intro.h'\"
  1364. else
  1365.   echo shar: Extracting \"'intro.h'\" \(1065 characters\)
  1366.   sed "s/^X//" >'intro.h' <<'END_OF_FILE'
  1367. X#ifndef _INTRO_H_
  1368. X#define _INTRO_H_
  1369. X
  1370. X#include "copyright.h"
  1371. X
  1372. X/*
  1373. X *  Dependencies on other include files:
  1374. X */
  1375. X
  1376. X#include <X11/Xlib.h>
  1377. X
  1378. X/*
  1379. X *  Constants and macros:
  1380. X */
  1381. X
  1382. X/*
  1383. X *  Type declarations:
  1384. X */
  1385. X
  1386. Xenum IntroStates 
  1387. X{ 
  1388. X    INTRO_TITLE, 
  1389. X    INTRO_BLOCKS, 
  1390. X    INTRO_TEXT, 
  1391. X    INTRO_EXPLODE, 
  1392. X    INTRO_WAIT, 
  1393. X    INTRO_FINISH 
  1394. X};
  1395. X
  1396. X/*
  1397. X *  Function prototypes:
  1398. X */
  1399. X
  1400. X#if NeedFunctionPrototypes
  1401. Xvoid SetUpIntroduction(Display *display, Window window, Colormap colormap);
  1402. Xvoid Introduction(Display *display, Window window);
  1403. Xvoid RedrawIntroduction(Display *display, Window window);
  1404. Xvoid FreeIntroduction(Display *display);
  1405. Xvoid ResetIntroduction(void);
  1406. Xvoid DoIntroTitle(Display *display, Window window);
  1407. Xvoid DrawIntroTitle(Display *display, Window window, int x, int y);
  1408. X#else
  1409. Xvoid DrawIntroTitle();
  1410. Xvoid SetUpIntroduction();
  1411. Xvoid Introduction();
  1412. Xvoid RedrawIntroduction();
  1413. Xvoid FreeIntroduction();
  1414. Xvoid ResetIntroduction();
  1415. Xvoid DoIntroTitle();
  1416. X#endif
  1417. X
  1418. Xextern     enum IntroStates IntroState;
  1419. Xextern     Pixmap bigtitlePixmap, bigtitlePixmapM;
  1420. Xextern    Pixmap stars[12], starsM[12];
  1421. X
  1422. X
  1423. X#endif
  1424. END_OF_FILE
  1425.   if test 1065 -ne `wc -c <'intro.h'`; then
  1426.     echo shar: \"'intro.h'\" unpacked with wrong size!
  1427.   fi
  1428.   # end of 'intro.h'
  1429. fi
  1430. if test -f 'misc.h' -a "${1}" != "-c" ; then 
  1431.   echo shar: Will not clobber existing file \"'misc.h'\"
  1432. else
  1433.   echo shar: Extracting \"'misc.h'\" \(1116 characters\)
  1434.   sed "s/^X//" >'misc.h' <<'END_OF_FILE'
  1435. X#ifndef _MISC_H_
  1436. X#define _MISC_H_
  1437. X
  1438. X#include "copyright.h"
  1439. X
  1440. X/*
  1441. X *  Dependencies on other include files:
  1442. X */
  1443. X
  1444. X#include <X11/Xlib.h>
  1445. X
  1446. X/*
  1447. X *  Constants and macros:
  1448. X */
  1449. X
  1450. X/*
  1451. X *  Type declarations:
  1452. X */
  1453. X
  1454. X/*
  1455. X *  Function prototypes:
  1456. X */
  1457. X
  1458. X#if NeedFunctionPrototypes
  1459. Xvoid DrawText(Display *display, Window window, int x, int y, XFontStruct *font,
  1460. X    int colour, char *text, int numChar);
  1461. Xvoid DrawLine(Display *display, Window window, int x, int y, int x2, int y2,
  1462. X    int colour, int width);
  1463. Xvoid RenderShape(Display *display, Window window, Pixmap pixmap,
  1464. X    Pixmap mask, int x, int y, int w, int h, int clear);
  1465. Xvoid DrawShadowCentredText(Display *display, Window window, XFontStruct *font,
  1466. X    char *string, int y, int colour, int width);
  1467. Xvoid DrawShadowText(Display *display, Window window, XFontStruct *font,
  1468. X    char *string, int x, int y, int colour);
  1469. Xint ColourNameToPixel(Display *display, Colormap colormap, char *colourName);
  1470. Xvoid FreeMisc(Display *display);
  1471. X#else
  1472. Xvoid FreeMisc();
  1473. Xint ColourNameToPixel();
  1474. Xvoid DrawText();
  1475. Xvoid DrawLine();
  1476. Xvoid RenderShape();
  1477. Xvoid DrawShadowCentredText();
  1478. Xvoid DrawShadowText();
  1479. X#endif
  1480. X
  1481. X#endif
  1482. END_OF_FILE
  1483.   if test 1116 -ne `wc -c <'misc.h'`; then
  1484.     echo shar: \"'misc.h'\" unpacked with wrong size!
  1485.   fi
  1486.   # end of 'misc.h'
  1487. fi
  1488. echo shar: End of archive 24 \(of 26\).
  1489. cp /dev/null ark24isdone
  1490. MISSING=""
  1491. for I in 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 ; do
  1492.     if test ! -f ark${I}isdone ; then
  1493.     MISSING="${MISSING} ${I}"
  1494.     fi
  1495. done
  1496. if test "${MISSING}" = "" ; then
  1497.     echo You have unpacked all 26 archives.
  1498.     rm -f ark[1-9]isdone ark[1-9][0-9]isdone
  1499.     echo "merging split files..."
  1500.     cat blocks.c[12] > blocks.c
  1501.     rm blocks.c[12]
  1502.     echo "blocks.c done"
  1503.     cat bitmaps/earth.xpm.Z.u.[ab] > bitmaps/earth.xpm.Z.uue
  1504.     rm bitmaps/earth.xpm.Z.u.[ab]
  1505.     echo "bitmaps/earth.xpm.Z.uue done"
  1506. else
  1507.     echo You still must unpack the following archives:
  1508.     echo "        " ${MISSING}
  1509. fi
  1510. exit 0
  1511. exit 0 # Just in case...
  1512. -- 
  1513.   // chris@Sterling.COM           | Send comp.sources.x submissions to:
  1514. \X/  Amiga - The only way to fly! |    sources-x@sterling.com
  1515.  "It's intuitively obvious to the |
  1516.   most casual observer..."        | GCS d+/-- p+ c++ l+ m+ s++/+ g+ w+ t+ r+ x+
  1517.