home *** CD-ROM | disk | FTP | other *** search
/ Source Code 1994 March / Source_Code_CD-ROM_Walnut_Creek_March_1994.iso / compsrcs / x / volume18 / xmris / patch1.02 < prev    next >
Encoding:
Internet Message Format  |  1992-07-28  |  50.5 KB
  1. Path: uunet!uunet!elroy.jpl.nasa.gov!swrinde!mips!msi!dcmartin
  2. From: nathan@inmos.co.uk (Nathan Sidwell)
  3. Newsgroups: comp.sources.x
  4. Subject: v18i073: xmris version 2.00, Patch1, Part02/05
  5. Message-ID: <1992Jul29.181100.15589@msi.com>
  6. Date: 29 Jul 92 18:11:00 GMT
  7. References: <csx-18i072-xmris@uunet.UU.NET>
  8. Sender: dcmartin@msi.com (David C. Martin - Moderator)
  9. Organization: Molecular Simulations, Inc.
  10. Lines: 1540
  11. Approved: dcmartin@msi.com
  12. Originator: dcmartin@fascet
  13.  
  14. Submitted-by: Nathan Sidwell <nathan@inmos.co.uk>
  15. Posting-number: Volume 18, Issue 73
  16. Archive-name: xmris/patch1.02
  17. Patch-To: xmris: Volume XXX, Issue XXX
  18.  
  19. #!/bin/sh
  20. # this is part.02 (part 2 of a multipart archive)
  21. # do not concatenate these parts, unpack them in order with /bin/sh
  22. # file patch.v2.00 continued
  23. #
  24. if test ! -r _shar_seq_.tmp; then
  25.     echo 'Please unpack part 1 first!'
  26.     exit 1
  27. fi
  28. (read Scheck
  29.  if test "$Scheck" != 2; then
  30.     echo Please unpack part "$Scheck" next!
  31.     exit 1
  32.  else
  33.     exit 0
  34.  fi
  35. ) < _shar_seq_.tmp || exit 1
  36. if test ! -f _shar_wnt_.tmp; then
  37.     echo 'x - still skipping patch.v2.00'
  38. else
  39. echo 'x - continuing file patch.v2.00'
  40. sed 's/^X//' << 'SHAR_EOF' >> 'patch.v2.00' &&
  41. !   {dronsq_bits, dronsqm_bits, dronsq_width, dronsq_height, {CELL_WIDTH, CELL_HEIGHT / 4}},
  42. !   {NULL, NULL, 0, 0, {0, 0}, SPRITE_SQUISHED + 9, 1},
  43. !   {plyrsq_bits, plyrsqm_bits, plyrsq_width, plyrsq_height, {CELL_WIDTH, CELL_HEIGHT / 4}},
  44. X    /*}}}*/
  45. X    /*{{{  2:chomp (open, closed)*/
  46. !   {chmpopn_bits, chmpopnm_bits, chmpopn_width, chmpopn_height, {CELL_WIDTH, CELL_HEIGHT}},
  47. !   {chmpcls_bits, chmpclsm_bits, chmpcls_width, chmpcls_height, {CELL_WIDTH, CELL_HEIGHT}},
  48. X    /*}}}*/
  49. X    /*{{{  8:m r i s*/
  50. !   {solidm_bits, bigm_bits, solidm_width, solidm_height, {CELL_WIDTH, CELL_HEIGHT}},
  51. !   {solidr_bits, bigr_bits, solidr_width, solidr_height, {CELL_WIDTH, CELL_HEIGHT}},
  52. !   {solidi_bits, bigi_bits, solidi_width, solidi_height, {CELL_WIDTH, CELL_HEIGHT}},
  53. !   {solids_bits, bigs_bits, solids_width, solids_height, {CELL_WIDTH, CELL_HEIGHT}},
  54. !   {shellm_bits, bigm_bits, shellm_width, shellm_height, {CELL_WIDTH, CELL_HEIGHT}},
  55. !   {shellr_bits, bigr_bits, shellr_width, shellr_height, {CELL_WIDTH, CELL_HEIGHT}},
  56. !   {shelli_bits, bigi_bits, shelli_width, shelli_height, {CELL_WIDTH, CELL_HEIGHT}},
  57. !   {shells_bits, bigs_bits, shells_width, shells_height, {CELL_WIDTH, CELL_HEIGHT}},
  58. X    /*}}}*/
  59. X    /*{{{  5:prizes*/
  60. !   {cake_bits,    cakem_bits,    cake_width,    cake_height,    {CELL_WIDTH, CELL_HEIGHT}},
  61. !   {spanner_bits, spannerm_bits, spanner_width, spanner_height, {CELL_WIDTH, CELL_HEIGHT}},
  62. !   {brolly_bits,  brollym_bits,  brolly_width,  brolly_height,  {CELL_WIDTH, CELL_HEIGHT}},
  63. !   {mushrm_bits,  mushrmm_bits,  mushrm_width,  mushrm_height,  {CELL_WIDTH, CELL_HEIGHT}},
  64. !   {clock_bits,   clockm_bits,   clock_width,   clock_height,   {CELL_WIDTH, CELL_HEIGHT}},
  65. X    /*}}}*/
  66. X  };
  67. X  /*}}}*/
  68. ! /*{{{  static SPRITE spritet[2] =*/
  69. X  static SPRITE spritet[2] =
  70. X  {
  71. !   {solidt_bits, bigt_bits, solidt_width, solidt_height, {CELL_WIDTH, CELL_HEIGHT}},
  72. !   {shellt_bits, bigt_bits, shellt_width, shellt_height, {CELL_WIDTH, CELL_HEIGHT}},
  73. X  };
  74. X  /*}}}*/
  75. X  /*{{{  static SPRITE icons[2] =*/
  76. X  static SPRITE icons[2] =
  77. X  {
  78. !   {NULL, mris_bits, mris_width, mris_height},
  79. !   {NULL, msit_bits, msit_width, msit_height},
  80. X  };
  81. X  /*}}}*/
  82. X  /*{{{  APPLE_SIZE const apple_sizes[6] =*/
  83. --- 184,386 ----
  84. X    {"iconic",  1, &flags.iconic,   "Start iconic"},
  85. X    {"mris",    0, &flags.gender,   "Male version"},
  86. X    {"msit",    1, &flags.gender,   "Female version"},
  87. +   {"scores", -1, &score_file,     "High score file"},
  88. X    {NULL}
  89. X  };
  90. X  /*}}}*/
  91. + /*{{{  DEFAULT const defaults[] =*/
  92. + static DEFAULT const defaults[] =
  93. + {
  94. +   {"up",        0},
  95. +   {"down",      1},
  96. +   {"left",      2},
  97. +   {"right",     3},
  98. +   {"throw",     KEY_THROW},
  99. +   {"pause",     KEY_PAUSE},
  100. +   {"quit",      KEY_QUIT},
  101. +   {"iconize",   KEY_ICONIZE},
  102. +   {"keyboard",  KEY_KEYBOARD},
  103. +   {"font",      -1, &font.name},
  104. +   {"scores",    -1, &score_file},
  105. +   {NULL}
  106. + };
  107. + /*}}}*/
  108. X  /*{{{  SPRITE sprites[] =*/
  109. X  SPRITE sprites[] =
  110. X  {
  111. X    /*{{{  2:center masks (oblong, rect)*/
  112. !   {NULL, oblong_bits, {oblong_width, oblong_height}, {CELL_WIDTH, CELL_HEIGHT}},
  113. !   {NULL, rect_bits, {rect_width, rect_height}, {CELL_WIDTH, CELL_HEIGHT}},
  114. X    /*}}}*/
  115. X    /*{{{  2:munch masks (tb,lr)*/
  116. !   {NULL, munchtb_bits, {munchtb_width, munchtb_height}, {CELL_WIDTH, MUNCH_HEIGHT}},
  117. !   {NULL, munchlr_bits, {munchlr_width, munchlr_height}, {MUNCH_WIDTH, CELL_HEIGHT}},
  118. X    /*}}}*/
  119. X    /*{{{  2:edge masks (tb, lr)*/
  120. !   {NULL, edgetb_bits, {edgetb_width, edgetb_height}, {GAP_WIDTH * 5, EDGE_HEIGHT}},
  121. !   {NULL, edgelr_bits, {edgelr_width, edgelr_height}, {EDGE_WIDTH, GAP_HEIGHT * 5}},
  122. X    /*}}}*/
  123. X    /*{{{  4:fills (0,1,2,3)*/
  124. !   {fill0_bits, NULL, {fill0_width, fill0_height}, {0, 0}},
  125. !   {fill1_bits, NULL, {fill1_width, fill1_height}, {0, 0}},
  126. !   {fill2_bits, NULL, {fill2_width, fill2_height}, {0, 0}},
  127. !   {fill3_bits, NULL, {fill3_width, fill3_height}, {0, 0}},
  128. X    /*}}}*/
  129. X    /*{{{  1:digits (0,1,2,3,4,5,6,7,8,9,' ')*/
  130. !   {digits_bits, digitsm_bits, {digits_width, digits_height}, {DIGIT_WIDTH * 11, DIGIT_HEIGHT}},
  131. X    /*}}}*/
  132. X    /*{{{  1:cherry*/
  133. !   {cherry_bits, cherrym_bits, {cherry_width, cherry_height}, {CELL_WIDTH, CELL_HEIGHT}},
  134. X    /*}}}*/
  135. X    /*{{{  1:den*/
  136. !   {den_bits, denm_bits, {den_width, den_height}, {CELL_WIDTH, CELL_HEIGHT}},
  137. X    /*}}}*/
  138. X    /*{{{  1:ball*/
  139. !   {ball_bits, ball_bits, {ball_width, ball_height}, {BALL_WIDTH, BALL_HEIGHT}},
  140. X    /*}}}*/
  141. X    /*{{{  6:apples (apple, rock, apple, split, decay, rot)*/
  142. !   {apple_bits, applem_bits, {apple_width, apple_height}, {CELL_WIDTH, CELL_HEIGHT}},
  143. !   {rock_bits,  rockm_bits,  {rock_width,  rock_height},  {CELL_WIDTH, CELL_HEIGHT}},
  144. !   {NULL, NULL, {0, 0}, {0, 0}, SPRITE_APPLE, 0},
  145. !   {split_bits, splitm_bits, {split_width, split_height}, {CELL_WIDTH, CELL_HEIGHT}},
  146. !   {decay_bits, decaym_bits, {decay_width, decay_height}, {DECAY_WIDTH, DECAY_HEIGHT}},
  147. !   {rot_bits,   rotm_bits,   {rot_width,   rot_height}, {ROT_WIDTH, ROT_HEIGHT}},
  148. X    /*}}}*/
  149. X    /*{{{  2:extra (bold, faint)*/
  150. !   {xtrbold_bits,  xtrbold_bits, {xtrbold_width,  xtrbold_height}, {CELL_WIDTH / 2 * 5, CELL_HEIGHT / 2}},
  151. !   {xtrfaint_bits, xtrbold_bits, {xtrfaint_width, xtrfaint_height}, {CELL_WIDTH / 2 * 5, CELL_HEIGHT / 2}},
  152. X    /*}}}*/
  153. X    /*{{{  2:xtra source*/
  154. !   {xtra1_bits, xtra1m_bits, {xtra1_width, xtra1_height}, {CELL_WIDTH, CELL_HEIGHT}},
  155. !   {xtra2_bits, xtra2m_bits, {xtra2_width, xtra2_height}, {CELL_WIDTH, CELL_HEIGHT}},
  156. X    /*}}}*/
  157. X    /*{{{  12:normal (ul, dr, l, r, ur, dl)*/
  158. !   {NULL, NULL, {0, 0}, {0, 0}, SPRITE_NORMAL + 8, 1},
  159. !   {NULL, NULL, {0, 0}, {0, 0}, SPRITE_NORMAL + 9, 1},
  160. !   {NULL, NULL, {0, 0}, {0, 0}, SPRITE_NORMAL + 8, 2},
  161. !   {NULL, NULL, {0, 0}, {0, 0}, SPRITE_NORMAL + 9, 2},
  162. !   {NULL, NULL, {0, 0}, {0, 0}, SPRITE_NORMAL + 6, 1},
  163. !   {NULL, NULL, {0, 0}, {0, 0}, SPRITE_NORMAL + 7, 1},
  164. !   {normrt1_bits, normrt1m_bits, {normrt1_width, normrt1_height}, {CELL_WIDTH, CELL_HEIGHT}},
  165. !   {normrt2_bits, normrt2m_bits, {normrt2_width, normrt2_height}, {CELL_WIDTH, CELL_HEIGHT}},
  166. !   {normup1_bits, normup1m_bits, {normup1_width, normup1_height}, {CELL_WIDTH, CELL_HEIGHT}},
  167. !   {normup2_bits, normup2m_bits, {normup2_width, normup1_height}, {CELL_WIDTH, CELL_HEIGHT}},
  168. !   {NULL, NULL, {0, 0}, {0, 0}, SPRITE_NORMAL + 0, 2},
  169. !   {NULL, NULL, {0, 0}, {0, 0}, SPRITE_NORMAL + 1, 2},
  170. X    /*}}}*/
  171. X    /*{{{  12:muncher (ul, dr, l, r, ur, dl)*/
  172. !   {NULL, NULL, {0, 0}, {0, 0}, SPRITE_MUNCHER + 8, 1},
  173. !   {NULL, NULL, {0, 0}, {0, 0}, SPRITE_MUNCHER + 9, 1},
  174. !   {NULL, NULL, {0, 0}, {0, 0}, SPRITE_MUNCHER + 8, 2},
  175. !   {NULL, NULL, {0, 0}, {0, 0}, SPRITE_MUNCHER + 9, 2},
  176. !   {NULL, NULL, {0, 0}, {0, 0}, SPRITE_MUNCHER + 6, 1},
  177. !   {NULL, NULL, {0, 0}, {0, 0}, SPRITE_MUNCHER + 7, 1},
  178. !   {mnchrt1_bits, mnchrt1m_bits, {mnchrt1_width, mnchrt1_height}, {CELL_WIDTH, CELL_HEIGHT}},
  179. !   {mnchrt2_bits, mnchrt2m_bits, {mnchrt2_width, mnchrt2_height}, {CELL_WIDTH, CELL_HEIGHT}},
  180. !   {mnchup1_bits, mnchup1m_bits, {mnchup1_width, mnchup1_height}, {CELL_WIDTH, CELL_HEIGHT}},
  181. !   {mnchup2_bits, mnchup2m_bits, {mnchup2_width, mnchup2_height}, {CELL_WIDTH, CELL_HEIGHT}},
  182. !   {NULL, NULL, {0, 0}, {0, 0}, SPRITE_MUNCHER + 0, 2},
  183. !   {NULL, NULL, {0, 0}, {0, 0}, SPRITE_MUNCHER + 1, 2},
  184. X    /*}}}*/
  185. X    /*{{{  12:xtra (ul, dr, l, r, ur, dl)*/
  186. !   {xtra1_bits, xtra1m_bits, {xtra1_width, xtra1_height}, {CELL_WIDTH, CELL_HEIGHT}},
  187. !   {xtra2_bits, xtra2m_bits, {xtra2_width, xtra2_height}, {CELL_WIDTH, CELL_HEIGHT}},
  188. !   {NULL, NULL, {0, 0}, {0, 0}, SPRITE_XTRA + 0, 0},
  189. !   {NULL, NULL, {0, 0}, {0, 0}, SPRITE_XTRA + 1, 0},
  190. !   {NULL, NULL, {0, 0}, {0, 0}, SPRITE_XTRA + 0, 0},
  191. !   {NULL, NULL, {0, 0}, {0, 0}, SPRITE_XTRA + 1, 0},
  192. !   {NULL, NULL, {0, 0}, {0, 0}, SPRITE_XTRA + 0, 0},
  193. !   {NULL, NULL, {0, 0}, {0, 0}, SPRITE_XTRA + 1, 0},
  194. !   {NULL, NULL, {0, 0}, {0, 0}, SPRITE_XTRA + 0, 0},
  195. !   {NULL, NULL, {0, 0}, {0, 0}, SPRITE_XTRA + 1, 0},
  196. !   {NULL, NULL, {0, 0}, {0, 0}, SPRITE_XTRA + 0, 0},
  197. !   {NULL, NULL, {0, 0}, {0, 0}, SPRITE_XTRA + 1, 0},
  198. X    /*}}}*/
  199. X    /*{{{  12:drone (ul, dr, l, r, ur, dl)*/
  200. !   {NULL, NULL, {0, 0}, {0, 0}, SPRITE_DRONE + 8, 1},
  201. !   {NULL, NULL, {0, 0}, {0, 0}, SPRITE_DRONE + 9, 1},
  202. !   {NULL, NULL, {0, 0}, {0, 0}, SPRITE_DRONE + 8, 2},
  203. !   {NULL, NULL, {0, 0}, {0, 0}, SPRITE_DRONE + 9, 2},
  204. !   {NULL, NULL, {0, 0}, {0, 0}, SPRITE_DRONE + 6, 1},
  205. !   {NULL, NULL, {0, 0}, {0, 0}, SPRITE_DRONE + 7, 1},
  206. !   {dronrt1_bits, dronrt1m_bits, {dronrt1_width, dronrt1_height}, {CELL_WIDTH, CELL_HEIGHT}},
  207. !   {dronrt2_bits, dronrt2m_bits, {dronrt2_width, dronrt2_height}, {CELL_WIDTH, CELL_HEIGHT}},
  208. !   {dronup1_bits, dronup1m_bits, {dronup1_width, dronup1_height}, {CELL_WIDTH, CELL_HEIGHT}},
  209. !   {dronup2_bits, dronup2m_bits, {dronup2_width, dronup2_height}, {CELL_WIDTH, CELL_HEIGHT}},
  210. !   {NULL, NULL, {0, 0}, {0, 0}, SPRITE_DRONE + 0, 2},
  211. !   {NULL, NULL, {0, 0}, {0, 0}, SPRITE_DRONE + 1, 2},
  212. X    /*}}}*/
  213. X    /*{{{  12:player (ul, dr, l, r, ur, dl)*/
  214. !   {NULL, NULL, {0, 0}, {0, 0}, SPRITE_PLAYER + 8, 1},
  215. !   {NULL, NULL, {0, 0}, {0, 0}, SPRITE_PLAYER + 9, 1},
  216. !   {NULL, NULL, {0, 0}, {0, 0}, SPRITE_PLAYER + 8, 2},
  217. !   {NULL, NULL, {0, 0}, {0, 0}, SPRITE_PLAYER + 9, 2},
  218. !   {NULL, NULL, {0, 0}, {0, 0}, SPRITE_PLAYER + 6, 1},
  219. !   {NULL, NULL, {0, 0}, {0, 0}, SPRITE_PLAYER + 7, 1},
  220. !   {plyrrt1_bits, plyrrt1m_bits, {plyrrt1_width, plyrrt1_height}, {CELL_WIDTH, CELL_HEIGHT}},
  221. !   {plyrrt2_bits, plyrrt2m_bits, {plyrrt2_width, plyrrt2_height}, {CELL_WIDTH, CELL_HEIGHT}},
  222. !   {plyrup1_bits, plyrup1m_bits, {plyrup1_width, plyrup1_height}, {CELL_WIDTH, CELL_HEIGHT}},
  223. !   {plyrup2_bits, plyrup2m_bits, {plyrup2_width, plyrup2_height}, {CELL_WIDTH, CELL_HEIGHT}},
  224. !   {NULL, NULL, {0, 0}, {0, 0}, SPRITE_PLAYER + 0, 2},
  225. !   {NULL, NULL, {0, 0}, {0, 0}, SPRITE_PLAYER + 1, 2},
  226. X    /*}}}*/
  227. X    /*{{{  4:player push (l, r)*/
  228. !   {NULL, NULL, {0, 0}, {0, 0}, SPRITE_PLAYER_PUSH + 2, 1},
  229. !   {NULL, NULL, {0, 0}, {0, 0}, SPRITE_PLAYER_PUSH + 3, 1},
  230. !   {plyrps1_bits, plyrps1m_bits, {plyrps1_width, plyrps1_height}, {CELL_WIDTH, CELL_HEIGHT}},
  231. !   {plyrps2_bits, plyrps2m_bits, {plyrps2_width, plyrps2_height}, {CELL_WIDTH, CELL_HEIGHT}},
  232. X    /*}}}*/
  233. X    /*{{{  2:player dead (l, r)*/
  234. !   {NULL, NULL, {0, 0}, {0, 0}, SPRITE_PLAYER + 4, 2},
  235. !   {NULL, NULL, {0, 0}, {0, 0}, SPRITE_PLAYER + 6, 2},
  236. X    /*}}}*/
  237. X    /*{{{  10:squished*/
  238. !   {NULL, NULL, {0, 0}, {0, 0}, SPRITE_SQUISHED + 1, 1},
  239. !   {normsq_bits, normsqm_bits, {normsq_width, normsq_height}, {CELL_WIDTH, CELL_HEIGHT / 4}},
  240. !   {NULL, NULL, {0, 0}, {0, 0}, SPRITE_SQUISHED + 3, 1},
  241. !   {mnchsq_bits, mnchsqm_bits, {mnchsq_width, mnchsq_height}, {CELL_WIDTH, CELL_HEIGHT / 4}},
  242. !   {NULL, NULL, {0, 0}, {0, 0}, SPRITE_SQUISHED + 5, 0},
  243. !   {xtrasq_bits, xtrasqm_bits, {xtrasq_width, xtrasq_height}, {CELL_WIDTH, CELL_HEIGHT / 4}},
  244. !   {NULL, NULL, {0, 0}, {0, 0}, SPRITE_SQUISHED + 7, 1},
  245. !   {dronsq_bits, dronsqm_bits, {dronsq_width, dronsq_height}, {CELL_WIDTH, CELL_HEIGHT / 4}},
  246. !   {NULL, NULL, {0, 0}, {0, 0}, SPRITE_SQUISHED + 9, 1},
  247. !   {plyrsq_bits, plyrsqm_bits, {plyrsq_width, plyrsq_height}, {CELL_WIDTH, CELL_HEIGHT / 4}},
  248. X    /*}}}*/
  249. X    /*{{{  2:chomp (open, closed)*/
  250. !   {chmpopn_bits, chmpopnm_bits, {chmpopn_width, chmpopn_height}, {CELL_WIDTH, CELL_HEIGHT}},
  251. !   {chmpcls_bits, chmpclsm_bits, {chmpcls_width, chmpcls_height}, {CELL_WIDTH, CELL_HEIGHT}},
  252. X    /*}}}*/
  253. X    /*{{{  8:m r i s*/
  254. !   {solidm_bits, bigm_bits, {solidm_width, solidm_height}, {CELL_WIDTH, CELL_HEIGHT}},
  255. !   {solidr_bits, bigr_bits, {solidr_width, solidr_height}, {CELL_WIDTH, CELL_HEIGHT}},
  256. !   {solidi_bits, bigi_bits, {solidi_width, solidi_height}, {CELL_WIDTH, CELL_HEIGHT}},
  257. !   {solids_bits, bigs_bits, {solids_width, solids_height}, {CELL_WIDTH, CELL_HEIGHT}},
  258. !   {shellm_bits, bigm_bits, {shellm_width, shellm_height}, {CELL_WIDTH, CELL_HEIGHT}},
  259. !   {shellr_bits, bigr_bits, {shellr_width, shellr_height}, {CELL_WIDTH, CELL_HEIGHT}},
  260. !   {shelli_bits, bigi_bits, {shelli_width, shelli_height}, {CELL_WIDTH, CELL_HEIGHT}},
  261. !   {shells_bits, bigs_bits, {shells_width, shells_height}, {CELL_WIDTH, CELL_HEIGHT}},
  262. X    /*}}}*/
  263. X    /*{{{  5:prizes*/
  264. !   {cake_bits,    cakem_bits,    {cake_width,    cake_height},    {CELL_WIDTH, CELL_HEIGHT}},
  265. !   {spanner_bits, spannerm_bits, {spanner_width, spanner_height}, {CELL_WIDTH, CELL_HEIGHT}},
  266. !   {brolly_bits,  brollym_bits,  {brolly_width,  brolly_height},  {CELL_WIDTH, CELL_HEIGHT}},
  267. !   {mushrm_bits,  mushrmm_bits,  {mushrm_width,  mushrm_height},  {CELL_WIDTH, CELL_HEIGHT}},
  268. !   {clock_bits,   clockm_bits,   {clock_width,   clock_height},   {CELL_WIDTH, CELL_HEIGHT}},
  269. X    /*}}}*/
  270. X  };
  271. X  /*}}}*/
  272. ! /*{{{  static SPRITE sprites[2] =*/
  273. X  static SPRITE spritet[2] =
  274. X  {
  275. !   {solidt_bits, bigt_bits, {solidt_width, solidt_height}, {CELL_WIDTH, CELL_HEIGHT}},
  276. !   {shellt_bits, bigt_bits, {shellt_width, shellt_height}, {CELL_WIDTH, CELL_HEIGHT}},
  277. X  };
  278. X  /*}}}*/
  279. X  /*{{{  static SPRITE icons[2] =*/
  280. X  static SPRITE icons[2] =
  281. X  {
  282. !   {NULL, mris_bits, {mris_width, mris_height}},
  283. !   {NULL, msit_bits, {msit_width, msit_height}},
  284. X  };
  285. X  /*}}}*/
  286. X  /*{{{  APPLE_SIZE const apple_sizes[6] =*/
  287. ***************
  288. *** 386,392 ****
  289. X        {(CELL_WIDTH - ROT_WIDTH) / 2, CELL_HEIGHT - ROT_HEIGHT}},
  290. X    };
  291. X  /*}}}*/
  292. ! /*{{{  BOARD const boards[10] =*/
  293. X  #if BOARDS != 10
  294. X    #error BOARDS != 10
  295. X  #endif
  296. --- 396,402 ----
  297. X        {(CELL_WIDTH - ROT_WIDTH) / 2, CELL_HEIGHT - ROT_HEIGHT}},
  298. X    };
  299. X  /*}}}*/
  300. ! /*{{{  BOARD const boards[BOARDS] =*/
  301. X  #if BOARDS != 10
  302. X    #error BOARDS != 10
  303. X  #endif
  304. ***************
  305. *** 599,605 ****
  306. X      /*}}}*/
  307. X    };
  308. X  /*}}}*/
  309. ! char keystrokes[5] = {'\'', '/', 'z', 'x', ' '};
  310. X  /*{{{  COORD const ball_hold[16] =*/
  311. X  /*{{{  held ball offsets*/
  312. X  #define PLAYER_RIGHT1_BALL_X   (plyrrt1_x_hot - CELL_WIDTH / 2)
  313. --- 609,622 ----
  314. X      /*}}}*/
  315. X    };
  316. X  /*}}}*/
  317. ! /*{{{  KeySym keystrokes[KEYS] =*/
  318. ! #if BOARDS != 10
  319. !   #error BOARDS != 10
  320. ! #endif
  321. ! KeySym keystrokes[KEYS] = 
  322. !   {KEYSYM_UP, KEYSYM_DOWN, KEYSYM_LEFT, KEYSYM_RIGHT, KEYSYM_THROW,
  323. !    KEYSYM_PAUSE, KEYSYM_QUIT, KEYSYM_ICONIZE, KEYSYM_KEY};
  324. ! /*}}}*/
  325. X  /*{{{  COORD const ball_hold[16] =*/
  326. X  /*{{{  held ball offsets*/
  327. X  #define PLAYER_RIGHT1_BALL_X   (plyrrt1_x_hot - CELL_WIDTH / 2)
  328. ***************
  329. *** 648,656 ****
  330. X    {(CELL_WIDTH + GAP_WIDTH) / 2, GAP_HEIGHT / 2},
  331. X  };
  332. X  /*}}}*/
  333. ! int const ball_dir[8] = {0, 1, 2, 1, 3, 2, 2, 1};
  334. ! /*{{{  int const player_dies[8] =*/
  335. ! int const player_dies[8] =
  336. X    {
  337. X      SPRITE_PLAYER_DEAD + 1,
  338. X      SPRITE_PLAYER + 0,
  339. --- 665,673 ----
  340. X    {(CELL_WIDTH + GAP_WIDTH) / 2, GAP_HEIGHT / 2},
  341. X  };
  342. X  /*}}}*/
  343. ! unsigned const ball_dir[8] = {0, 1, 2, 1, 3, 2, 2, 1};
  344. ! /*{{{  unsigned const player_dies[8] =*/
  345. ! unsigned const player_dies[8] =
  346. X    {
  347. X      SPRITE_PLAYER_DEAD + 1,
  348. X      SPRITE_PLAYER + 0,
  349. ***************
  350. *** 662,685 ****
  351. X      SPRITE_PLAYER_DEAD + 0,
  352. X    };
  353. X  /*}}}*/
  354. ! /*{{{  char const *title_text[] =*/
  355. ! char const *title_text[] =
  356. X    {
  357. !     "(C) 1992 Nathan Sidwell",
  358. X  #if __STDC__
  359. !     XMRISVERSION " " __DATE__, "",
  360. X  #else
  361. !     "                           ", /* should be enough space */
  362. X  #endif
  363. !     "Z - Left", "X - Right", "' - Up", "/ - Down", "Space - Throw",
  364. !     "Or use the mouse", "P - Pause", "Q - Quit",
  365. !     "Press a key or button to start", NULL
  366. X    };
  367. X  /*}}}*/
  368. X  #if SQUISH_SCORES != 7
  369. X    #error SQUISH_SCORES != 7
  370. X  #endif
  371. ! int const squish_scores[SQUISH_SCORES] = {0, 1000, 2000, 4000, 6000, 8000, 9900};
  372. X  /*}}}*/
  373. X  /*{{{  void create_resources(arc, argv)*/
  374. X  extern void create_resources FUNCARGLIST((argc, argv))
  375. --- 679,712 ----
  376. X      SPRITE_PLAYER_DEAD + 0,
  377. X    };
  378. X  /*}}}*/
  379. ! /*{{{  TITLE const title_text[] =*/
  380. ! TITLE const title_text[] =
  381. X    {
  382. !     {"(C) 1992 Nathan Sidwell"},
  383. X  #if __STDC__
  384. !     {XMRISVERSION " " DATE},
  385. X  #else
  386. !     {"                           "}, /* should be enough space */
  387. X  #endif
  388. !     {"",},
  389. !     {"Left - %s",         2},
  390. !     {"Right - %s",        3},
  391. !     {"Up - %s",           0},
  392. !     {"Down - %s",         1},
  393. !     {"Throw - %s",        KEY_THROW},
  394. !     {"Pause - %s",        KEY_PAUSE},
  395. !     {"Quit - %s",         KEY_QUIT},
  396. !     {"Iconize - %s",      KEY_ICONIZE},
  397. !     {"Map keys - %s",     KEY_KEYBOARD},
  398. !     {"Press %s to start", KEY_THROW},
  399. !     {NULL}
  400. X    };
  401. X  /*}}}*/
  402. X  #if SQUISH_SCORES != 7
  403. X    #error SQUISH_SCORES != 7
  404. X  #endif
  405. ! unsigned const squish_scores[SQUISH_SCORES] = 
  406. !   {0, 1000, 2000, 4000, 6000, 8000, 9900};
  407. X  /*}}}*/
  408. X  /*{{{  void create_resources(arc, argv)*/
  409. X  extern void create_resources FUNCARGLIST((argc, argv))
  410. ***************
  411. *** 686,697 ****
  412. X  int     argc    FUNCARGSEP
  413. X  char    **argv  FUNCARGTERM
  414. X  {
  415. -   display.display = XOpenDisplay(display.name);
  416. -   /*{{{  opened?*/
  417. -   if(!display.display)
  418. -     fatal_error("Cannot open display \"%s\"",
  419. -     display.name ? display.name : "DEFAULT", stderr);
  420. -   /*}}}*/
  421. X    /*{{{  open the display*/
  422. X    {
  423. X      display.screen = DefaultScreen(display.display);
  424. --- 713,718 ----
  425. ***************
  426. *** 740,748 ****
  427. --- 761,777 ----
  428. X    /*}}}*/
  429. X    /*{{{  get a font*/
  430. X    {
  431. +     char const *string = "09AZhy";
  432. +     int       direction;
  433. +     XCharStruct chars;
  434. +     
  435. X      font.font = XLoadFont(display.display, font.name);
  436. X      if(!font.font)
  437. X        fatal_error("Cannot load font \"%s\"", font.name);
  438. +     XQueryTextExtents(display.display, font.font, string, 6,
  439. +         &direction, &font.ascent, &font.descent, &chars);
  440. +     font.width = chars.width / 6;
  441. +     font.center = (font.ascent - font.descent) / 2;
  442. X    }
  443. X    /*}}}*/
  444. X    /*{{{  create graphics contexts*/
  445. ***************
  446. *** 788,794 ****
  447. X      XQueryColors(display.display, display.colormap, colors, 2);
  448. X      display.icon = XCreatePixmapFromBitmapData(display.display,
  449. X      display.root, icons[flags.gender].mask_bits,
  450. !     icons[flags.gender].width, icons[flags.gender].height, 1, 0, 1);
  451. X      if(!display.icon)
  452. X        fatal_error("Cannot create window icon");
  453. X      cursor = mask = 0;
  454. --- 817,823 ----
  455. X      XQueryColors(display.display, display.colormap, colors, 2);
  456. X      display.icon = XCreatePixmapFromBitmapData(display.display,
  457. X      display.root, icons[flags.gender].mask_bits,
  458. !     icons[flags.gender].size.x, icons[flags.gender].size.y, 1, 0, 1);
  459. X      if(!display.icon)
  460. X        fatal_error("Cannot create window icon");
  461. X      cursor = mask = 0;
  462. ***************
  463. *** 809,815 ****
  464. X      if(!display.cursor)
  465. X        fatal_error("Cannot create cursor icon");
  466. X      display.window = XCreateSimpleWindow(display.display, display.root,
  467. !     0, 0, hints.width, hints.height, 1, display.black, display.white);
  468. X      if(!display.window)
  469. X        fatal_error("Cannot create window");
  470. X      XSetStandardProperties(display.display, display.window,
  471. --- 838,845 ----
  472. X      if(!display.cursor)
  473. X        fatal_error("Cannot create cursor icon");
  474. X      display.window = XCreateSimpleWindow(display.display, display.root,
  475. !     0, 0, (unsigned)hints.width, (unsigned)hints.height, 
  476. !     1, display.black, display.white);
  477. X      if(!display.window)
  478. X        fatal_error("Cannot create window");
  479. X      XSetStandardProperties(display.display, display.window,
  480. ***************
  481. *** 818,824 ****
  482. X    }
  483. X    /*}}}*/
  484. X    display.back = XCreatePixmap(display.display, display.root,
  485. !       WINDOW_WIDTH, WINDOW_HEIGHT, display.depth);
  486. X    display.copy = XCreatePixmap(display.display, display.root,
  487. X        WINDOW_WIDTH, WINDOW_HEIGHT, display.depth);
  488. X    if(!display.back || !display.copy)
  489. --- 848,854 ----
  490. X    }
  491. X    /*}}}*/
  492. X    display.back = XCreatePixmap(display.display, display.root,
  493. !       WINDOW_WIDTH, WINDOW_HEIGHT, (unsigned)display.depth);
  494. X    display.copy = XCreatePixmap(display.display, display.root,
  495. X        WINDOW_WIDTH, WINDOW_HEIGHT, display.depth);
  496. X    if(!display.back || !display.copy)
  497. ***************
  498. *** 843,875 ****
  499. X      for(i = 0, sptr = sprites; i != SPRITES; i++, sptr++)
  500. X        {
  501. X      /* check that its the size we expected */
  502. !     assert((!sptr->expected.x || sptr->expected.x == sptr->width) &&
  503. !         (!sptr->expected.y || sptr->expected.y == sptr->height));
  504. X      if(sptr->mask_bits || sptr->image_bits)
  505. X        {
  506. !         assert(sptr->width && sptr->height);
  507. X          if(sptr->image_bits)
  508. X            sptr->image = XCreatePixmapFromBitmapData(display.display,
  509. X            display.root, sptr->image_bits,
  510. !           sptr->width, sptr->height,
  511. X            display.black, display.white, display.depth);
  512. X          else
  513. X            {
  514. X          sptr->image = XCreatePixmap(display.display, display.root,
  515. !             sptr->width, sptr->height, display.depth);
  516. X          if(sptr->image)
  517. X            XFillRectangle(display.display, sptr->image, GCN(GC_CLEAR),
  518. !               0, 0, sptr->width, sptr->height);
  519. X            }
  520. X          if(sptr->mask_bits && sptr->image)
  521. X            {
  522. X          sptr->mask = XCreatePixmapFromBitmapData(display.display,
  523. !             display.root, sptr->mask_bits, sptr->width, sptr->height,
  524. X              ((unsigned long)1 << display.depth) - (unsigned long)1,
  525. X              (unsigned long)0, display.depth);
  526. X          if(sptr->mask)
  527. X            XCopyArea(display.display, sptr->mask, sptr->image, GCN(GC_AND),
  528. !               0, 0, sptr->width, sptr->height, 0, 0);
  529. X            }
  530. X          if((!sptr->mask && sptr->mask_bits) || !sptr->image)
  531. X            fatal_error("Cannot create sprite %d", i);
  532. --- 873,905 ----
  533. X      for(i = 0, sptr = sprites; i != SPRITES; i++, sptr++)
  534. X        {
  535. X      /* check that its the size we expected */
  536. !     assert(!sptr->expected.x || sptr->expected.x == sptr->size.x);
  537. !     assert(!sptr->expected.y || sptr->expected.y == sptr->size.y);
  538. X      if(sptr->mask_bits || sptr->image_bits)
  539. X        {
  540. !         assert(sptr->size.x && sptr->size.y);
  541. X          if(sptr->image_bits)
  542. X            sptr->image = XCreatePixmapFromBitmapData(display.display,
  543. X            display.root, sptr->image_bits,
  544. !           sptr->size.x, sptr->size.y,
  545. X            display.black, display.white, display.depth);
  546. X          else
  547. X            {
  548. X          sptr->image = XCreatePixmap(display.display, display.root,
  549. !             sptr->size.x, sptr->size.y, display.depth);
  550. X          if(sptr->image)
  551. X            XFillRectangle(display.display, sptr->image, GCN(GC_CLEAR),
  552. !               0, 0, sptr->size.x, sptr->size.y);
  553. X            }
  554. X          if(sptr->mask_bits && sptr->image)
  555. X            {
  556. X          sptr->mask = XCreatePixmapFromBitmapData(display.display,
  557. !             display.root, sptr->mask_bits, sptr->size.x, sptr->size.y,
  558. X              ((unsigned long)1 << display.depth) - (unsigned long)1,
  559. X              (unsigned long)0, display.depth);
  560. X          if(sptr->mask)
  561. X            XCopyArea(display.display, sptr->mask, sptr->image, GCN(GC_AND),
  562. !               0, 0, sptr->size.x, sptr->size.y, 0, 0);
  563. X            }
  564. X          if((!sptr->mask && sptr->mask_bits) || !sptr->image)
  565. X            fatal_error("Cannot create sprite %d", i);
  566. ***************
  567. *** 904,912 ****
  568. X        SPRITE    *optr;
  569. X            
  570. X        optr = &sprites[sptr->copy];
  571. !       assert(optr->width && optr->height);
  572. !       sptr->width = optr->width;
  573. !       sptr->height = optr->height;
  574. X        switch(sptr->reflect)
  575. X        {
  576. X          /*{{{  case 0: (no reflections)*/
  577. --- 934,942 ----
  578. X        SPRITE    *optr;
  579. X            
  580. X        optr = &sprites[sptr->copy];
  581. !       assert(optr->size.x && optr->size.y);
  582. !       sptr->size.x = optr->size.x;
  583. !       sptr->size.y = optr->size.y;
  584. X        switch(sptr->reflect)
  585. X        {
  586. X          /*{{{  case 0: (no reflections)*/
  587. ***************
  588. *** 919,938 ****
  589. X          case 1:
  590. X          {
  591. X            int       i;
  592. !                           
  593. X            sptr->mask = XCreatePixmap(display.display, display.root,
  594. !           sptr->width, sptr->height, display.depth);
  595. X            sptr->image = XCreatePixmap(display.display, display.root,
  596. !           sptr->width, sptr->height, display.depth);
  597. X            if(sptr->image && sptr->mask)
  598. !         for(i = sptr->width; i--;)
  599. X            {
  600. X              XCopyArea(display.display, optr->mask, sptr->mask,
  601. X              GCN(GC_COPY),
  602. !             i, 0, 1, sptr->height, sptr->width - i - 1, 0);
  603. X              XCopyArea(display.display, optr->image, sptr->image,
  604. X              GCN(GC_COPY),
  605. !             i, 0, 1, sptr->height, sptr->width - i - 1, 0);
  606. X            }
  607. X            break;
  608. X          }
  609. --- 949,968 ----
  610. X          case 1:
  611. X          {
  612. X            int       i;
  613. !                                                           
  614. X            sptr->mask = XCreatePixmap(display.display, display.root,
  615. !           sptr->size.x, sptr->size.y, display.depth);
  616. X            sptr->image = XCreatePixmap(display.display, display.root,
  617. !           sptr->size.x, sptr->size.y, display.depth);
  618. X            if(sptr->image && sptr->mask)
  619. !         for(i = sptr->size.x; i--;)
  620. X            {
  621. X              XCopyArea(display.display, optr->mask, sptr->mask,
  622. X              GCN(GC_COPY),
  623. !             i, 0, 1, sptr->size.y, (int)sptr->size.x - i - 1, 0);
  624. X              XCopyArea(display.display, optr->image, sptr->image,
  625. X              GCN(GC_COPY),
  626. !             i, 0, 1, sptr->size.y, (int)sptr->size.x - i - 1, 0);
  627. X            }
  628. X            break;
  629. X          }
  630. ***************
  631. *** 941,960 ****
  632. X          case 2:
  633. X          {
  634. X            int       i;
  635. !                           
  636. X            sptr->mask = XCreatePixmap(display.display, display.root,
  637. !           sptr->width, sptr->height, display.depth);
  638. X            sptr->image = XCreatePixmap(display.display, display.root,
  639. !           sptr->width, sptr->height, display.depth);
  640. X            if(sptr->mask && sptr->image)
  641. !         for(i = sptr->width; i--;)
  642. X            {
  643. X              XCopyArea(display.display, optr->mask, sptr->mask,
  644. X              GCN(GC_COPY),
  645. !             0, i, sptr->width, 1, 0, sptr->height - i - 1);
  646. X              XCopyArea(display.display, optr->image, sptr->image,
  647. X              GCN(GC_COPY),
  648. !             0, i, sptr->width, 1, 0, sptr->height - i - 1);
  649. X            }
  650. X            break;
  651. X          }
  652. --- 971,990 ----
  653. X          case 2:
  654. X          {
  655. X            int       i;
  656. !                                                           
  657. X            sptr->mask = XCreatePixmap(display.display, display.root,
  658. !           sptr->size.x, sptr->size.y, display.depth);
  659. X            sptr->image = XCreatePixmap(display.display, display.root,
  660. !           sptr->size.x, sptr->size.y, display.depth);
  661. X            if(sptr->mask && sptr->image)
  662. !         for(i = sptr->size.x; i--;)
  663. X            {
  664. X              XCopyArea(display.display, optr->mask, sptr->mask,
  665. X              GCN(GC_COPY),
  666. !             0, i, sptr->size.x, 1, 0, (int)sptr->size.y - i - 1);
  667. X              XCopyArea(display.display, optr->image, sptr->image,
  668. X              GCN(GC_COPY),
  669. !             0, i, sptr->size.x, 1, 0, (int)sptr->size.y - i - 1);
  670. X            }
  671. X            break;
  672. X          }
  673. ***************
  674. *** 975,984 ****
  675. X      unsigned  i;
  676. X      
  677. X      for(i = sizeof(ball_hold) / sizeof(COORD); i--;)
  678. !       assert(ball_hold[i].x + CELL_WIDTH / 2 >= 0 &&
  679. !       ball_hold[i].x + CELL_WIDTH / 2 <= CELL_WIDTH - BALL_WIDTH / 2 && 
  680. !       ball_hold[i].y + CELL_HEIGHT / 2 >= 0 &&
  681. !       ball_hold[i].y + CELL_HEIGHT / 2 <= CELL_HEIGHT - BALL_HEIGHT / 2);
  682. X    }
  683. X    /*}}}*/
  684. X    /*{{{  create score pixmaps*/
  685. --- 1005,1016 ----
  686. X      unsigned  i;
  687. X      
  688. X      for(i = sizeof(ball_hold) / sizeof(COORD); i--;)
  689. !       {
  690. !     assert(ball_hold[i].x + CELL_WIDTH / 2 >= 0);
  691. !     assert(ball_hold[i].x + CELL_WIDTH / 2 <= CELL_WIDTH - BALL_WIDTH / 2);
  692. !     assert(ball_hold[i].y + CELL_HEIGHT / 2 >= 0);
  693. !     assert(ball_hold[i].y + CELL_HEIGHT / 2 <= CELL_HEIGHT - BALL_HEIGHT / 2);
  694. !       }
  695. X    }
  696. X    /*}}}*/
  697. X    /*{{{  create score pixmaps*/
  698. ***************
  699. *** 1001,1007 ****
  700. X  /*}}}*/
  701. X  /*{{{  void create_xtra_monster(index)*/
  702. X  extern void create_xtra_monster FUNCARGLIST((index))
  703. ! int   index FUNCARGTERM
  704. X  {
  705. X    SPRITE    *dptr;
  706. X    SPRITE    *sptr;
  707. --- 1033,1039 ----
  708. X  /*}}}*/
  709. X  /*{{{  void create_xtra_monster(index)*/
  710. X  extern void create_xtra_monster FUNCARGLIST((index))
  711. ! unsigned  index FUNCARGTERM
  712. X  {
  713. X    SPRITE    *dptr;
  714. X    SPRITE    *sptr;
  715. ***************
  716. *** 1016,1026 ****
  717. X        XCopyArea(display.display, sptr->image, dptr->image, GCN(GC_COPY),
  718. X        0, 0, CELL_WIDTH, CELL_HEIGHT, 0, 0);
  719. X        XCopyArea(display.display, lptr->mask, dptr->image, GCN(GC_MASK),
  720. !       index * (CELL_WIDTH / 2), 0, CELL_WIDTH / 2, CELL_HEIGHT / 2,
  721. X        XTRA_LETTER_X, XTRA_LETTER_Y);
  722. X        XCopyArea(display.display, lptr[!(extra.got & 1 << index)].image,
  723. X        dptr->image, GCN(GC_OR),
  724. !       index * (CELL_WIDTH / 2), 0, CELL_WIDTH / 2, CELL_HEIGHT / 2,
  725. X        XTRA_LETTER_X, XTRA_LETTER_Y);
  726. X      }
  727. X    return;
  728. --- 1048,1058 ----
  729. X        XCopyArea(display.display, sptr->image, dptr->image, GCN(GC_COPY),
  730. X        0, 0, CELL_WIDTH, CELL_HEIGHT, 0, 0);
  731. X        XCopyArea(display.display, lptr->mask, dptr->image, GCN(GC_MASK),
  732. !       (int)index * (CELL_WIDTH / 2), 0, CELL_WIDTH / 2, CELL_HEIGHT / 2,
  733. X        XTRA_LETTER_X, XTRA_LETTER_Y);
  734. X        XCopyArea(display.display, lptr[!(extra.got & 1 << index)].image,
  735. X        dptr->image, GCN(GC_OR),
  736. !       (int)index * (CELL_WIDTH / 2), 0, CELL_WIDTH / 2, CELL_HEIGHT / 2,
  737. X        XTRA_LETTER_X, XTRA_LETTER_Y);
  738. X      }
  739. X    return;
  740. ***************
  741. *** 1028,1034 ****
  742. X  /*}}}*/
  743. X  /*{{{  void draw_extra_letter(index)*/
  744. X  extern void draw_extra_letter FUNCARGLIST((index))
  745. ! int     index  FUNCARGTERM
  746. X  {
  747. X    SPRITE    *lptr;
  748. X    int       x;
  749. --- 1060,1066 ----
  750. X  /*}}}*/
  751. X  /*{{{  void draw_extra_letter(index)*/
  752. X  extern void draw_extra_letter FUNCARGLIST((index))
  753. ! unsigned  index  FUNCARGTERM
  754. X  {
  755. X    SPRITE    *lptr;
  756. X    int       x;
  757. ***************
  758. *** 1038,1051 ****
  759. X    XFillRectangle(display.display, display.back, GCN(GC_CLEAR),
  760. X        x, XTRA_Y, CELL_WIDTH, CELL_HEIGHT);
  761. X    XCopyArea(display.display, lptr->mask,
  762. !       display.back, GCN(GC_MASK), index * (CELL_WIDTH / 2), 0,
  763. X        CELL_WIDTH / 2, CELL_HEIGHT / 2,
  764. X        x + XTRA_LETTER_X, XTRA_Y + XTRA_LETTER_Y);
  765. X    XCopyArea(display.display, lptr[!(extra.got & 1 << index)].image,
  766. !       display.back, GCN(GC_OR), index * (CELL_WIDTH / 2), 0,
  767. X        CELL_WIDTH / 2, CELL_HEIGHT / 2,
  768. X        x + XTRA_LETTER_X, XTRA_Y + XTRA_LETTER_Y);
  769. X    add_background(x, XTRA_Y, CELL_WIDTH, CELL_HEIGHT);
  770. X    return;
  771. X  }
  772. X  /*}}}*/
  773. --- 1070,1114 ----
  774. X    XFillRectangle(display.display, display.back, GCN(GC_CLEAR),
  775. X        x, XTRA_Y, CELL_WIDTH, CELL_HEIGHT);
  776. X    XCopyArea(display.display, lptr->mask,
  777. !       display.back, GCN(GC_MASK), (int)index * (CELL_WIDTH / 2), 0,
  778. X        CELL_WIDTH / 2, CELL_HEIGHT / 2,
  779. X        x + XTRA_LETTER_X, XTRA_Y + XTRA_LETTER_Y);
  780. X    XCopyArea(display.display, lptr[!(extra.got & 1 << index)].image,
  781. !       display.back, GCN(GC_OR), (int)index * (CELL_WIDTH / 2), 0,
  782. X        CELL_WIDTH / 2, CELL_HEIGHT / 2,
  783. X        x + XTRA_LETTER_X, XTRA_Y + XTRA_LETTER_Y);
  784. X    add_background(x, XTRA_Y, CELL_WIDTH, CELL_HEIGHT);
  785. +   return;
  786. + }
  787. + /*}}}*/
  788. + /*{{{  void read_xdefaults()*/
  789. + extern void read_xdefaults FUNCARGVOID
  790. + {
  791. +   DEFAULT const *dptr;
  792. +   
  793. +   for(dptr = defaults; dptr->name; dptr++)
  794. +   {
  795. +     char    *value;
  796. +     
  797. +     value = XGetDefault(display.display, "Xmris", dptr->name);
  798. +     if(!value)
  799. +       /*EMPTY*/;
  800. +     else if(dptr->type < 0)
  801. +       {
  802. +     if(!*dptr->text)
  803. +       *dptr->text = value;
  804. +       }
  805. +     else
  806. +       {
  807. +     KeySym    symbol;
  808. +     
  809. +     symbol = XStringToKeysym(value);
  810. +     if(symbol)
  811. +       keystrokes[dptr->type] = symbol;
  812. +     else
  813. +       fprintf(stderr, "Don't understand %s key '%s'\n", dptr->name, value);
  814. +       }
  815. +   }
  816. X    return;
  817. X  }
  818. X  /*}}}*/
  819. diff -c -r exp.v1.01/demo.c exp.v2.00/demo.c
  820. *** exp.v1.01/demo.c    Fri Jul 24 09:56:04 1992
  821. --- exp.v2.00/demo.c    Fri Jul 24 13:43:12 1992
  822. ***************
  823. *** 1,28 ****
  824. ! /*{{{  (C) 1992 Nathan Sidwell*/
  825. ! /*****************************************************************************
  826. !             X M R I S V1.01
  827. !             ---------------
  828. !             (C) 1992 Nathan Sidwell
  829. ! 
  830. ! This program is copyright (C) 1992 Nathan Sidwell. This software and documentation
  831. ! is in the public domain. Permission is granted to distribute and compile
  832. ! verbatim copies of this software for non-commercial, non-profit use,
  833. ! without fee. The software may be modified, provided that both the above copyright
  834. ! notice and this permission notice appear.
  835. ! 
  836. ! No guarantee is given as to the robustness or suitability of this
  837. ! software for your computer.
  838. ! 
  839. ! Nathan Sidwell  INMOS UK |                 | nathan@inmos.co.uk       DoD#0390
  840. ! *****************************************************************************/
  841. ! /*}}}*/
  842. X  #include "xmris.h"
  843. X  /*{{{  prototypes*/
  844. X  static int demo_board PROTOARGLIST((void));
  845. X  static int demo_keys PROTOARGLIST((void));
  846. ! static int move_demo PROTOARGLIST((void));
  847. X  static void move_mris PROTOARGLIST((void));
  848. X  /*}}}*/
  849. X  /*{{{  int demo_board()*/
  850. X  static int demo_board FUNCARGVOID
  851. X  {
  852. --- 1,186 ----
  853. ! /* (C) 1992 Nathan Sidwell */
  854. X  #include "xmris.h"
  855. + #include <time.h>
  856. + #if HIGH_SCORE_FILE
  857. + #include <sys/stat.h>
  858. + #endif
  859. + #define HIGH_SCORES (CELLS_DOWN - 1)
  860. + #define NAME_LEN  64
  861. + /*{{{  typedef struct High_Score*/
  862. + typedef struct High_Score
  863. + {
  864. +   time_t    stamp;
  865. +   unsigned  score;
  866. +   unsigned  screen;
  867. +   char name[NAME_LEN + 1];
  868. + } HIGH_SCORE;
  869. + /*}}}*/
  870. + static HIGH_SCORE high_scores[HIGH_SCORES];
  871. + static HIGH_SCORE my_score;
  872. X  /*{{{  prototypes*/
  873. + static void back_mris PROTOARGLIST((unsigned));
  874. + static void back_score PROTOARGLIST((HIGH_SCORE const *, unsigned));
  875. + static int back_title PROTOARGLIST((TITLE const *, unsigned, unsigned));
  876. + static void def_keys PROTOARGLIST((void));
  877. X  static int demo_board PROTOARGLIST((void));
  878. X  static int demo_keys PROTOARGLIST((void));
  879. ! static int demo_score PROTOARGLIST((void));
  880. ! static int move_demo PROTOARGLIST((unsigned));
  881. X  static void move_mris PROTOARGLIST((void));
  882. + #if HIGH_SCORE_FILE
  883. + static unsigned file_changed PROTOARGLIST((FILE *));
  884. + static void get_lock PROTOARGLIST((FILE *));
  885. + static void get_unlock PROTOARGLIST((FILE *));
  886. + static unsigned merge_scores PROTOARGLIST((FILE *));
  887. + static void write_scores PROTOARGLIST((FILE *));
  888. + #endif
  889. X  /*}}}*/
  890. + /*{{{  void back_mris(shell)*/
  891. + static void back_mris FUNCARGLIST((shell))
  892. + unsigned  shell FUNCARGTERM
  893. + {
  894. +   unsigned  index;
  895. +   
  896. +   for(index = 4; index--;)
  897. +     {
  898. +       SPRITE    *sptr;
  899. +     
  900. +       sptr = &sprites[SPRITE_MRIS + index + 4 * !!((1 << index) & shell)];
  901. +       XCopyArea(display.display, sptr->mask, display.back, GCN(GC_MASK),
  902. +       0, 0, CELL_WIDTH, CELL_HEIGHT,
  903. +       PIXELX(4 + (int)index, 0), PIXELY(-1, 0));
  904. +       XCopyArea(display.display, sptr->image, display.back, GCN(GC_OR),
  905. +       0, 0, CELL_WIDTH, CELL_HEIGHT,
  906. +       PIXELX(4 + (int)index, 0), PIXELY(-1, 0));
  907. +     }
  908. +   return;
  909. + }
  910. + /*}}}*/
  911. + /*{{{  void back_score(sptr, index)*/
  912. + static void back_score FUNCARGLIST((sptr, index))
  913. + HIGH_SCORE const *sptr FUNCARGSEP
  914. + unsigned  index FUNCARGTERM
  915. + {
  916. +   unsigned  length;
  917. +   char      score[10];
  918. +   char      screen[5];
  919. +   COORD     place;
  920. +     
  921. +   itoa(score, sptr->score, 9);
  922. +   itoa(screen, sptr->screen, 4);
  923. +   length = strlen(sptr->name);
  924. +   place.x = PIXELX(0, 0);
  925. +   place.y = PIXELY((int)index, CELL_HEIGHT / 2) + font.center;
  926. +   XDrawImageString(display.display, display.back, GCN(GC_TEXT),
  927. +       place.x, place.y, score, 9);
  928. +   place.x += 11 * font.width;
  929. +   XDrawImageString(display.display, display.back, GCN(GC_TEXT),
  930. +       place.x, place.y, screen, 4);
  931. +   place.x += 6 * font.width;
  932. +   XDrawImageString(display.display, display.back, GCN(GC_TEXT),
  933. +       place.x, place.y, sptr->name, (int)length);
  934. +   return;
  935. + }
  936. + /*}}}*/
  937. + /*{{{  int back_title(tptr, index, flag)*/
  938. + static int back_title FUNCARGLIST((tptr, index, flag))
  939. + TITLE const *tptr FUNCARGSEP
  940. + unsigned  index   FUNCARGSEP
  941. + unsigned  flag    FUNCARGTERM
  942. + {
  943. +   char      buffer[48];
  944. +   unsigned  length;
  945. +   
  946. +   /*{{{  insert key string?*/
  947. +   {
  948. +     char  const *ptr;
  949. +     
  950. +     ptr = strchr(tptr->text, '%');
  951. +     if(!ptr)
  952. +       strcpy(buffer, tptr->text);
  953. +     else if(!flag)
  954. +       sprintf(buffer, tptr->text, 
  955. +       XKeysymToString(keystrokes[tptr->index]));
  956. +     else
  957. +       {
  958. +     strcpy(buffer, tptr->text);
  959. +     strcpy(&buffer[ptr - tptr->text], &ptr[2]);
  960. +       }
  961. +   }
  962. +   /*}}}*/
  963. +   length = strlen(buffer);
  964. +   if(length)
  965. +     {
  966. +       char  const *ptr;
  967. +       unsigned  shift;
  968. +    
  969. +       ptr = strchr(buffer, '-');
  970. +       if(ptr)
  971. +     shift = (ptr - buffer + 1) * font.width;
  972. +       else
  973. +     shift = 0;
  974. +       XDrawImageString(display.display, display.back, GCN(GC_TEXT),
  975. +       WINDOW_WIDTH / 2 - (int)(shift ? shift : length * font.width / 2),
  976. +       PIXELY((int)index, CELL_HEIGHT / 2) + font.center,
  977. +       buffer, (int)length);
  978. +     }
  979. +   return length;
  980. + }
  981. + /*}}}*/
  982. + /*{{{  void def_keys()*/
  983. + static void def_keys FUNCARGVOID
  984. + {
  985. +   unsigned  index;
  986. +   TITLE const *tptr;
  987. +   unsigned  base;
  988. +   unsigned  test;
  989. +   
  990. +   global.state = MODE_KEY_DEF;
  991. +   global.key = 0;
  992. +   monster.monsters = 0;
  993. +   apple.apples = 0;
  994. +   player.ball.state = 0;
  995. +   player.ball.count = 8;
  996. +   XFillRectangle(display.display, display.back, GCN(GC_CLEAR),
  997. +       0, 0, WINDOW_WIDTH, WINDOW_HEIGHT);
  998. +   back_mris(0);
  999. +   for(tptr = title_text, base = 0; !strchr(tptr->text, '%'); tptr++, base++)
  1000. +     back_title(tptr, base, 0);
  1001. +   test = 0;
  1002. +   for(index = 0; index < KEYS; tptr++, index++)
  1003. +     {
  1004. +       assert(tptr->text);
  1005. +       back_title(tptr, base + index, 1);
  1006. +       XCopyArea(display.display, display.back, display.copy, GCN(GC_COPY),
  1007. +       0, 0, WINDOW_WIDTH, WINDOW_HEIGHT, 0, 0);
  1008. +       refresh_window();
  1009. +       while(1)
  1010. +     {
  1011. +       unsigned  lookup;
  1012. +       KeySym    key;
  1013. +       
  1014. +       process_xevents(0);
  1015. +       key = global.key;
  1016. +       if(index != KEY_THROW && key == XK_space)
  1017. +         key = keystrokes[tptr->index];
  1018. +       for(lookup = 0; lookup != KEYS; lookup++)
  1019. +         if((test & 1 << lookup) && keystrokes[lookup] == key)
  1020. +           break;
  1021. +       if(lookup == KEYS)
  1022. +         {
  1023. +           keystrokes[tptr->index] = key;
  1024. +           test |= 1 << tptr->index;
  1025. +           break;
  1026. +         }
  1027. +     }
  1028. +       back_title(tptr, base + index, 0);
  1029. +     }
  1030. +   XCopyArea(display.display, display.back, display.copy, GCN(GC_COPY),
  1031. +       0, 0, WINDOW_WIDTH, WINDOW_HEIGHT, 0, 0);
  1032. +   refresh_window();
  1033. +   return;
  1034. + }
  1035. + /*}}}*/
  1036. X  /*{{{  int demo_board()*/
  1037. X  static int demo_board FUNCARGVOID
  1038. X  {
  1039. ***************
  1040. *** 30,35 ****
  1041. --- 188,194 ----
  1042. X    unsigned  count;
  1043. X    unsigned  quit;
  1044. X  
  1045. +   global.state = MODE_DEMO;
  1046. X    quit = 0;
  1047. X    player.screen = random() % 10;
  1048. X    extra.select = random() % 5;
  1049. ***************
  1050. *** 51,57 ****
  1051. X        unsigned  x, y;
  1052. X        unsigned  j;
  1053. X        CELL      *cptr;
  1054. !       
  1055. X        do
  1056. X      {
  1057. X        do
  1058. --- 210,216 ----
  1059. X        unsigned  x, y;
  1060. X        unsigned  j;
  1061. X        CELL      *cptr;
  1062. !     
  1063. X        do
  1064. X      {
  1065. X        do
  1066. ***************
  1067. *** 62,73 ****
  1068. X        cptr = BOARDCELL(x, y);
  1069. X      }
  1070. X        while(!cptr->visit);
  1071. !       spawn_monster(SPRITE_MRIS + count + (random() & 4), 0, 0, x, y, 0, 0);
  1072. X      }
  1073. X    /*}}}*/
  1074. X    refresh_window();
  1075. X    count = DISPLAY_HOLD;
  1076. !   den = 4;
  1077. X    timer_start(FRAME_RATE);
  1078. X    while(count)
  1079. X      {
  1080. --- 221,234 ----
  1081. X        cptr = BOARDCELL(x, y);
  1082. X      }
  1083. X        while(!cptr->visit);
  1084. !       spawn_monster(SPRITE_MRIS + count + (random() & 4), 0, 0, 
  1085. !       (int)x, (int)y, 0, 0);
  1086. X      }
  1087. X    /*}}}*/
  1088. X    refresh_window();
  1089. X    count = DISPLAY_HOLD;
  1090. !   den = 0xF;
  1091. !   monster.normals = 0;
  1092. X    timer_start(FRAME_RATE);
  1093. X    while(count)
  1094. X      {
  1095. ***************
  1096. *** 78,88 ****
  1097. X        break;
  1098. X      }
  1099. X        /*{{{  calc distances?*/
  1100. !       if(den != monster.den)
  1101. X      {
  1102. !       den = monster.den;
  1103. X        monster.list[0].cell.y = 0;
  1104. !       monster.list[0].cell.x = 4 + den;
  1105. X        calc_distances();
  1106. X        monster.list[0].cell.y = PLAYER_START_Y;
  1107. X        monster.list[0].cell.x = PLAYER_START_X;
  1108. --- 239,251 ----
  1109. X        break;
  1110. X      }
  1111. X        /*{{{  calc distances?*/
  1112. !       if(den && monster.normals != monster.monsters)
  1113. X      {
  1114. !       monster.normals = monster.monsters;
  1115. !       monster.den = choose_direction(den);
  1116. !       den ^= 1 << monster.den;
  1117. X        monster.list[0].cell.y = 0;
  1118. !       monster.list[0].cell.x = 4 + monster.den;
  1119. X        calc_distances();
  1120. X        monster.list[0].cell.y = PLAYER_START_Y;
  1121. X        monster.list[0].cell.x = PLAYER_START_X;
  1122. ***************
  1123. *** 89,95 ****
  1124. X      }
  1125. X        /*}}}*/
  1126. X        move_mris();
  1127. !       if(monster.den == 4)
  1128. X      count--;
  1129. X        if(player.button)
  1130. X      count = 0;
  1131. --- 252,258 ----
  1132. X      }
  1133. X        /*}}}*/
  1134. X        move_mris();
  1135. !       if(monster.monsters == 1)
  1136. X      count--;
  1137. X        if(player.button)
  1138. X      count = 0;
  1139. ***************
  1140. *** 106,111 ****
  1141. --- 269,275 ----
  1142. X    unsigned  quit;
  1143. X    unsigned  count;
  1144. X  
  1145. +   global.state = MODE_DEMO;
  1146. X    monster.monsters = 0;
  1147. X    apple.apples = 0;
  1148. X    player.ball.state = 0;
  1149. ***************
  1150. *** 115,140 ****
  1151. X    /*{{{  put on M R I S*/
  1152. X    {
  1153. X      unsigned  missing;
  1154. -     unsigned  index;
  1155. X      int       x, y;
  1156. !       
  1157. X      missing = random() & 3;
  1158. !     for(index = 4; index--;)
  1159. !       {
  1160. !     SPRITE    *sptr;
  1161. !       
  1162. !     sptr = &sprites[SPRITE_MRIS + index + 4 * (index == missing)];
  1163. !     XCopyArea(display.display, sptr->mask, display.back, GCN(GC_MASK),
  1164. !         0, 0, CELL_WIDTH, CELL_HEIGHT,
  1165. !         PIXELX(4 + index, 0), PIXELY(-1, 0));
  1166. !     XCopyArea(display.display, sptr->image, display.back, GCN(GC_OR),
  1167. !         0, 0, CELL_WIDTH, CELL_HEIGHT,
  1168. !         PIXELX(4 + index, 0), PIXELY(-1, 0));
  1169. !       }
  1170. X      y = random() % (CELLS_DOWN + 2) * (CELL_HEIGHT + GAP_HEIGHT);
  1171. X      x = random() & 1 ? CELLS_ACROSS * (CELL_WIDTH + GAP_WIDTH) :
  1172. X      -CELLS_ACROSS * (CELL_WIDTH + GAP_WIDTH);
  1173. !     spawn_monster(SPRITE_MRIS + missing, 0, 0, 4 + missing, -1, x, y);
  1174. X    }
  1175. X    /*}}}*/
  1176. X    XCopyArea(display.display, display.back, display.copy, GCN(GC_COPY),
  1177. --- 279,292 ----
  1178. X    /*{{{  put on M R I S*/
  1179. X    {
  1180. X      unsigned  missing;
  1181. X      int       x, y;
  1182. !     
  1183. X      missing = random() & 3;
  1184. !     back_mris((unsigned)(1 << missing));
  1185. X      y = random() % (CELLS_DOWN + 2) * (CELL_HEIGHT + GAP_HEIGHT);
  1186. X      x = random() & 1 ? CELLS_ACROSS * (CELL_WIDTH + GAP_WIDTH) :
  1187. X      -CELLS_ACROSS * (CELL_WIDTH + GAP_WIDTH);
  1188. !     spawn_monster(SPRITE_MRIS + missing, 0, 0, 4 + (int)missing, -1, x, y);
  1189. X    }
  1190. X    /*}}}*/
  1191. X    XCopyArea(display.display, display.back, display.copy, GCN(GC_COPY),
  1192. ***************
  1193. *** 141,205 ****
  1194. X        0, 0, WINDOW_WIDTH, WINDOW_HEIGHT, 0, 0);
  1195. X    /*{{{  put on the title text*/
  1196. X    {
  1197. !     char const **tptr;
  1198. !     unsigned  length;
  1199. X      unsigned  index;
  1200. X      unsigned  gnome;
  1201. !       
  1202. X      gnome = 0;
  1203. !     for(tptr = title_text, index = 0; *tptr; tptr++, index++)
  1204. !       {
  1205. !     length = strlen(*tptr);
  1206. !     if(length)
  1207. !       {
  1208. !         TEXT      info;
  1209. !         char  const *ptr;
  1210. !         unsigned  shift;
  1211. !           
  1212. !         ptr = strchr(*tptr, '-');
  1213. !         if(ptr)
  1214. !           {
  1215. !         text_size(*tptr, ptr - *tptr + 1, &info);
  1216. !         shift = info.width;
  1217. !           }
  1218. !         else
  1219. !           shift = 0;
  1220. !         text_size(*tptr, length, &info);
  1221. !         XDrawImageString(display.display, display.back, GCN(GC_TEXT),
  1222. !         WINDOW_WIDTH / 2 - (shift ? shift : info.width / 2),
  1223. !         PIXELY(index, CELL_HEIGHT / 2) +
  1224. !         (info.ascent - info.descent) / 2, *tptr, length);
  1225. !         /*{{{  spawn monster*/
  1226. X          {
  1227. !           unsigned  type;
  1228. !           int       cellx;
  1229. !           int       offsetx;
  1230. !                 
  1231. !           do
  1232. !         {
  1233. !           type = random() & 3;
  1234. !           if(type & 2)
  1235. !             type++;
  1236. !         }
  1237. !           while(type == 4 && gnome);
  1238. !           if(type == 4)
  1239. !         gnome = 1;
  1240. !           if(random() & 1)
  1241. !         {
  1242. !           cellx = -2;
  1243. !           offsetx = (CELLS_ACROSS + 2) * (CELL_WIDTH + GAP_WIDTH);
  1244. !         }
  1245. !           else
  1246. !         {
  1247. !           cellx = CELLS_ACROSS + 1;
  1248. !           offsetx = -(CELLS_ACROSS + 5) * (CELL_WIDTH + GAP_WIDTH);
  1249. !         }
  1250. !           offsetx += CELL_WIDTH * (random() & 3);
  1251. !           spawn_monster(type, 0, 0, cellx, index, offsetx, 0);
  1252. X          }
  1253. !         /*}}}*/
  1254. !       }
  1255. !       }
  1256. X    }
  1257. X    /*}}}*/
  1258. X    count = DISPLAY_HOLD;
  1259. --- 293,334 ----
  1260. X        0, 0, WINDOW_WIDTH, WINDOW_HEIGHT, 0, 0);
  1261. X    /*{{{  put on the title text*/
  1262. X    {
  1263. !     TITLE const *tptr;
  1264. X      unsigned  index;
  1265. X      unsigned  gnome;
  1266. !     
  1267. X      gnome = 0;
  1268. !     for(tptr = title_text, index = 0; tptr->text; tptr++, index++)
  1269. !       if(back_title(tptr, index, 0))
  1270. !     /*{{{  spawn monster*/
  1271. !     {
  1272. !       unsigned  type;
  1273. !       int       cellx;
  1274. !       int       offsetx;
  1275. !                                                         
  1276. !       do
  1277. X          {
  1278. !           type = random() & 3;
  1279. !           if(type & 2)
  1280. !         type++;
  1281. X          }
  1282. !       while(type == 4 && gnome);
  1283. !       if(type == 4)
  1284. !         gnome = 1;
  1285. !       if(random() & 1)
  1286. !         {
  1287. !           cellx = -2;
  1288. !           offsetx = (CELLS_ACROSS + 2) * (CELL_WIDTH + GAP_WIDTH);
  1289. !         }
  1290. !       else
  1291. !         {
  1292. !           cellx = CELLS_ACROSS + 1;
  1293. !           offsetx = -(CELLS_ACROSS + 5) * (CELL_WIDTH + GAP_WIDTH);
  1294. !         }
  1295. !       offsetx += CELL_WIDTH * (random() & 3);
  1296. !       spawn_monster(type, 0, 0, cellx, (int)index, offsetx, 0);
  1297. !     }
  1298. !     /*}}}*/
  1299. X    }
  1300. X    /*}}}*/
  1301. X    count = DISPLAY_HOLD;
  1302. ***************
  1303. *** 213,225 ****
  1304. X        player.button = 1;
  1305. X        break;
  1306. X      }
  1307. !       if(!move_demo())
  1308. X      count--;
  1309. X        if(player.button)
  1310. X      count = 0;
  1311. X        show_updates();
  1312. X        timer_wait();
  1313. !       }
  1314. X    timer_stop();
  1315. X    return quit;
  1316. X  }
  1317. --- 342,354 ----
  1318. X        player.button = 1;
  1319. X        break;
  1320. X      }
  1321. !       if(!move_demo(MONSTER_CYCLES))
  1322. X      count--;
  1323. X        if(player.button)
  1324. X      count = 0;
  1325. X        show_updates();
  1326. X        timer_wait();
  1327. !     }
  1328. X    timer_stop();
  1329. X    return quit;
  1330. X  }
  1331. ***************
  1332. *** 227,236 ****
  1333. X  /*{{{  int demo_mode()*/
  1334. X  extern int demo_mode FUNCARGVOID
  1335. X  {
  1336. X    unsigned  quit;
  1337. X  
  1338. -   global.state = 6;
  1339. -   player.keyboard = 0;
  1340. X    player.button = 0;
  1341. X    player.pressed = 0;
  1342. X    player.old_ball.state = 0;
  1343. --- 356,364 ----
  1344. X  /*{{{  int demo_mode()*/
  1345. X  extern int demo_mode FUNCARGVOID
  1346. X  {
  1347. +   static  int subsequent = 0;
  1348. X    unsigned  quit;
  1349. X  
  1350. X    player.button = 0;
  1351. X    player.pressed = 0;
  1352. X    player.old_ball.state = 0;
  1353. ***************
  1354. *** 237,251 ****
  1355. --- 365,498 ----
  1356. X    quit = 0;
  1357. X    while(!player.button)
  1358. X      {
  1359. +       if(!player.button && subsequent)
  1360. +     quit = demo_score();
  1361. +       subsequent = high_scores[0].score;
  1362. X        if(!player.button)
  1363. X      quit = demo_keys();
  1364. X        if(!player.button)
  1365. X      quit = demo_board();
  1366. +       if(player.button == 2)
  1367. +     {
  1368. +       def_keys();
  1369. +       player.button = 0;
  1370. +     }
  1371. X      }
  1372. X    player.button = 0;
  1373. X    return quit;
  1374. X  }
  1375. X  /*}}}*/
  1376. + /*{{{  int demo_score()*/
  1377. + static int demo_score FUNCARGVOID
  1378. + {
  1379. +   unsigned  quit;
  1380. +   unsigned  count;
  1381. + 
  1382. + #if HIGH_SCORE_FILE
  1383. +   if(score_file)
  1384. +     {
  1385. +       FILE    *stream;
  1386. +       
  1387. +       stream = fopen(score_file, "r+");
  1388. +       if(stream)
  1389. +     {
  1390. +       if(file_changed(stream))
  1391. +         {
  1392. +           get_lock(stream);
  1393. +           if(merge_scores(stream))
  1394. +         write_scores(stream);
  1395. +           get_unlock(stream);
  1396. +         }
  1397. +       fclose(stream);
  1398. +     }
  1399. +     }
  1400. + #endif /* HIGH_SCORE_FILE */
  1401. +   global.state = MODE_DEMO;
  1402. +   monster.monsters = 0;
  1403. +   apple.apples = 0;
  1404. +   player.ball.state = 0;
  1405. +   player.ball.count = 8;
  1406. +   XFillRectangle(display.display, display.back, GCN(GC_CLEAR),
  1407. +       0, 0, WINDOW_WIDTH, WINDOW_HEIGHT);
  1408. +   back_mris(0);
  1409. +   /*{{{  heading*/
  1410. +   {
  1411. +     char const *string = "    Score Screen Name";
  1412. +     unsigned  length;
  1413. +     
  1414. +     length = strlen(string);
  1415. +     XDrawImageString(display.display, display.back, GCN(GC_TEXT),
  1416. +     PIXELX(0, 0), PIXELY(0, CELL_HEIGHT / 2) + font.center,
  1417. +     string, (int)length);
  1418. +     if(my_score.score)
  1419. +       back_score(&my_score, CELLS_DOWN);
  1420. +   }
  1421. +   /*}}}*/
  1422. +   XCopyArea(display.display, display.back, display.copy, GCN(GC_COPY),
  1423. +       0, 0, WINDOW_WIDTH, WINDOW_HEIGHT, 0, 0);
  1424. +   /*{{{  put on the scores*/
  1425. +   {
  1426. +     HIGH_SCORE const *sptr;
  1427. +     unsigned  index;
  1428. +     
  1429. +     for(sptr = high_scores, index = 0; 
  1430. +     sptr->score && index != HIGH_SCORES; sptr++, index++)
  1431. +       back_score(sptr, 1 + index);
  1432. +     spawn_monster(4, 3, 3, 0, (int)index + 1, 
  1433. +     -2 * (CELL_WIDTH + GAP_WIDTH), 0);
  1434. +   }
  1435. +   /*}}}*/
  1436. +   count = DISPLAY_HOLD;
  1437. +   refresh_window();
  1438. +   timer_start(SCORE_RATE);
  1439. +   while(count)
  1440. +     {
  1441. +       quit = process_xevents(0);
  1442. +       if(quit)
  1443. +     {
  1444. +       player.button = 1;
  1445. +       break;
  1446. +     }
  1447. +       if(!move_demo(MONSTER_CYCLES / 2))
  1448. +     count--;
  1449. +       /*{{{  turn player?*/
  1450. +       if(monster.list[0].offset.x == 0 && 
  1451. +       monster.list[0].offset.y == 0 && monster.list[0].cell.y > 0)
  1452. +     {
  1453. +       if(monster.list[0].dir == 0)
  1454. +         {
  1455. +           if(monster.list[0].cell.x)
  1456. +         {
  1457. +           monster.list[0].cell.x = 0;
  1458. +           monster.list[0].offset.x = (CELLS_ACROSS - 1) * (CELL_WIDTH + GAP_WIDTH);
  1459. +         }
  1460. +           else
  1461. +         {
  1462. +           monster.list[0].cell.x = CELLS_ACROSS - 1;
  1463. +           monster.list[0].offset.x = -(CELLS_ACROSS - 1) * (CELL_WIDTH + GAP_WIDTH);
  1464. +         }
  1465. +         }
  1466. +       else if(monster.list[0].cell.y != 1)
  1467. +         {
  1468. +           monster.list[0].cell.y--;
  1469. +           monster.list[0].offset.y = CELL_HEIGHT + GAP_HEIGHT;
  1470. +         }
  1471. +       else
  1472. +         {
  1473. +           monster.list[0].cell.y = -2;
  1474. +           monster.list[0].offset.y = 3 * (CELL_HEIGHT + GAP_HEIGHT);
  1475. +         }
  1476. +     }
  1477. +       /*}}}*/
  1478. +       if(player.button)
  1479. +     count = 0;
  1480. +       show_updates();
  1481. +       timer_wait();
  1482. +     }
  1483. +   timer_stop();
  1484. +   return quit;
  1485. + }
  1486. + /*}}}*/
  1487. X  /*{{{  void extra_life()*/
  1488. X  extern void extra_life FUNCARGVOID
  1489. X  /* does the extra life senario */
  1490. ***************
  1491. *** 259,277 ****
  1492. X    /*{{{  display some text*/
  1493. X    {
  1494. X      unsigned  line;
  1495. -     TEXT      info;
  1496. X      char const **tptr;
  1497. X      unsigned  length;
  1498. !       
  1499. X      line = BORDER_TOP + CELL_HEIGHT;
  1500. X      for(tptr = text; *tptr; tptr++)
  1501. X        {
  1502. X      length = strlen(*tptr);
  1503. -     text_size(*tptr, length, &info);
  1504. X      XDrawImageString(display.display, display.back, GCN(GC_TEXT),
  1505. !         WINDOW_WIDTH / 2 - info.width / 2,
  1506. !         line + info.ascent, *tptr, length);
  1507. !     line += info.ascent + info.descent;
  1508. X        }
  1509. X    }
  1510. X    /*}}}*/
  1511. --- 506,522 ----
  1512. X    /*{{{  display some text*/
  1513. X    {
  1514. X      unsigned  line;
  1515. X      char const **tptr;
  1516. X      unsigned  length;
  1517. !     
  1518. X      line = BORDER_TOP + CELL_HEIGHT;
  1519. X      for(tptr = text; *tptr; tptr++)
  1520. X        {
  1521. X      length = strlen(*tptr);
  1522. X      XDrawImageString(display.display, display.back, GCN(GC_TEXT),
  1523. !         WINDOW_WIDTH / 2 - (int)(length * font.width / 2),
  1524. !         (int)line + font.ascent, *tptr, (int)length);
  1525. !     line += font.ascent + font.descent;
  1526. X        }
  1527. X    }
  1528. X    /*}}}*/
  1529. ***************
  1530. *** 283,298 ****
  1531. X    /*{{{  add m r i s*/
  1532. X    {
  1533. X      unsigned  i;
  1534. X      for(i = 4; i--;)
  1535. X        {
  1536. X      XCopyArea(display.display, sprites[SPRITE_MRIS + 4 + i].mask,
  1537. X          display.back, GCN(GC_MASK), 0, 0, CELL_WIDTH, CELL_HEIGHT,
  1538. !         PIXELX(CELLS_ACROSS / 2 - 2 + i, 0), PIXELY(2, 0));
  1539. X      XCopyArea(display.display, sprites[SPRITE_MRIS + 4 + i].image,
  1540. X          display.back, GCN(GC_OR), 0, 0, CELL_WIDTH, CELL_HEIGHT,
  1541. !         PIXELX(CELLS_ACROSS / 2 - 2 + i, 0), PIXELY(2, 0));
  1542. SHAR_EOF
  1543. true || echo 'restore of patch.v2.00 failed'
  1544. fi
  1545. echo 'End of  part 2'
  1546. echo 'File patch.v2.00 is continued in part 3'
  1547. echo 3 > _shar_seq_.tmp
  1548. exit 0
  1549. -- 
  1550. Senior Systems Scientist        mail: dcmartin@msi.com
  1551. Molecular Simulations, Inc.        uucp: uunet!dcmartin
  1552. 796 North Pastoria Avenue        at&t: 408/522-9236
  1553. Sunnyvale, California 94086        fax: 408/732-0831
  1554.