home *** CD-ROM | disk | FTP | other *** search
/ Source Code 1994 March / Source_Code_CD-ROM_Walnut_Creek_March_1994.iso / compsrcs / games / volume18 / xboing / part02 < prev    next >
Encoding:
Internet Message Format  |  1993-09-13  |  58.3 KB
  1. Path: uunet!news.tek.com!news.cna.tek.com!not-for-mail
  2. From: billr@saab.cna.tek.com (Bill Randle)
  3. Newsgroups: comp.sources.games
  4. Subject: v18i061:  xboing - blockout variant with color and sound for X, Part02/30
  5. Date: 30 Aug 1993 10:26:58 -0700
  6. Organization: Tektronix, Inc., Redmond, OR
  7. Lines: 1995
  8. Approved: billr@saab.CNA.TEK.COM
  9. Message-ID: <25td92$hst@saab.cna.tek.com>
  10. NNTP-Posting-Host: saab.cna.tek.com
  11. Xref: uunet comp.sources.games:1861
  12.  
  13. Submitted-by: jck@kimba.catt.citri.edu.au (Justin Kibell)
  14. Posting-number: Volume 18, Issue 61
  15. Archive-name: xboing/part02
  16. Environment: X11, Xlib, XPM
  17.  
  18.  
  19.  
  20. #! /bin/sh
  21. # This is a shell archive.  Remove anything before this line, then unpack
  22. # it by saving it into a file and typing "sh file".  To overwrite existing
  23. # files, type "sh file -c".  You can also feed this as standard input via
  24. # unshar, or by typing "sh <file", e.g..  If this archive is complete, you
  25. # will see the following message at the end:
  26. #        "End of archive 2 (of 30)."
  27. # Contents:  blocks.c
  28. # Wrapped by billr@saab on Mon Aug 30 09:14:22 1993
  29. PATH=/bin:/usr/bin:/usr/ucb ; export PATH
  30. if test -f 'blocks.c' -a "${1}" != "-c" ; then 
  31.   echo shar: Will not clobber existing file \"'blocks.c'\"
  32. else
  33. echo shar: Extracting \"'blocks.c'\" \(55711 characters\)
  34. sed "s/^X//" >'blocks.c' <<'END_OF_FILE'
  35. X#include "include/copyright.h"
  36. X
  37. X/*
  38. X *  Include file dependencies:
  39. X */
  40. X
  41. X#include <stdio.h>
  42. X#include <stdlib.h>
  43. X#include <stddef.h>
  44. X#include <X11/Xlib.h>
  45. X#include <X11/Xutil.h>
  46. X#include <X11/Xos.h>
  47. X#include <xpm.h>
  48. X
  49. X#include "bitmaps/blueblock.xpm"
  50. X#include "bitmaps/exblueblock1.xpm"
  51. X#include "bitmaps/exblueblock2.xpm"
  52. X#include "bitmaps/exblueblock3.xpm"
  53. X
  54. X#include "bitmaps/redblock.xpm"
  55. X#include "bitmaps/exredblock1.xpm"
  56. X#include "bitmaps/exredblock2.xpm"
  57. X#include "bitmaps/exredblock3.xpm"
  58. X
  59. X#include "bitmaps/yellowblock.xpm"
  60. X#include "bitmaps/exyellowblock1.xpm"
  61. X#include "bitmaps/exyellowblock2.xpm"
  62. X#include "bitmaps/exyellowblock3.xpm"
  63. X
  64. X#include "bitmaps/greenblock.xpm"
  65. X#include "bitmaps/exgreenblock1.xpm"
  66. X#include "bitmaps/exgreenblock2.xpm"
  67. X#include "bitmaps/exgreenblock3.xpm"
  68. X
  69. X#include "bitmaps/tanblock.xpm"
  70. X#include "bitmaps/extanblock1.xpm"
  71. X#include "bitmaps/extanblock2.xpm"
  72. X#include "bitmaps/extanblock3.xpm"
  73. X
  74. X#include "bitmaps/purpleblock.xpm"
  75. X#include "bitmaps/expurpleblock1.xpm"
  76. X#include "bitmaps/expurpleblock2.xpm"
  77. X#include "bitmaps/expurpleblock3.xpm"
  78. X
  79. X#include "bitmaps/bombblock.xpm"
  80. X#include "bitmaps/exbombblock1.xpm"
  81. X#include "bitmaps/exbombblock2.xpm"
  82. X#include "bitmaps/exbombblock3.xpm"
  83. X
  84. X#include "bitmaps/counterblock1.xpm"
  85. X#include "bitmaps/counterblock2.xpm"
  86. X#include "bitmaps/counterblock3.xpm"
  87. X#include "bitmaps/counterblock4.xpm"
  88. X#include "bitmaps/counterblock5.xpm"
  89. X#include "bitmaps/counterblock.xpm"
  90. X#include "bitmaps/excounterblock1.xpm"
  91. X#include "bitmaps/excounterblock2.xpm"
  92. X#include "bitmaps/excounterblock3.xpm"
  93. X
  94. X#include "bitmaps/blackblock.xpm"
  95. X#include "bitmaps/reverse.xpm"
  96. X#include "bitmaps/hyperspace.xpm"
  97. X#include "bitmaps/machinegun.xpm"
  98. X#include "bitmaps/walloff.xpm"
  99. X#include "bitmaps/multiballblock.xpm"
  100. X#include "bitmaps/stickyblock.xpm"
  101. X#include "bitmaps/paddleshrink.xpm"
  102. X#include "bitmaps/paddleexpand.xpm"
  103. X
  104. X#include "bitmaps/xtraball.xpm"
  105. X#include "bitmaps/xtraball2.xpm"
  106. X
  107. X#include "bitmaps/x2bonus1.xpm"
  108. X#include "bitmaps/x2bonus2.xpm"
  109. X#include "bitmaps/x2bonus3.xpm"
  110. X#include "bitmaps/x2bonus4.xpm"
  111. X
  112. X#include "bitmaps/x4bonus1.xpm"
  113. X#include "bitmaps/x4bonus2.xpm"
  114. X#include "bitmaps/x4bonus3.xpm"
  115. X#include "bitmaps/x4bonus4.xpm"
  116. X
  117. X#include "bitmaps/bonus1.xpm"
  118. X#include "bitmaps/bonus2.xpm"
  119. X#include "bitmaps/bonus3.xpm"
  120. X#include "bitmaps/bonus4.xpm"
  121. X
  122. X#include "bitmaps/exx2bonus1.xpm"
  123. X#include "bitmaps/exx2bonus2.xpm"
  124. X#include "bitmaps/exx2bonus3.xpm"
  125. X
  126. X#include "bitmaps/death1.xpm"
  127. X#include "bitmaps/death2.xpm"
  128. X#include "bitmaps/death3.xpm"
  129. X#include "bitmaps/death4.xpm"
  130. X#include "bitmaps/death5.xpm"
  131. X
  132. X#include "bitmaps/exdeath1.xpm"
  133. X#include "bitmaps/exdeath2.xpm"
  134. X#include "bitmaps/exdeath3.xpm"
  135. X#include "bitmaps/exdeath4.xpm"
  136. X
  137. X#include "include/audio.h"
  138. X#include "include/misc.h"
  139. X#include "include/mess.h"
  140. X#include "include/gun.h"
  141. X#include "include/error.h"
  142. X#include "include/bonus.h"
  143. X#include "include/special.h"
  144. X#include "include/main.h"
  145. X#include "include/init.h"
  146. X#include "include/stage.h"
  147. X#include "include/ball.h"
  148. X#include "include/score.h"
  149. X#include "include/paddle.h"
  150. X#include "include/level.h"
  151. X#include "include/sfx.h"
  152. X
  153. X#include "include/blocks.h"
  154. X
  155. X/*
  156. X *  Internal macro definitions:
  157. X */
  158. X
  159. X#define EXPLODE_DELAY                10    
  160. X#define BONUS_DELAY                    150    
  161. X#define BONUS_LENGTH                2000
  162. X#define NUMBER_OF_BULLETS_NEW_LEVEL 4
  163. X#define DEATH_DELAY1                100
  164. X#define DEATH_DELAY2                700
  165. X#define EXTRABALL_DELAY                300
  166. X#define RANDOM_DELAY                500
  167. X
  168. X/*
  169. X *  Internal type declarations:
  170. X */
  171. X
  172. X#if NeedFunctionPrototypes
  173. Xstatic void ClearBlock(int row, int col);
  174. Xstatic void CalculateBlockGeometry(int row, int col);
  175. Xstatic void SetBlockUpForExplosion(int row, int col, int frame);
  176. X#else
  177. Xstatic void SetBlockUpForExplosion();
  178. Xstatic void ClearBlock();
  179. Xstatic void CalculateBlockGeometry();
  180. X#endif
  181. X
  182. X/*
  183. X *  Internal variable declarations:
  184. X */
  185. X
  186. Xstatic Pixmap    exredblock[3],        exredblockM[3];
  187. Xstatic Pixmap    extanblock[3],        extanblockM[3];
  188. Xstatic Pixmap    exyellowblock[3],    exyellowblockM[3];
  189. Xstatic Pixmap    exgreenblock[3],    exgreenblockM[3];
  190. Xstatic Pixmap    exblueblock[3],        exblueblockM[3];
  191. Xstatic Pixmap    expurpleblock[3],    expurpleblockM[3];
  192. Xstatic Pixmap    exbombblock[3],        exbombblockM[3];
  193. Xstatic Pixmap    excounterblock[3],    excounterblockM[3];
  194. Xstatic Pixmap    exx2bonus[3],        exx2bonusM[3];
  195. Xstatic Pixmap    x2bonus[4],            x2bonusM[4];
  196. Xstatic Pixmap    x4bonus[4],            x4bonusM[4];
  197. Xstatic Pixmap    Bonus[4],            BonusM[4];
  198. Xstatic Pixmap    death[5],            deathM[5];
  199. Xstatic Pixmap    exdeath[5],            exdeathM[5];
  200. Xstatic Pixmap    counterblock[6],    counterblockM[6];
  201. Xstatic Pixmap    extraball[3],        extraballM[3];
  202. X
  203. Xstatic Pixmap    redblock, greenblock, blueblock, yellowblock, purpleblock;    
  204. Xstatic Pixmap    tanblock, blackblock, bombblock, revblock,     hyperblock;
  205. Xstatic Pixmap    mgunblock, walloffblock, multiball, sticky, paddleshrink;
  206. Xstatic Pixmap    paddleexpand;
  207. X
  208. Xstatic Pixmap    redblockM, greenblockM, blueblockM, yellowblockM, purpleblockM;    
  209. Xstatic Pixmap    tanblockM, blackblockM, bombblockM, revblockM,     hyperblockM;
  210. Xstatic Pixmap    mgunblockM, walloffblockM, multiballM, stickyM, paddleshrinkM;
  211. Xstatic Pixmap    paddleexpandM;
  212. X
  213. Xstruct aBlock     blocks[MAX_ROW][MAX_COL];
  214. Xint            blocksExploding = 0;
  215. Xint            rowHeight;
  216. Xint            colWidth;
  217. X
  218. X#if NeedFunctionPrototypes
  219. Xvoid InitialiseBlocks(Display *display, Window window, Colormap colormap)
  220. X#else
  221. Xvoid InitialiseBlocks(display, window, colormap)
  222. X    Display *display;
  223. X    Window window;
  224. X    Colormap colormap;
  225. X#endif
  226. X{
  227. X    XpmAttributes   attributes;
  228. X    int             XpmErrorStatus;
  229. X
  230. X    attributes.valuemask = XpmColormap;
  231. X    attributes.colormap = colormap;
  232. X
  233. X    /* Create all xpm pixmap blocks from the files */
  234. X    XpmErrorStatus = XpmCreatePixmapFromData(display, window, redblock_xpm, 
  235. X        &redblock, &redblockM, &attributes);
  236. X    HandleXPMError(display, XpmErrorStatus, "InitialiseBlocks(red)");
  237. X
  238. X    XpmErrorStatus = XpmCreatePixmapFromData(display, window, blueblock_xpm, 
  239. X        &blueblock, &blueblockM, &attributes);
  240. X    HandleXPMError(display, XpmErrorStatus, "InitialiseBlocks(blue)");
  241. X
  242. X    XpmErrorStatus = XpmCreatePixmapFromData(display, window, greenblock_xpm, 
  243. X        &greenblock, &greenblockM, &attributes);
  244. X    HandleXPMError(display, XpmErrorStatus, "InitialiseBlocks(green)");
  245. X
  246. X    XpmErrorStatus = XpmCreatePixmapFromData(display, window, yellowblock_xpm, 
  247. X        &yellowblock, &yellowblockM, &attributes);
  248. X    HandleXPMError(display, XpmErrorStatus, "InitialiseBlocks(yellow)");
  249. X
  250. X    XpmErrorStatus = XpmCreatePixmapFromData(display, window, tanblock_xpm, 
  251. X        &tanblock, &tanblockM, &attributes);
  252. X    HandleXPMError(display, XpmErrorStatus, "InitialiseBlocks(tan)");
  253. X
  254. X    XpmErrorStatus = XpmCreatePixmapFromData(display, window, purpleblock_xpm, 
  255. X        &purpleblock, &purpleblockM, &attributes);
  256. X    HandleXPMError(display, XpmErrorStatus, "InitialiseBlocks(purple)");
  257. X
  258. X    XpmErrorStatus = XpmCreatePixmapFromData(display, window, blackblock_xpm, 
  259. X        &blackblock, &blackblockM, &attributes);
  260. X    HandleXPMError(display, XpmErrorStatus, "InitialiseBlocks(wall)");
  261. X
  262. X    XpmErrorStatus = XpmCreatePixmapFromData(display, window, bombblock_xpm, 
  263. X        &bombblock, &bombblockM, &attributes);
  264. X    HandleXPMError(display, XpmErrorStatus, "InitialiseBlocks(bomb)");
  265. X
  266. X    XpmErrorStatus = XpmCreatePixmapFromData(display, window, reverse_xpm, 
  267. X        &revblock, &revblockM, &attributes);
  268. X    HandleXPMError(display, XpmErrorStatus, "InitialiseBlocks(reverse)");
  269. X
  270. X    XpmErrorStatus = XpmCreatePixmapFromData(display, window, hyperspace_xpm, 
  271. X        &hyperblock, &hyperblockM, &attributes);
  272. X    HandleXPMError(display, XpmErrorStatus, "InitialiseBlocks(hyperspace)");
  273. X
  274. X    XpmErrorStatus = XpmCreatePixmapFromData(display, window, machinegun_xpm, 
  275. X        &mgunblock, &mgunblockM, &attributes);
  276. X    HandleXPMError(display, XpmErrorStatus, "InitialiseBlocks(machinegun)");
  277. X
  278. X    XpmErrorStatus = XpmCreatePixmapFromData(display, window, walloff_xpm, 
  279. X        &walloffblock, &walloffblockM, &attributes);
  280. X    HandleXPMError(display, XpmErrorStatus, "InitialiseBlocks(walloff)");
  281. X
  282. X    /* Explosion for yellow block */
  283. X
  284. X    XpmErrorStatus = XpmCreatePixmapFromData(display, window, 
  285. X        exyellowblock1_xpm, &exyellowblock[0], &exyellowblockM[0], 
  286. X        &attributes);
  287. X    HandleXPMError(display, XpmErrorStatus, "InitialiseBlocks(exyellow)");
  288. X
  289. X    XpmErrorStatus = XpmCreatePixmapFromData(display, window, 
  290. X        exyellowblock2_xpm, &exyellowblock[1], &exyellowblockM[1], 
  291. X        &attributes);
  292. X    HandleXPMError(display, XpmErrorStatus, "InitialiseBlocks(exyellow)");
  293. X
  294. X    XpmErrorStatus = XpmCreatePixmapFromData(display, window, 
  295. X        exyellowblock3_xpm, &exyellowblock[2], &exyellowblockM[2], 
  296. X        &attributes);
  297. X    HandleXPMError(display, XpmErrorStatus, "InitialiseBlocks(exyellow)");
  298. X
  299. X    /* Explosion for red block */
  300. X
  301. X    XpmErrorStatus = XpmCreatePixmapFromData(display, window, exredblock1_xpm, 
  302. X        &exredblock[0], &exredblockM[0], &attributes);
  303. X    HandleXPMError(display, XpmErrorStatus, "InitialiseBlocks(exred)");
  304. X
  305. X    XpmErrorStatus = XpmCreatePixmapFromData(display, window, exredblock2_xpm, 
  306. X        &exredblock[1], &exredblockM[1], &attributes);
  307. X    HandleXPMError(display, XpmErrorStatus, "InitialiseBlocks(exred)");
  308. X
  309. X    XpmErrorStatus = XpmCreatePixmapFromData(display, window, exredblock3_xpm, 
  310. X        &exredblock[2], &exredblockM[2], &attributes);
  311. X    HandleXPMError(display, XpmErrorStatus, "InitialiseBlocks(exred)");
  312. X
  313. X    /* Explosion for green block */
  314. X
  315. X    XpmErrorStatus = XpmCreatePixmapFromData(display, window, 
  316. X        exgreenblock1_xpm, &exgreenblock[0], &exgreenblockM[0], &attributes);
  317. X    HandleXPMError(display, XpmErrorStatus, "InitialiseBlocks(exgreen)");
  318. X
  319. X    XpmErrorStatus = XpmCreatePixmapFromData(display, window, 
  320. X        exgreenblock2_xpm, &exgreenblock[1], &exgreenblockM[1], &attributes);
  321. X    HandleXPMError(display, XpmErrorStatus, "InitialiseBlocks(exgreen)");
  322. X
  323. X    XpmErrorStatus = XpmCreatePixmapFromData(display, window, 
  324. X        exgreenblock3_xpm, &exgreenblock[2], &exgreenblockM[2], &attributes);
  325. X    HandleXPMError(display, XpmErrorStatus, "InitialiseBlocks(exgreen)");
  326. X
  327. X    /* Explosion for blue block */
  328. X
  329. X    XpmErrorStatus = XpmCreatePixmapFromData(display, window, 
  330. X        exblueblock1_xpm, &exblueblock[0], &exblueblockM[0], &attributes);
  331. X    HandleXPMError(display, XpmErrorStatus, "InitialiseBlocks(exblue)");
  332. X
  333. X    XpmErrorStatus = XpmCreatePixmapFromData(display, window, 
  334. X        exblueblock2_xpm, &exblueblock[1], &exblueblockM[1], &attributes);
  335. X    HandleXPMError(display, XpmErrorStatus, "InitialiseBlocks(exblue)");
  336. X
  337. X    XpmErrorStatus = XpmCreatePixmapFromData(display, window, 
  338. X        exblueblock3_xpm, &exblueblock[2], &exblueblockM[2], &attributes);
  339. X    HandleXPMError(display, XpmErrorStatus, "InitialiseBlocks(exblue)");
  340. X
  341. X    /* Explosion for tan block */
  342. X
  343. X    XpmErrorStatus = XpmCreatePixmapFromData(display, window, 
  344. X        extanblock1_xpm, &extanblock[0], &extanblockM[0], &attributes);
  345. X    HandleXPMError(display, XpmErrorStatus, "InitialiseBlocks(extan)");
  346. X
  347. X    XpmErrorStatus = XpmCreatePixmapFromData(display, window, 
  348. X        extanblock2_xpm, &extanblock[1], &extanblockM[1], &attributes);
  349. X    HandleXPMError(display, XpmErrorStatus, "InitialiseBlocks(extan)");
  350. X
  351. X    XpmErrorStatus = XpmCreatePixmapFromData(display, window, 
  352. X        extanblock3_xpm, &extanblock[2], &extanblockM[2], &attributes);
  353. X    HandleXPMError(display, XpmErrorStatus, "InitialiseBlocks(extan)");
  354. X
  355. X    /* Explosion for purple block */
  356. X
  357. X    XpmErrorStatus = XpmCreatePixmapFromData(display, window, 
  358. X        expurpleblock1_xpm, &expurpleblock[0], &expurpleblockM[0], 
  359. X        &attributes);
  360. X    HandleXPMError(display, XpmErrorStatus, "InitialiseBlocks(expurple)");
  361. X
  362. X    XpmErrorStatus = XpmCreatePixmapFromData(display, window, 
  363. X        expurpleblock2_xpm, &expurpleblock[1], &expurpleblockM[1], 
  364. X        &attributes);
  365. X    HandleXPMError(display, XpmErrorStatus, "InitialiseBlocks(expurple)");
  366. X
  367. X    XpmErrorStatus = XpmCreatePixmapFromData(display, window, 
  368. X        expurpleblock3_xpm, &expurpleblock[2], &expurpleblockM[2], 
  369. X        &attributes);
  370. X    HandleXPMError(display, XpmErrorStatus, "InitialiseBlocks(expurple)");
  371. X
  372. X    /* Explosion for bomb block */
  373. X
  374. X    XpmErrorStatus = XpmCreatePixmapFromData(display, window, 
  375. X        exbombblock1_xpm, &exbombblock[0], &exbombblockM[0], &attributes);
  376. X    HandleXPMError(display, XpmErrorStatus, "InitialiseBlocks(exbomb)");
  377. X
  378. X    XpmErrorStatus = XpmCreatePixmapFromData(display, window, 
  379. X        exbombblock2_xpm, &exbombblock[1], &exbombblockM[1], &attributes);
  380. X    HandleXPMError(display, XpmErrorStatus, "InitialiseBlocks(exbomb)");
  381. X
  382. X    XpmErrorStatus = XpmCreatePixmapFromData(display, window, 
  383. X        exbombblock3_xpm, &exbombblock[2], &exbombblockM[2], &attributes);
  384. X    HandleXPMError(display, XpmErrorStatus, "InitialiseBlocks(exbomb)");
  385. X
  386. X    /* Explosion for counter block */
  387. X
  388. X    XpmErrorStatus = XpmCreatePixmapFromData(display, window, 
  389. X        excounterblock1_xpm, &excounterblock[0], &excounterblockM[0], 
  390. X        &attributes);
  391. X    HandleXPMError(display, XpmErrorStatus, "InitialiseBlocks(excounter)");
  392. X
  393. X    XpmErrorStatus = XpmCreatePixmapFromData(display, window, 
  394. X        excounterblock2_xpm, &excounterblock[1], &excounterblockM[1], 
  395. X        &attributes);
  396. X    HandleXPMError(display, XpmErrorStatus, "InitialiseBlocks(excounter)");
  397. X
  398. X    XpmErrorStatus = XpmCreatePixmapFromData(display, window, 
  399. X        excounterblock3_xpm, &excounterblock[2], &excounterblockM[2], 
  400. X        &attributes);
  401. X    HandleXPMError(display, XpmErrorStatus, "InitialiseBlocks(excounter)");
  402. X
  403. X    /* countdown for counter block */
  404. X
  405. X    XpmErrorStatus = XpmCreatePixmapFromData(display, window, 
  406. X        counterblock_xpm, &counterblock[0], &counterblockM[0], 
  407. X        &attributes);
  408. X    HandleXPMError(display, XpmErrorStatus, "InitialiseBlocks(counter0)");
  409. X
  410. X    XpmErrorStatus = XpmCreatePixmapFromData(display, window, 
  411. X        counterblock1_xpm, &counterblock[1], &counterblockM[1], 
  412. X        &attributes);
  413. X    HandleXPMError(display, XpmErrorStatus, "InitialiseBlocks(counter1)");
  414. X
  415. X    XpmErrorStatus = XpmCreatePixmapFromData(display, window, 
  416. X        counterblock2_xpm, &counterblock[2], &counterblockM[2], 
  417. X        &attributes);
  418. X    HandleXPMError(display, XpmErrorStatus, "InitialiseBlocks(counter2)");
  419. X
  420. X    XpmErrorStatus = XpmCreatePixmapFromData(display, window, 
  421. X        counterblock3_xpm, &counterblock[3], &counterblockM[3], 
  422. X        &attributes);
  423. X    HandleXPMError(display, XpmErrorStatus, "InitialiseBlocks(counter3)");
  424. X
  425. X    XpmErrorStatus = XpmCreatePixmapFromData(display, window, 
  426. X        counterblock4_xpm, &counterblock[4], &counterblockM[4], 
  427. X        &attributes);
  428. X    HandleXPMError(display, XpmErrorStatus, "InitialiseBlocks(counter4)");
  429. X
  430. X    XpmErrorStatus = XpmCreatePixmapFromData(display, window, 
  431. X        counterblock5_xpm, &counterblock[5], &counterblockM[5], 
  432. X        &attributes);
  433. X    HandleXPMError(display, XpmErrorStatus, "InitialiseBlocks(counter5)");
  434. X
  435. X    /* Bonus block stuff */
  436. X
  437. X    XpmErrorStatus = XpmCreatePixmapFromData(display, window, 
  438. X        x2bonus1_xpm, &x2bonus[0], &x2bonusM[0], &attributes);
  439. X    HandleXPMError(display, XpmErrorStatus, "InitialiseBlocks(x2bonus1)");
  440. X
  441. X    XpmErrorStatus = XpmCreatePixmapFromData(display, window, 
  442. X        x2bonus2_xpm, &x2bonus[1], &x2bonusM[1], &attributes);
  443. X    HandleXPMError(display, XpmErrorStatus, "InitialiseBlocks(x2bonus2)");
  444. X
  445. X    XpmErrorStatus = XpmCreatePixmapFromData(display, window, 
  446. X        x2bonus3_xpm, &x2bonus[2], &x2bonusM[2], &attributes);
  447. X    HandleXPMError(display, XpmErrorStatus, "InitialiseBlocks(x2bonus3)");
  448. X
  449. X    XpmErrorStatus = XpmCreatePixmapFromData(display, window, 
  450. X        x2bonus4_xpm, &x2bonus[3], &x2bonusM[3], &attributes);
  451. X    HandleXPMError(display, XpmErrorStatus, "InitialiseBlocks(x2bonus4)");
  452. X
  453. X
  454. X    XpmErrorStatus = XpmCreatePixmapFromData(display, window, 
  455. X        x4bonus1_xpm, &x4bonus[0], &x4bonusM[0], &attributes);
  456. X    HandleXPMError(display, XpmErrorStatus, "InitialiseBlocks(x4bonus1)");
  457. X
  458. X    XpmErrorStatus = XpmCreatePixmapFromData(display, window, 
  459. X        x4bonus2_xpm, &x4bonus[1], &x4bonusM[1], &attributes);
  460. X    HandleXPMError(display, XpmErrorStatus, "InitialiseBlocks(x4bonus2)");
  461. X
  462. X    XpmErrorStatus = XpmCreatePixmapFromData(display, window, 
  463. X        x4bonus3_xpm, &x4bonus[2], &x4bonusM[2], &attributes);
  464. X    HandleXPMError(display, XpmErrorStatus, "InitialiseBlocks(x4bonus3)");
  465. X
  466. X    XpmErrorStatus = XpmCreatePixmapFromData(display, window, 
  467. X        x4bonus4_xpm, &x4bonus[3], &x4bonusM[3], &attributes);
  468. X    HandleXPMError(display, XpmErrorStatus, "InitialiseBlocks(x4bonus4)");
  469. X
  470. X
  471. X    XpmErrorStatus = XpmCreatePixmapFromData(display, window, 
  472. X        bonus1_xpm, &Bonus[0], &BonusM[0], &attributes);
  473. X    HandleXPMError(display, XpmErrorStatus, "InitialiseBlocks(bonus1)");
  474. X
  475. X    XpmErrorStatus = XpmCreatePixmapFromData(display, window, 
  476. X        bonus2_xpm, &Bonus[1], &BonusM[1], &attributes);
  477. X    HandleXPMError(display, XpmErrorStatus, "InitialiseBlocks(bonus2)");
  478. X
  479. X    XpmErrorStatus = XpmCreatePixmapFromData(display, window, 
  480. X        bonus3_xpm, &Bonus[2], &BonusM[2], &attributes);
  481. X    HandleXPMError(display, XpmErrorStatus, "InitialiseBlocks(bonus3)");
  482. X
  483. X    XpmErrorStatus = XpmCreatePixmapFromData(display, window, 
  484. X        bonus4_xpm, &Bonus[3], &BonusM[3], &attributes);
  485. X    HandleXPMError(display, XpmErrorStatus, "InitialiseBlocks(bonus4)");
  486. X
  487. X
  488. X    XpmErrorStatus = XpmCreatePixmapFromData(display, window, 
  489. X        exx2bonus1_xpm, &exx2bonus[0], &exx2bonusM[0], &attributes);
  490. X    HandleXPMError(display, XpmErrorStatus, "InitialiseBlocks(exbonus)");
  491. X
  492. X    XpmErrorStatus = XpmCreatePixmapFromData(display, window, 
  493. X        exx2bonus2_xpm, &exx2bonus[1], &exx2bonusM[1], &attributes);
  494. X    HandleXPMError(display, XpmErrorStatus, "InitialiseBlocks(exbonus)");
  495. X
  496. X    XpmErrorStatus = XpmCreatePixmapFromData(display, window, 
  497. X        exx2bonus3_xpm, &exx2bonus[2], &exx2bonusM[2], &attributes);
  498. X    HandleXPMError(display, XpmErrorStatus, "InitialiseBlocks(exbonus)");
  499. X
  500. X    /* Death block initialisation */
  501. X
  502. X    XpmErrorStatus = XpmCreatePixmapFromData(display, window, 
  503. X        death1_xpm, &death[0], &deathM[0], &attributes);
  504. X    HandleXPMError(display, XpmErrorStatus, "InitialiseBlocks(death)");
  505. X
  506. X    XpmErrorStatus = XpmCreatePixmapFromData(display, window, 
  507. X        death2_xpm, &death[1], &deathM[1], &attributes);
  508. X    HandleXPMError(display, XpmErrorStatus, "InitialiseBlocks(death)");
  509. X
  510. X    XpmErrorStatus = XpmCreatePixmapFromData(display, window, 
  511. X        death3_xpm, &death[2], &deathM[2], &attributes);
  512. X    HandleXPMError(display, XpmErrorStatus, "InitialiseBlocks(death)");
  513. X
  514. X    XpmErrorStatus = XpmCreatePixmapFromData(display, window, 
  515. X        death4_xpm, &death[3], &deathM[3], &attributes);
  516. X    HandleXPMError(display, XpmErrorStatus, "InitialiseBlocks(death)");
  517. X
  518. X    XpmErrorStatus = XpmCreatePixmapFromData(display, window, 
  519. X        death5_xpm, &death[4], &deathM[4], &attributes);
  520. X    HandleXPMError(display, XpmErrorStatus, "InitialiseBlocks(death)");
  521. X
  522. X    /* Death block explosion init */
  523. X
  524. X    XpmErrorStatus = XpmCreatePixmapFromData(display, window, 
  525. X        exdeath1_xpm, &exdeath[0], &exdeathM[0], &attributes);
  526. X    HandleXPMError(display, XpmErrorStatus, "InitialiseBlocks(exdeath)");
  527. X
  528. X    XpmErrorStatus = XpmCreatePixmapFromData(display, window, 
  529. X        exdeath2_xpm, &exdeath[1], &exdeathM[1], &attributes);
  530. X    HandleXPMError(display, XpmErrorStatus, "InitialiseBlocks(exdeath)");
  531. X
  532. X    XpmErrorStatus = XpmCreatePixmapFromData(display, window, 
  533. X        exdeath3_xpm, &exdeath[2], &exdeathM[2], &attributes);
  534. X    HandleXPMError(display, XpmErrorStatus, "InitialiseBlocks(exdeath)");
  535. X
  536. X    XpmErrorStatus = XpmCreatePixmapFromData(display, window, 
  537. X        exdeath4_xpm, &exdeath[3], &exdeathM[3], &attributes);
  538. X    HandleXPMError(display, XpmErrorStatus, "InitialiseBlocks(exdeath)");
  539. X
  540. X    /* Extra balll pixmaps */
  541. X
  542. X    XpmErrorStatus = XpmCreatePixmapFromData(display, window, 
  543. X        xtraball_xpm, &extraball[0], &extraballM[0], &attributes);
  544. X    HandleXPMError(display, XpmErrorStatus, "InitialiseBlocks(extraball)");
  545. X
  546. X    XpmErrorStatus = XpmCreatePixmapFromData(display, window, 
  547. X        xtraball2_xpm, &extraball[1], &extraballM[1], &attributes);
  548. X    HandleXPMError(display, XpmErrorStatus, "InitialiseBlocks(extraball)");
  549. X
  550. X    /* Multiple ball pixmap */
  551. X
  552. X    XpmErrorStatus = XpmCreatePixmapFromData(display, window, 
  553. X        multiballblock_xpm, &multiball, &multiballM, &attributes);
  554. X    HandleXPMError(display, XpmErrorStatus, "InitialiseBlocks(multiball)");
  555. X
  556. X    /* Sticky block */
  557. X
  558. X    XpmErrorStatus = XpmCreatePixmapFromData(display, window, 
  559. X        stickyblock_xpm, &sticky, &stickyM, &attributes);
  560. X    HandleXPMError(display, XpmErrorStatus, "InitialiseBlocks(sticky)");
  561. X
  562. X    /* paddle shrink and expand block */
  563. X
  564. X    XpmErrorStatus = XpmCreatePixmapFromData(display, window, 
  565. X        paddleshrink_xpm, &paddleshrink, &paddleshrinkM, &attributes);
  566. X    HandleXPMError(display, XpmErrorStatus, "InitialiseBlocks(paddleshrink)");
  567. X
  568. X    XpmErrorStatus = XpmCreatePixmapFromData(display, window, 
  569. X        paddleexpand_xpm, &paddleexpand, &paddleexpandM, &attributes);
  570. X    HandleXPMError(display, XpmErrorStatus, "InitialiseBlocks(paddleexpand)");
  571. X
  572. X    /* Free the xpm pixmap attributes */
  573. X    XpmFreeAttributes(&attributes);
  574. X}
  575. X
  576. X#if NeedFunctionPrototypes
  577. Xvoid PlaySoundForBlock(int type)
  578. X#else
  579. Xvoid PlaySoundForBlock(type)
  580. X    int type;
  581. X#endif
  582. X{
  583. X    /* If no sound the no sound */
  584. X    if (noSound == True) return;
  585. X
  586. X    /* Play the sound effect for the block being hit */
  587. X    switch (type)
  588. X    {
  589. X        case BOMB_BLK:        
  590. X            playSoundFile("bomb", 50);
  591. X            break;
  592. X
  593. X        case BULLET_BLK:
  594. X            playSoundFile("ammo", 50);
  595. X            break;
  596. X
  597. X        case RED_BLK:
  598. X        case GREEN_BLK:        
  599. X        case BLUE_BLK:    
  600. X        case TAN_BLK:
  601. X        case PURPLE_BLK:    
  602. X        case YELLOW_BLK:
  603. X        case COUNTER_BLK:
  604. X        case RANDOM_BLK:
  605. X            playSoundFile("touch", 100);
  606. X            break;
  607. X
  608. X        case BONUSX2_BLK:    
  609. X        case BONUSX4_BLK:    
  610. X        case BONUS_BLK:    
  611. X        case MGUN_BLK:    
  612. X        case EXTRABALL_BLK:    
  613. X        case WALLOFF_BLK:    
  614. X        case REVERSE_BLK:    
  615. X        case MULTIBALL_BLK:
  616. X        case STICKY_BLK:
  617. X        case PAD_SHRINK_BLK:
  618. X        case PAD_EXPAND_BLK:
  619. X            playSoundFile("bonus", 50);
  620. X            break;
  621. X
  622. X        case DEATH_BLK:    
  623. X            playSoundFile("evillaugh", 100);
  624. X            break;
  625. X
  626. X        case BLACK_BLK:        
  627. X            playSoundFile("touch", 50);
  628. X            break;
  629. X
  630. X        case HYPERSPACE_BLK:
  631. X            playSoundFile("hyperspace", 70);
  632. X            break;
  633. X
  634. X        case KILL_BLK:
  635. X            ErrorMessage("Error: kill block type in PlaySoundForBlock()");
  636. X            break;
  637. X
  638. X        default:
  639. X            ErrorMessage("Error: Unknown block type in PlaySoundForBlock()");
  640. X            break;
  641. X    }
  642. X}
  643. X
  644. X#if NeedFunctionPrototypes
  645. Xvoid ExplodeBlockType(Display *display, Window window, int x, int y, 
  646. X    int type, int slide)
  647. X#else
  648. Xvoid ExplodeBlockType(display, window, x, y, type, slide)
  649. X    Display *display;
  650. X    Window window;
  651. X    int x;
  652. X    int y; 
  653. X    int type;
  654. X    int slide;
  655. X#endif
  656. X{
  657. X    /* Draw a frame from the blocks explode animation */
  658. X    switch (type)
  659. X    {
  660. X        case BOMB_BLK:        /* Draw the bomb block explosion slide */
  661. X            RenderShape(display, window, exbombblock[slide], 
  662. X                exbombblockM[slide], x, y, 30, 30, True);
  663. X            break;
  664. X
  665. X        case MULTIBALL_BLK:
  666. X        case RED_BLK:        /* Draw a red block explosion slide */
  667. X            RenderShape(display, window, exredblock[slide], 
  668. X                exredblockM[slide], x, y, 40, 20, True);
  669. X            break;
  670. X
  671. X        case GREEN_BLK:        /* Draw a green block explosion slide */
  672. X            RenderShape(display, window, exgreenblock[slide], 
  673. X                exgreenblockM[slide], x, y, 40, 20, True);
  674. X            break;
  675. X
  676. X        case BLUE_BLK:        /* Draw a blue block explosion slide */
  677. X            RenderShape(display, window, exblueblock[slide], 
  678. X                exblueblockM[slide], x, y, 40, 20, True);
  679. X            break;
  680. X
  681. X        case TAN_BLK:        /* Draw a tan block explosion slide */
  682. X            RenderShape(display, window, extanblock[slide], 
  683. X                extanblockM[slide], x, y, 40, 20, True);
  684. X            break;
  685. X
  686. X        case PURPLE_BLK:    /* Draw a purple block explosion slide */
  687. X            RenderShape(display, window, expurpleblock[slide], 
  688. X                expurpleblockM[slide], x, y, 40, 20, True);
  689. X            break;
  690. X
  691. X        case BULLET_BLK:    /* Draw a bullet block explosion slide */
  692. X        case YELLOW_BLK:    /* Draw a yellow block explosion slide */
  693. X            RenderShape(display, window, exyellowblock[slide], 
  694. X                exyellowblockM[slide], x, y, 40, 20, True);
  695. X            break;
  696. X
  697. X        case COUNTER_BLK:    /* Draw a counter block explosion slide */
  698. X            RenderShape(display, window, excounterblock[slide], 
  699. X                excounterblockM[slide], x, y, 40, 20, True);
  700. X            break;
  701. X
  702. X        case BONUS_BLK:        /* Draw a bonus coin block explosion slide */
  703. X        case BONUSX4_BLK:    /* Draw a bonus x2 oin block explosion slide */
  704. X        case BONUSX2_BLK:    /* Draw a bonus x4 coin block explosion slide */
  705. X            RenderShape(display, window, exx2bonus[slide], 
  706. X                exx2bonusM[slide], x, y, 27, 27, True);
  707. X            break;
  708. X
  709. X        case DEATH_BLK:        /* Draw a pirate death block explosion slide */
  710. X            RenderShape(display, window, exdeath[slide], 
  711. X                exdeathM[slide], x, y, 30, 30, True);
  712. X            break;
  713. X
  714. X        case BLACK_BLK:        /* The wall doesn't have any animation */
  715. X        case REVERSE_BLK:    /* The reverse doesn't have any animation */
  716. X        case HYPERSPACE_BLK:/* The hyperspace doesn't have any animation */
  717. X        case EXTRABALL_BLK:    /* The extra ball doesn't have any animation */
  718. X        case MGUN_BLK:        /* The machine gun doesn't have any animation */
  719. X        case WALLOFF_BLK:    /* The wall off doesn't have any animation */
  720. X        case STICKY_BLK:    /* No animation for sticky block either */
  721. X        case PAD_SHRINK_BLK:
  722. X        case PAD_EXPAND_BLK:
  723. X            break;
  724. X
  725. X            break;
  726. X
  727. X        default:
  728. X            ErrorMessage("Error: Unknown block type in ExplodeBlockType()");
  729. X            break;
  730. X    }
  731. X}
  732. X
  733. X#if NeedFunctionPrototypes
  734. Xvoid AddBonusBlock(Display *display, Window window, int *row, int *col, 
  735. X    int type)
  736. X#else
  737. Xvoid AddBonusBlock(display, window, row, col, type)
  738. X    Display *display;
  739. X    Window window;
  740. X    int *row;
  741. X    int *col;
  742. X    int type;
  743. X#endif
  744. X{
  745. X    int r, c;
  746. X    struct aBlock *blockP;
  747. X
  748. X    /* Give me a new random block position */
  749. X    r = rand() % (MAX_ROW - 4);
  750. X    c = rand() % MAX_COL;
  751. X
  752. X    /* Pointer to the correct block we need - speed things up */
  753. X    blockP = &blocks[r][c];
  754. X
  755. X    /* Add a bonus coin in this block only if it isn't occupied and 
  756. X     * it isn't exploding.
  757. X     */
  758. X    if ((blockP->occupied == False) && (blockP->explodeStartFrame == 0))
  759. X    {
  760. X        AddNewBlock(display, window, r, c, type, 0);
  761. X        bonusBlock = True;
  762. X
  763. X        /* Setup the block structure for new block */
  764. X        blockP->nextFrame         = frame + BONUS_DELAY;
  765. X        blockP->lastFrame         = frame + BONUS_LENGTH;
  766. X        blockP->bonusSlide         = 3;
  767. X
  768. X        /* Return the new bonus row & coloumn position */
  769. X        *row = r; *col = c;
  770. X    }
  771. X}
  772. X
  773. X#if NeedFunctionPrototypes
  774. Xstatic int GetRandomType(void)
  775. X#else
  776. Xstatic int GetRandomType()
  777. X#endif
  778. X{
  779. X    /* This function will return a random new block block type */
  780. X    switch (rand() % 7)
  781. X    {
  782. X        case 0:
  783. X            return RED_BLK;
  784. X
  785. X        case 1:
  786. X            return BLUE_BLK;
  787. X
  788. X        case 2:
  789. X            return GREEN_BLK;
  790. X
  791. X        case 3:
  792. X            return TAN_BLK;
  793. X
  794. X        case 4:
  795. X            return YELLOW_BLK;
  796. X
  797. X        case 5:
  798. X            return PURPLE_BLK;
  799. X
  800. X        case 6:
  801. X            return BULLET_BLK;
  802. X    }
  803. X
  804. X    /* Shouldn't get here but it stops warnings on compiler */
  805. X    return YELLOW_BLK;
  806. X}
  807. X
  808. X#if NeedFunctionPrototypes
  809. Xvoid HandlePendingBonuses(Display *display, Window window, int type, 
  810. X    int r, int c)
  811. X#else
  812. Xvoid HandlePendingBonuses(display, window, type, r, c)
  813. X    Display *display;
  814. X    Window window;
  815. X    int type;
  816. X    int r, c;
  817. X#endif
  818. X{
  819. X    struct aBlock *blockP;
  820. X
  821. X    blockP = &blocks[r][c];
  822. X
  823. X    if (blockP->nextFrame == frame) 
  824. X    {
  825. X        if (frame <= blockP->lastFrame)
  826. X        {
  827. X            /* Advance to the next frame of animation */
  828. X            DrawTheBlock(display, window, 
  829. X                blockP->x, blockP->y, 
  830. X                type, blockP->bonusSlide);
  831. X
  832. X                blockP->nextFrame = frame + BONUS_DELAY;
  833. X                blockP->bonusSlide--;
  834. X
  835. X                if (blockP->bonusSlide < 0)
  836. X                blockP->bonusSlide = 3;
  837. X        }
  838. X        else
  839. X        {
  840. X            /* Kill off bonus block */
  841. X            bonusBlock = False;
  842. X            blockP->occupied = False;
  843. X            XClearArea(display, window, 
  844. X                blockP->x, blockP->y,
  845. X                blockP->width, blockP->height, 
  846. X                False);
  847. X        }
  848. X    }
  849. X}
  850. X
  851. X#if NeedFunctionPrototypes
  852. Xvoid HandlePendingAnimations(Display *display, Window window)
  853. X#else
  854. Xvoid HandlePendingAnimations(display, window)
  855. X    Display *display;
  856. X    Window window;
  857. X#endif
  858. X{
  859. X    int r, c;
  860. X    struct aBlock *blockP;
  861. X
  862. X    /* Cycle through all rows and columns and update any animations that
  863. X     * need to be done every frame. ie: bonus etc
  864. X     */
  865. X    for (r = 0; r < MAX_ROW; r++)
  866. X    {
  867. X        for (c = 0; c < MAX_COL; c++)
  868. X        {
  869. X            blockP = &blocks[r][c];
  870. X
  871. X            /* Only bother if the block is occupied! */
  872. X            if (blockP->occupied == True) 
  873. X            {
  874. X                switch (blockP->blockType)
  875. X                {
  876. X                    case BONUS_BLK:    /* Bonus coin symbol */
  877. X                        HandlePendingBonuses(display, window, BONUS_BLK, r, c);
  878. X                        break;
  879. X
  880. X                    case BONUSX2_BLK:    /* Bonus x2 coin symbol */
  881. X                        HandlePendingBonuses(display, window, BONUSX2_BLK, r,c);
  882. X                        break;
  883. X
  884. X                    case BONUSX4_BLK:    /* Bonus x4 coin symbol */
  885. X                        HandlePendingBonuses(display, window, BONUSX4_BLK, r,c);
  886. X                        break;
  887. X
  888. X                    case DEATH_BLK:    /* Death block animation */
  889. X                        if (blockP->nextFrame == frame) 
  890. X                        {
  891. X                            /* Advance to the next frame of animation */
  892. X                            DrawTheBlock(display, window, 
  893. X                                blockP->x, blockP->y, 
  894. X                                DEATH_BLK, blockP->bonusSlide);
  895. X
  896. X                            blockP->nextFrame = frame + DEATH_DELAY1;
  897. X                            blockP->bonusSlide++;
  898. X
  899. X                            /* Have the delay bit between winks */
  900. X                            if (blockP->bonusSlide > 4)
  901. X                            {
  902. X                                blockP->bonusSlide = 0;
  903. X                                blockP->nextFrame = frame + DEATH_DELAY2;
  904. X                                DrawTheBlock(display, window, 
  905. X                                    blockP->x, blockP->y, 
  906. X                                    DEATH_BLK, blockP->bonusSlide);
  907. X                            }
  908. X                        }
  909. X                        break;
  910. X
  911. X                    case EXTRABALL_BLK:    /* extra ball block animation */
  912. X                        if (blockP->nextFrame == frame) 
  913. X                        {
  914. X                            /* Advance to the next frame of animation */
  915. X                            DrawTheBlock(display, window, 
  916. X                                blockP->x, blockP->y, 
  917. X                                EXTRABALL_BLK, blockP->bonusSlide);
  918. X
  919. X                            blockP->nextFrame = frame + EXTRABALL_DELAY;
  920. X                            blockP->bonusSlide++;
  921. X
  922. X                            /* Have the delay bit between flashes */
  923. X                            if (blockP->bonusSlide > 1)
  924. X                                blockP->bonusSlide = 0;
  925. X                        }
  926. X                        break;
  927. X                }
  928. X
  929. X                /* If it is a random block then change? */
  930. X                if (blockP->random == True)
  931. X                {
  932. X                    if (blockP->nextFrame == frame) 
  933. X                    {
  934. X                        /* Change the block to a new block block. We should
  935. X                         * be allright in just changing the blocktype etc.
  936. X                         * as the blocks are all the same .
  937. X                         */
  938. X                        blockP->blockType = GetRandomType();
  939. X                        blockP->bonusSlide = 0;
  940. X
  941. X                        DrawTheBlock(display, window, 
  942. X                            blockP->x, blockP->y, 
  943. X                            blockP->blockType, blockP->bonusSlide);
  944. X
  945. X                        blockP->nextFrame = 
  946. X                            frame + (rand() % RANDOM_DELAY) + 300;
  947. X                    }    
  948. X                }
  949. X            }
  950. X        }
  951. X    }
  952. X}
  953. X
  954. X#if NeedFunctionPrototypes
  955. Xvoid ExplodeBlocksPending(Display *display, Window window)
  956. X#else
  957. Xvoid ExplodeBlocksPending(display, window)
  958. X    Display *display;
  959. X    Window window;
  960. X#endif
  961. X{
  962. X    int r, c, x, y, type, i;
  963. X    struct aBlock *blockP;
  964. X    char str[50];
  965. X
  966. X    /* If none are exploding then bug out */
  967. X    if (blocksExploding == 0) return;
  968. X
  969. X    /* Cycle through all blocks exploding pending animation blocks */
  970. X    for (r = 0; r < MAX_ROW; r++)
  971. X    {
  972. X        for (c = 0; c < MAX_COL; c++)
  973. X        {
  974. X            /* Get the pointer to the block we need */
  975. X            blockP = &blocks[r][c];
  976. X
  977. X            /* Will be non-zero if animation is required */
  978. X            if (blockP->explodeStartFrame)
  979. X            {
  980. X                /* Is it time to explode this frame */
  981. X                if (blockP->explodeNextFrame == frame) 
  982. X                {
  983. X                    x = blockP->x;
  984. X                    y = blockP->y;
  985. X                    type = blockP->blockType;
  986. X
  987. X                    /* Switch on slide of animation */
  988. X                    switch (blockP->explodeSlide)
  989. X                    {
  990. X                        case 1:    /* First frame of animation */
  991. X                            ExplodeBlockType(display, window, x, y, type, 0);
  992. X                            blockP->explodeNextFrame =
  993. X                                blockP->explodeStartFrame;
  994. X                            break;
  995. X    
  996. X                        case 2:    /* Second frame of animation */
  997. X                            ExplodeBlockType(display, window, x, y, type, 1);
  998. X                            break;
  999. X    
  1000. X                        case 3:    /* Third frame of animation */
  1001. X                            ExplodeBlockType(display, window, x, y, type, 2);
  1002. X                            break;
  1003. X    
  1004. X                        case 4:    /* Last frame of animation  - clear */
  1005. X                            XClearArea(display, window, x, y, 
  1006. X                                blockP->width, 
  1007. X                                blockP->height, False);
  1008. X                            break;
  1009. X                    }
  1010. X    
  1011. X                    /* procede to next frame in animation */
  1012. X                    blockP->explodeSlide++;
  1013. X                    blockP->explodeNextFrame += EXPLODE_DELAY;
  1014. X    
  1015. X                    /* last frame so clean up animation and block */
  1016. X                    if (blockP->explodeSlide > 4)
  1017. X                    {
  1018. X                        blocksExploding--;
  1019. X                        blockP->occupied = 0;
  1020. X                        blockP->exploding = False;
  1021. X
  1022. X                        AddToScore((u_long) blockP->hitPoints);
  1023. X                        DisplayScore(display, scoreWindow, score);
  1024. X
  1025. X                        switch (blockP->blockType)
  1026. X                        {
  1027. X                            case BLACK_BLK:
  1028. X                            case PAD_SHRINK_BLK:
  1029. X                            case PAD_EXPAND_BLK:
  1030. X                                break;
  1031. X
  1032. X                            case BOMB_BLK:
  1033. X                                /* Explode all the ones around it */
  1034. X                                SetBlockUpForExplosion(r+1, c, 
  1035. X                                    frame + EXPLODE_DELAY);
  1036. X                                SetBlockUpForExplosion(r, c+1, 
  1037. X                                    frame + EXPLODE_DELAY);
  1038. X                                SetBlockUpForExplosion(r-1, c, 
  1039. X                                    frame + EXPLODE_DELAY);
  1040. X                                SetBlockUpForExplosion(r, c-1, 
  1041. X                                    frame + EXPLODE_DELAY);
  1042. X                                SetBlockUpForExplosion(r-1, c-1, 
  1043. X                                    frame + EXPLODE_DELAY);
  1044. X                                SetBlockUpForExplosion(r-1, c+1, 
  1045. X                                    frame + EXPLODE_DELAY);
  1046. X                                SetBlockUpForExplosion(r+1, c-1, 
  1047. X                                    frame + EXPLODE_DELAY);
  1048. X                                SetBlockUpForExplosion(r+1, c+1, 
  1049. X                                    frame + EXPLODE_DELAY);
  1050. X
  1051. X                                /* Special effect where screen shakes 
  1052. X                                 * during explosion 
  1053. X                                 */
  1054. X                                SetSfxEndFrame(frame + 70);
  1055. X                                changeSfxMode(SFX_SHAKE);
  1056. X                                break;
  1057. X
  1058. X                            case BULLET_BLK:
  1059. X                                SetCurrentMessage(display, messWindow, 
  1060. X                                    "More ammunition, cool!", True);
  1061. X                                for (i=0; i < NUMBER_OF_BULLETS_NEW_LEVEL; i++)
  1062. X                                    AddABullet(display);
  1063. X                                break;
  1064. X
  1065. X                            case BONUS_BLK:
  1066. X                                IncNumberBonus();
  1067. X
  1068. X                                if (GetNumberBonus() <= MAX_BONUS)
  1069. X                                    sprintf(str, 
  1070. X                                        "- Bonus #%d -", GetNumberBonus());
  1071. X                                else
  1072. X                                    sprintf(str, "- Super Bonus -");
  1073. X
  1074. X                                SetCurrentMessage(display, messWindow, str, 
  1075. X                                    True);
  1076. X                                bonusBlock = False;
  1077. X
  1078. X                                /* Turn on killer mode after 10 bonuses */
  1079. X                                if (GetNumberBonus() == 10)
  1080. X                                {
  1081. X                                    /* Turn on killer mode */
  1082. X                                    ToggleKiller(display, True);
  1083. X                                    DrawSpecials(display);
  1084. X
  1085. X                                    SetCurrentMessage(display, messWindow, 
  1086. X                                        "- Killer Mode -", True);
  1087. X                                }
  1088. X                                break;
  1089. X
  1090. X                            case BONUSX2_BLK:
  1091. X                                Togglex2Bonus(display, True);
  1092. X                                Togglex4Bonus(display, False);
  1093. X                                DrawSpecials(display);
  1094. X
  1095. X                                bonusBlock = False;
  1096. X                                SetCurrentMessage(display, messWindow, 
  1097. X                                    "- x2 Bonus -", True);
  1098. X                                break;
  1099. X
  1100. X                            case BONUSX4_BLK:
  1101. X                                Togglex2Bonus(display, False);
  1102. X                                Togglex4Bonus(display, True);
  1103. X                                DrawSpecials(display);
  1104. X
  1105. X                                bonusBlock = False;
  1106. X                                SetCurrentMessage(display, messWindow, 
  1107. X                                    "- x4 Bonus -", True);
  1108. X                                break;
  1109. X
  1110. X                            default :
  1111. X                                break;
  1112. X                        }
  1113. X
  1114. X                        /* Reset to a non exploding block */
  1115. X                        ClearBlock(r, c);
  1116. X                    }
  1117. X                }
  1118. X            }
  1119. X        }
  1120. X    }
  1121. X}
  1122. X
  1123. X#if NeedFunctionPrototypes
  1124. Xvoid DrawTheBlock(Display *display, Window window, int x, int y, 
  1125. X    int blockType, int slide)
  1126. X#else
  1127. Xvoid DrawTheBlock(display, window, x, y, blockType, slide)
  1128. X    Display *display;
  1129. X    Window window;
  1130. X    int x;
  1131. X    int y; 
  1132. X    int blockType;
  1133. X    int slide;
  1134. X#endif
  1135. X{
  1136. X    switch(blockType)
  1137. X    {
  1138. X        case PAD_SHRINK_BLK:    /* Paddle shrink block */
  1139. X            RenderShape(display, window, paddleshrink,
  1140. X                paddleshrinkM, x, y, 40, 15, False);
  1141. X            break;
  1142. X
  1143. X        case PAD_EXPAND_BLK:    /* Paddle expand block */
  1144. X            RenderShape(display, window, paddleexpand,
  1145. X                paddleexpandM, x, y, 40, 15, False);
  1146. X            break;
  1147. X
  1148. X        case BULLET_BLK:    /* Draw a bullet shape */
  1149. X            RenderShape(display, window, yellowblock, yellowblockM, 
  1150. X                x, y, 40, 20, False);
  1151. X            DrawTheBullet(display, window, x+6, y+10);
  1152. X            DrawTheBullet(display, window, x+15, y+10);
  1153. X            DrawTheBullet(display, window, x+24, y+10);
  1154. X            DrawTheBullet(display, window, x+33, y+10);
  1155. X            break;
  1156. X
  1157. X        case MULTIBALL_BLK:    /* Draw multiple ball block */
  1158. X            RenderShape(display, window, multiball, multiballM, 
  1159. X                x, y, 40, 20, False);
  1160. X            break;
  1161. X
  1162. X        case STICKY_BLK:    /* Draw sticky block */
  1163. X            RenderShape(display, window, sticky, stickyM, 
  1164. X                x, y, 32, 32, False);
  1165. X            break;
  1166. X
  1167. X        case RED_BLK:    /* Draw a red block shape */
  1168. X            RenderShape(display, window, redblock, redblockM, 
  1169. X                x, y, 40, 20, False);
  1170. X            break;
  1171. X
  1172. X        case BLACK_BLK:        /* Draw a solid wall block */    
  1173. X            RenderShape(display, window, blackblock, blackblockM, 
  1174. X                x, y, 50, 30, False);
  1175. X            break;
  1176. X
  1177. X        case GREEN_BLK:        /* Draw a green block */
  1178. X            RenderShape(display, window, greenblock, greenblockM, 
  1179. X                x, y, 40, 20, False);
  1180. X            break;
  1181. X
  1182. X        case BLUE_BLK:        /* Draw a blue block */
  1183. X            RenderShape(display, window, blueblock, blueblockM, 
  1184. X                x, y, 40, 20, False);
  1185. X            break;
  1186. X
  1187. X        case YELLOW_BLK:    /* Draw a yellow block */
  1188. X            RenderShape(display, window, yellowblock, yellowblockM, 
  1189. X                x, y, 40, 20, False);
  1190. X            break;
  1191. X
  1192. X        case TAN_BLK:        /* Draw a tan block */
  1193. X            RenderShape(display, window, tanblock, tanblockM, 
  1194. X                x, y, 40, 20, False);
  1195. X            break;
  1196. X
  1197. X        case PURPLE_BLK:    /* Draw a purple block */
  1198. X            RenderShape(display, window, purpleblock, purpleblockM, 
  1199. X                x, y, 40, 20, False);
  1200. X            break;
  1201. X
  1202. X        case COUNTER_BLK:    /* Draw a frame of counter block */
  1203. X            RenderShape(display, window, counterblock[slide], 
  1204. X                counterblockM[slide], x, y, 40, 20, False);
  1205. X            break;
  1206. X
  1207. X        case BONUSX2_BLK:    /* Draw a bonus x2 coin block */
  1208. X            RenderShape(display, window, x2bonus[slide], 
  1209. X                x2bonusM[slide], x, y, 27, 27, False);
  1210. X            break;
  1211. X
  1212. X        case BONUSX4_BLK:    /* Draw a bonus x4 coin block */
  1213. X            RenderShape(display, window, x4bonus[slide], 
  1214. X                x4bonusM[slide], x, y, 27, 27, False);
  1215. X            break;
  1216. X
  1217. X        case BONUS_BLK:    /* Draw a bonus coin block */
  1218. X            RenderShape(display, window, Bonus[slide], 
  1219. X                BonusM[slide], x, y, 27, 27, False);
  1220. X            break;
  1221. X
  1222. X        case BOMB_BLK:        /* Draw a bomb block */
  1223. X            RenderShape(display, window, bombblock, bombblockM, 
  1224. X                x, y, 30, 30, False);
  1225. X            break;
  1226. X
  1227. X        case DEATH_BLK:        /* Draw the pirate death block */
  1228. X            RenderShape(display, window, death[slide], deathM[slide], 
  1229. X                x, y, 30, 30, False);
  1230. X            break;
  1231. X
  1232. X        case REVERSE_BLK:    /* Draw the reverse block */
  1233. X            RenderShape(display, window, revblock, revblockM, 
  1234. X                x, y, 33, 16, False);
  1235. X            break;
  1236. X
  1237. X        case EXTRABALL_BLK:    /* Draw the extra ball block */
  1238. X            RenderShape(display, window, extraball[slide], extraballM[slide], 
  1239. X                x, y, 30, 19, False);
  1240. X            break;
  1241. X
  1242. X        case HYPERSPACE_BLK:    /* Draw the hyperspace block */
  1243. X            RenderShape(display, window, hyperblock, hyperblockM, 
  1244. X                x, y, 31, 31, False);
  1245. X            break;
  1246. X
  1247. X        case MGUN_BLK:    /* Draw the machine gun block */
  1248. X            RenderShape(display, window, mgunblock, mgunblockM, 
  1249. X                x, y, 35, 15, False);
  1250. X            break;
  1251. X
  1252. X        case WALLOFF_BLK:    /* Draw the wall off block */
  1253. X            RenderShape(display, window, walloffblock, walloffblockM, 
  1254. X                x, y, 27, 23, False);
  1255. X            break;
  1256. X    }
  1257. X}
  1258. X
  1259. X#if NeedFunctionPrototypes
  1260. Xstatic void SetBlockUpForExplosion(int row, int col, int frame)
  1261. X#else
  1262. Xstatic void SetBlockUpForExplosion(row, col, frame)
  1263. X    int row;
  1264. X    int col;
  1265. X    int frame;
  1266. X#endif
  1267. X{
  1268. X    struct aBlock *blockP;
  1269. X
  1270. X    if (row < 0 || row >= MAX_ROW) return;
  1271. X    if (col < 0 || col >= MAX_COL) return;
  1272. X
  1273. X    /* Obtain a pointer to the affected block */
  1274. X    blockP = &blocks[row][col];
  1275. X
  1276. X    /* Do not have any effect on a specials block */
  1277. X    if (blockP->blockType == HYPERSPACE_BLK) return;
  1278. X
  1279. X    /* If it isn't occupied then why blow it up */
  1280. X    if (blockP->occupied == 1 && blockP->exploding == False)
  1281. X    {
  1282. X        /* Keep track of how many blocks are exploding */
  1283. X        blocksExploding++;
  1284. X
  1285. X        /* Some special variables used for timing */
  1286. X        blockP->explodeStartFrame     = frame;
  1287. X        blockP->explodeNextFrame     = frame;
  1288. X        blockP->explodeSlide         = 1;
  1289. X        blockP->exploding             = True;
  1290. X    }
  1291. X}
  1292. X
  1293. X
  1294. X#if NeedFunctionPrototypes
  1295. Xvoid DrawBlock(Display *display, Window window, int row, int col, int blockType)
  1296. X#else
  1297. Xvoid DrawBlock(display, window, row, col, blockType)
  1298. X    Display *display;
  1299. X    Window window;
  1300. X    int row;
  1301. X    int col;
  1302. X    int blockType;
  1303. X#endif
  1304. X{
  1305. X    struct aBlock *blockP;
  1306. X
  1307. X    if (row < 0 || row > MAX_ROW) 
  1308. X    {
  1309. X        ErrorMessage("Block out of bounds row.");
  1310. X        return;
  1311. X    }
  1312. X
  1313. X    if (col < 0 || col > MAX_COL) 
  1314. X    {
  1315. X        ErrorMessage("Block out of bounds column.");
  1316. X        return;
  1317. X    }
  1318. X
  1319. X    /* Pointer to the block in question */
  1320. X    blockP = &blocks[row][col];
  1321. X
  1322. X    switch(blockType)
  1323. X    {
  1324. X        case KILL_BLK:        /* Special block - blow it up */
  1325. X            PlaySoundForBlock(blockP->blockType);
  1326. X
  1327. X            if (blockP->blockType != BLACK_BLK)
  1328. X                SetBlockUpForExplosion(row, col, frame);
  1329. X            break;
  1330. X
  1331. X        default:            /* Your average block - draw it */
  1332. X            DrawTheBlock(display, window, blockP->x, blockP->y, 
  1333. X                blockType, blockP->counterSlide);
  1334. X    }
  1335. X}
  1336. X
  1337. X#if NeedFunctionPrototypes
  1338. Xvoid FreeBlockPixmaps(Display *display)
  1339. X#else
  1340. Xvoid FreeBlockPixmaps(display)
  1341. X    Display *display;
  1342. X#endif
  1343. X{
  1344. X    int i;
  1345. X
  1346. X    /* Free the memory associated with the block pixmaps */
  1347. X    if (redblock)        XFreePixmap(display, redblock);            
  1348. X    if (redblockM)        XFreePixmap(display, redblockM);
  1349. X    if (blueblock)        XFreePixmap(display, blueblock);        
  1350. X    if (blueblockM)        XFreePixmap(display, blueblockM);
  1351. X    if (greenblock)        XFreePixmap(display, greenblock);        
  1352. X    if (greenblockM)    XFreePixmap(display, greenblockM);
  1353. X    if (tanblock)        XFreePixmap(display, tanblock);            
  1354. X    if (tanblockM)        XFreePixmap(display, tanblockM);
  1355. X    if (yellowblock)    XFreePixmap(display, yellowblock);        
  1356. X    if (yellowblockM)    XFreePixmap(display, yellowblockM);
  1357. X    if (purpleblock)    XFreePixmap(display, purpleblock);        
  1358. X    if (purpleblockM)    XFreePixmap(display, purpleblockM);
  1359. X    if (blackblock)        XFreePixmap(display, blackblock);        
  1360. X    if (blackblockM)    XFreePixmap(display, blackblockM);
  1361. X    if (bombblock)        XFreePixmap(display, bombblock);        
  1362. X    if (bombblockM)        XFreePixmap(display, bombblockM);
  1363. X    if (revblock)        XFreePixmap(display, revblock);        
  1364. X    if (revblockM)        XFreePixmap(display, revblockM);
  1365. X    if (hyperblock)        XFreePixmap(display, hyperblock);        
  1366. X    if (hyperblockM)    XFreePixmap(display, hyperblockM);
  1367. X    if (mgunblock)        XFreePixmap(display, mgunblock);        
  1368. X    if (mgunblockM)        XFreePixmap(display, mgunblockM);
  1369. X    if (walloffblock)    XFreePixmap(display, walloffblock);        
  1370. X    if (walloffblockM)    XFreePixmap(display, walloffblockM);
  1371. X    if (multiball)        XFreePixmap(display, multiball);        
  1372. X    if (multiballM)        XFreePixmap(display, multiballM);
  1373. X    if (sticky)            XFreePixmap(display, sticky);        
  1374. X    if (stickyM)        XFreePixmap(display, stickyM);
  1375. X    if (paddleexpand)    XFreePixmap(display, paddleexpand);        
  1376. X    if (paddleexpandM)    XFreePixmap(display, paddleexpandM);
  1377. X    if (paddleshrink)    XFreePixmap(display, paddleshrink);        
  1378. X    if (paddleshrinkM)    XFreePixmap(display, paddleshrinkM);
  1379. X
  1380. X    for (i = 0; i < 5; i++)
  1381. X    {
  1382. X        /* Free the frames for the death block */
  1383. X        if (death[i])    XFreePixmap(display, death[i]);     
  1384. X        if (deathM[i])    XFreePixmap(display, deathM[i]);
  1385. X    }
  1386. X
  1387. X    for (i = 0; i < 6; i++)
  1388. X    {
  1389. X        if (counterblock[i])    XFreePixmap(display, counterblock[i]);     
  1390. X        if (counterblockM[i])    XFreePixmap(display, counterblockM[i]);
  1391. X    }
  1392. X
  1393. X    for (i = 0; i < 4; i++)
  1394. X    {
  1395. X        if (x2bonus[i])            XFreePixmap(display, x2bonus[i]);     
  1396. X        if (x2bonusM[i])        XFreePixmap(display, x2bonusM[i]);
  1397. X
  1398. X        if (x4bonus[i])            XFreePixmap(display, x4bonus[i]);     
  1399. X        if (x4bonusM[i])        XFreePixmap(display, x4bonusM[i]);
  1400. X
  1401. X        if (Bonus[i])            XFreePixmap(display, Bonus[i]);     
  1402. X        if (BonusM[i])            XFreePixmap(display, BonusM[i]);
  1403. X    }
  1404. X
  1405. X    for (i = 0; i < 2; i++)
  1406. X    {
  1407. X        if (extraball[i])        XFreePixmap(display, extraball[i]);     
  1408. X        if (extraballM[i])        XFreePixmap(display, extraballM[i]);
  1409. X    }
  1410. X
  1411. X    for (i = 0; i < 3; i++)
  1412. X    {
  1413. X        if (exgreenblock[i])       XFreePixmap(display, exgreenblock[i]);     
  1414. X        if (exgreenblockM[i])   XFreePixmap(display, exgreenblockM[i]);
  1415. X
  1416. X        if (exyellowblock[i])   XFreePixmap(display, exyellowblock[i]);
  1417. X        if (exyellowblockM[i])  XFreePixmap(display, exyellowblockM[i]);
  1418. X
  1419. X        if (exredblock[i])         XFreePixmap(display, exredblock[i]);
  1420. X        if (exredblockM[i])     XFreePixmap(display, exredblockM[i]);
  1421. X
  1422. X        if (exblueblock[i])     XFreePixmap(display, exblueblock[i]);
  1423. X        if (exblueblockM[i])    XFreePixmap(display, exblueblockM[i]);
  1424. X
  1425. X        if (extanblock[i])         XFreePixmap(display, extanblock[i]);
  1426. X        if (extanblockM[i])     XFreePixmap(display, extanblockM[i]);
  1427. X
  1428. X        if (excounterblock[i])  XFreePixmap(display, excounterblock[i]);
  1429. X        if (excounterblockM[i]) XFreePixmap(display, excounterblockM[i]);
  1430. X
  1431. X        if (exbombblock[i])     XFreePixmap(display, exbombblock[i]);
  1432. X        if (exbombblockM[i])    XFreePixmap(display, exbombblockM[i]);
  1433. X        
  1434. X        if (expurpleblock[i])   XFreePixmap(display, expurpleblock[i]);
  1435. X        if (expurpleblockM[i])  XFreePixmap(display, expurpleblockM[i]);
  1436. X        
  1437. X        if (exx2bonus[i])         XFreePixmap(display, exx2bonus[i]);
  1438. X        if (exx2bonusM[i])         XFreePixmap(display, exx2bonusM[i]);
  1439. X
  1440. X        if (exdeath[i])            XFreePixmap(display, exdeath[i]);     
  1441. X        if (exdeathM[i])        XFreePixmap(display, exdeathM[i]);
  1442. X    }
  1443. X}
  1444. X
  1445. X#if NeedFunctionPrototypes
  1446. Xstatic void CalculateBlockGeometry(int row, int col)
  1447. X#else
  1448. Xstatic void CalculateBlockGeometry(row, col)
  1449. X    int row, col;
  1450. X#endif
  1451. X{
  1452. X    struct aBlock *blockP;
  1453. X    XPoint points[4];
  1454. X    int halfWidth, halfHeight;
  1455. X
  1456. X    /* Pointer to the correct block we need - speed things up */
  1457. X    blockP = &blocks[row][col];
  1458. X
  1459. X    switch (blockP->blockType)
  1460. X    {
  1461. X        case COUNTER_BLK:
  1462. X            blockP->width             = BLOCK_WIDTH;
  1463. X            blockP->height            = BLOCK_HEIGHT;
  1464. X            blockP->blockOffsetX    = (colWidth - BLOCK_WIDTH) / 2;
  1465. X            blockP->blockOffsetY     = (rowHeight - BLOCK_HEIGHT) / 2;
  1466. X            break;
  1467. X
  1468. X        case MGUN_BLK:
  1469. X            blockP->width             = 35;
  1470. X            blockP->height            = 15;
  1471. X            blockP->blockOffsetX    = (colWidth - 35) / 2;
  1472. X            blockP->blockOffsetY     = (rowHeight - 15) / 2;
  1473. X            break;
  1474. X
  1475. X        case WALLOFF_BLK:
  1476. X            blockP->width             = 27;
  1477. X            blockP->height            = 23;
  1478. X            blockP->blockOffsetX    = (colWidth - 27) / 2;
  1479. X            blockP->blockOffsetY     = (rowHeight - 23) / 2;
  1480. X            break;
  1481. X
  1482. X        case REVERSE_BLK:
  1483. X            blockP->width             = 33;
  1484. X            blockP->height            = 16;
  1485. X            blockP->blockOffsetX    = (colWidth - 33) / 2;
  1486. X            blockP->blockOffsetY     = (rowHeight - 16) / 2;
  1487. X            break;
  1488. X
  1489. X        case EXTRABALL_BLK:
  1490. X            blockP->width             = 30;
  1491. X            blockP->height            = 19;
  1492. X            blockP->blockOffsetX    = (colWidth - 30) / 2;
  1493. X            blockP->blockOffsetY     = (rowHeight - 19) / 2;
  1494. X            break;
  1495. X
  1496. X        case HYPERSPACE_BLK:
  1497. X            blockP->width             = 31;
  1498. X            blockP->height            = 31;
  1499. X            blockP->blockOffsetX    = (colWidth - 31) / 2;
  1500. X            blockP->blockOffsetY     = (rowHeight - 31) / 2;
  1501. X            break;
  1502. X
  1503. X        case BOMB_BLK:
  1504. X        case DEATH_BLK:
  1505. X            blockP->width             = 30;
  1506. X            blockP->height            = 30;
  1507. X            blockP->blockOffsetX    = (colWidth - 30) / 2;
  1508. X            blockP->blockOffsetY     = (rowHeight - 30) / 2;
  1509. X            break;
  1510. X
  1511. X        case STICKY_BLK:
  1512. X            blockP->width             = 32;
  1513. X            blockP->height            = 32;
  1514. X            blockP->blockOffsetX    = (colWidth - 32) / 2;
  1515. X            blockP->blockOffsetY     = (rowHeight - 32) / 2;
  1516. X            break;
  1517. X
  1518. X        case BLACK_BLK:
  1519. X            blockP->width             = 50;
  1520. X            blockP->height            = 30;
  1521. X            blockP->blockOffsetX    = (colWidth - 50) / 2;
  1522. X            blockP->blockOffsetY     = (rowHeight - 30) / 2;
  1523. X            break;
  1524. X
  1525. X        case PAD_SHRINK_BLK:
  1526. X        case PAD_EXPAND_BLK:
  1527. X            blockP->width             = 40;
  1528. X            blockP->height            = 15;
  1529. X            blockP->blockOffsetX    = (colWidth - 40) / 2;
  1530. X            blockP->blockOffsetY     = (rowHeight - 15) / 2;
  1531. X            break;
  1532. X
  1533. X        case BONUS_BLK:
  1534. X        case BONUSX4_BLK:
  1535. X        case BONUSX2_BLK:
  1536. X            blockP->width             = 27;
  1537. X            blockP->height            = 27;
  1538. X            blockP->blockOffsetX    = (colWidth - 27) / 2;
  1539. X            blockP->blockOffsetY     = (rowHeight - 27) / 2;
  1540. X            break;
  1541. X
  1542. X        default:        /* All other blocks */
  1543. X            blockP->width             = BLOCK_WIDTH;
  1544. X            blockP->height            = BLOCK_HEIGHT;
  1545. X            blockP->blockOffsetX    = (colWidth - BLOCK_WIDTH) / 2;
  1546. X            blockP->blockOffsetY     = (rowHeight - BLOCK_HEIGHT) / 2;
  1547. X            break;
  1548. X
  1549. X    }    
  1550. X
  1551. X    /* Calculate the offset within the block grid */
  1552. X    blockP->x = (col * colWidth) + blockP->blockOffsetX;
  1553. X    blockP->y = (row * rowHeight) + blockP->blockOffsetY;
  1554. X
  1555. X    /* Used below */
  1556. X    halfWidth = blockP->x + (blockP->width / 2);
  1557. X    halfHeight = blockP->y + (blockP->height / 2);
  1558. X
  1559. X    /* Create the XPoint array for the top region */
  1560. X    points[0].x = blockP->x;
  1561. X    points[0].y = blockP->y;
  1562. X    points[1].x = halfWidth;
  1563. X    points[1].y = halfHeight;
  1564. X    points[2].x = blockP->x + blockP->width;
  1565. X    points[2].y = blockP->y;
  1566. X    points[3].x = points[0].x;
  1567. X    points[3].y = points[0].y;
  1568. X
  1569. X    /* Create the top region for the block */
  1570. X    blockP->regionTop = XPolygonRegion(points, 4, EvenOddRule);
  1571. X
  1572. X    /* Create the XPoint array for the bottom region */
  1573. X    points[0].x = blockP->x;
  1574. X    points[0].y = blockP->y + blockP->height;
  1575. X    points[1].x = halfWidth;
  1576. X    points[1].y = halfHeight;
  1577. X    points[2].x = blockP->x + blockP->width;
  1578. X    points[2].y = points[0].y;
  1579. X    points[3].x = points[0].x;
  1580. X    points[3].y = points[0].y;
  1581. X
  1582. X    /* Create the bottom region for the block */
  1583. X    blockP->regionBottom = XPolygonRegion(points, 4, EvenOddRule);
  1584. X
  1585. X    /* Create the XPoint array for the left region */
  1586. X    points[0].x = blockP->x;
  1587. X    points[0].y = blockP->y;
  1588. X    points[1].x = halfWidth;
  1589. X    points[1].y = halfHeight;
  1590. X    points[2].x = blockP->x;
  1591. X    points[2].y = blockP->y + blockP->height;
  1592. X    points[3].x = points[0].x;
  1593. X    points[3].y = points[0].y;
  1594. X
  1595. X    /* Create the left region for the block */
  1596. X    blockP->regionLeft = XPolygonRegion(points, 4, EvenOddRule);
  1597. X
  1598. X    /* Create the XPoint array for the right region */
  1599. X    points[0].x = blockP->x + blockP->width;
  1600. X    points[0].y = blockP->y;
  1601. X    points[1].x = halfWidth;
  1602. X    points[1].y = halfHeight;
  1603. X    points[2].x = points[0].x;
  1604. X    points[2].y = blockP->y + blockP->height;
  1605. X    points[3].x = points[0].x;
  1606. X    points[3].y = points[0].y;
  1607. X
  1608. X    /* Create the right region for the block */
  1609. X    blockP->regionRight = XPolygonRegion(points, 4, EvenOddRule);
  1610. X}
  1611. X
  1612. X#if NeedFunctionPrototypes
  1613. Xvoid AddNewBlock(Display *display, Window window, int row, int col,
  1614. X    int blockType, int counterSlide)
  1615. X#else
  1616. Xvoid AddNewBlock(display, window, row, col, blockType, counterSlide)
  1617. X    Display *display;
  1618. X    Window window;
  1619. X    int row;
  1620. X    int col;
  1621. X    int blockType;
  1622. X    int counterSlide;
  1623. X#endif
  1624. X{
  1625. X    struct aBlock *blockP;
  1626. X
  1627. X    if (row > MAX_ROW || row < 0) return;
  1628. X    if (col > MAX_COL || col < 0) return;
  1629. X
  1630. X    /* Pointer to the block we want */
  1631. X    blockP = &blocks[row][col];
  1632. X
  1633. X    /* Now set the block structure with new values */
  1634. X    blockP->blockType         = blockType;
  1635. X    blockP->occupied         = 1;
  1636. X    blockP->counterSlide     = counterSlide;
  1637. X
  1638. X    /* Handle the special case for a random block */
  1639. X    if (blockType == RANDOM_BLK)
  1640. X    {
  1641. X        /* Setup the random block so it has a next frame and new type */
  1642. X        blockP->random       = True;
  1643. X        blockP->blockType = RED_BLK;
  1644. X        blockP->nextFrame = frame + 1;
  1645. X    }
  1646. X
  1647. X    /* Work out all the block geometry stuff */
  1648. X    CalculateBlockGeometry(row, col);
  1649. X    
  1650. X    /* Add the number of points that will be awarded for each block */
  1651. X    switch(blockType)
  1652. X    {
  1653. X        case BULLET_BLK:
  1654. X            blockP->hitPoints = 50;
  1655. X            break;
  1656. X
  1657. X        case RED_BLK:
  1658. X            blockP->hitPoints = 100;
  1659. X            break;
  1660. X
  1661. X        case GREEN_BLK:
  1662. X            blockP->hitPoints = 120;
  1663. X            break;
  1664. X
  1665. X        case BLUE_BLK:
  1666. X            blockP->hitPoints = 110;
  1667. X            break;
  1668. X
  1669. X        case TAN_BLK:
  1670. X            blockP->hitPoints = 130;
  1671. X            break;
  1672. X
  1673. X        case YELLOW_BLK:
  1674. X            blockP->hitPoints = 140;
  1675. X            break;
  1676. X
  1677. X        case PURPLE_BLK:
  1678. X            blockP->hitPoints = 150;
  1679. X            break;
  1680. X
  1681. X        case BOMB_BLK:
  1682. X            blockP->hitPoints = 50;
  1683. X            break;
  1684. X
  1685. X        case COUNTER_BLK:
  1686. X            blockP->hitPoints = 200;
  1687. X            break;
  1688. X
  1689. X        case EXTRABALL_BLK:
  1690. X            blockP->nextFrame = frame + EXTRABALL_DELAY;
  1691. X            blockP->hitPoints = 100;
  1692. X            break;
  1693. X
  1694. X        case HYPERSPACE_BLK:
  1695. X        case MGUN_BLK:
  1696. X        case WALLOFF_BLK:
  1697. X        case REVERSE_BLK:
  1698. X        case MULTIBALL_BLK:
  1699. X        case STICKY_BLK:
  1700. X        case PAD_SHRINK_BLK:
  1701. X        case PAD_EXPAND_BLK:
  1702. X            blockP->hitPoints = 100;
  1703. X            break;
  1704. X
  1705. X        case DEATH_BLK:
  1706. X            blockP->hitPoints = -1000;
  1707. X            blockP->nextFrame = frame + DEATH_DELAY2;
  1708. X            break;
  1709. X
  1710. X        default:
  1711. X            break;
  1712. X    }
  1713. X
  1714. X    /* Draw the blocks please */
  1715. X    DrawBlock(display, window, row, col, blockType);
  1716. X}
  1717. X
  1718. X#if NeedFunctionPrototypes
  1719. Xvoid SkipToNextLevel(Display *display, Window window)
  1720. X#else
  1721. Xvoid SkipToNextLevel(display, window)
  1722. X    Display *display;
  1723. X    Window window;
  1724. X#endif
  1725. X{
  1726. X    struct aBlock *blockP;
  1727. X    int r, c;
  1728. X
  1729. X    /* This will kill all blocks that need to go before next level can
  1730. X     * be reached. Used in debug mode and maybe in special bonus mode.
  1731. X     */
  1732. X
  1733. X    for (r = 0; r < MAX_ROW; r++)
  1734. X        for (c = 0; c < MAX_COL; c++)
  1735. X        {
  1736. X            /* Pointer to the block we want */
  1737. X            blockP = &blocks[r][c];
  1738. X
  1739. X            if (blockP->occupied == True) 
  1740. X            {
  1741. X                switch (blockP->blockType)
  1742. X                {
  1743. X                    case BONUSX2_BLK:
  1744. X                    case BONUSX4_BLK:
  1745. X                    case BONUS_BLK:
  1746. X                    case BLACK_BLK:
  1747. X                    case BULLET_BLK:
  1748. X                    case BOMB_BLK:
  1749. X                    case DEATH_BLK:
  1750. X                    case REVERSE_BLK:
  1751. X                    case HYPERSPACE_BLK:
  1752. X                    case EXTRABALL_BLK:
  1753. X                    case MGUN_BLK:
  1754. X                    case WALLOFF_BLK:
  1755. X                    case MULTIBALL_BLK:
  1756. X                    case STICKY_BLK:
  1757. X                    case PAD_SHRINK_BLK:
  1758. X                    case PAD_EXPAND_BLK:
  1759. X                        break;
  1760. X
  1761. X                    default:
  1762. X                        DrawBlock(display, window, r, c, KILL_BLK);
  1763. X                        break;
  1764. X                }
  1765. X            }
  1766. X        }
  1767. X}
  1768. X
  1769. X#if NeedFunctionPrototypes
  1770. Xvoid RedrawAllBlocks(Display *display, Window window)
  1771. X#else
  1772. Xvoid RedrawAllBlocks(display, window)
  1773. X    Display *display;
  1774. X    Window window;
  1775. X#endif
  1776. X{
  1777. X    struct aBlock *blockP;
  1778. X    int r, c;
  1779. X
  1780. X    for (r = 0; r < MAX_ROW; r++)
  1781. X        for (c = 0; c < MAX_COL; c++)
  1782. X        {
  1783. X            /* Pointer to the block we want */
  1784. X            blockP = &blocks[r][c];
  1785. X
  1786. X            if (blockP->occupied == True)
  1787. X                DrawBlock(display, window, r, c, blockP->blockType);
  1788. X        }
  1789. X}
  1790. X
  1791. X#if NeedFunctionPrototypes
  1792. Xint StillActiveBlocks(void)
  1793. X#else
  1794. Xint StillActiveBlocks()
  1795. X#endif
  1796. X{
  1797. X    struct aBlock *blockP;
  1798. X    int r, c;
  1799. X
  1800. X    /* Check all blocks to see if they still are active */
  1801. X    for (r = 0; r < MAX_ROW; r++)
  1802. X        for (c = 0; c < MAX_COL; c++)
  1803. X        {
  1804. X            /* Pointer to the block we want */
  1805. X            blockP = &blocks[r][c];
  1806. X
  1807. X            if (blockP->occupied == True) 
  1808. X            {
  1809. X                switch (blockP->blockType)
  1810. X                {
  1811. X                    /* These blocks don't count */
  1812. X                    case BONUSX2_BLK:
  1813. X                    case BONUSX4_BLK:
  1814. X                    case BONUS_BLK:
  1815. X                    case BLACK_BLK:
  1816. X                    case BULLET_BLK:
  1817. X                    case BOMB_BLK:
  1818. X                    case DEATH_BLK:
  1819. X                    case REVERSE_BLK:
  1820. X                    case HYPERSPACE_BLK:
  1821. X                    case EXTRABALL_BLK:
  1822. X                    case MGUN_BLK:
  1823. X                    case WALLOFF_BLK:
  1824. X                    case MULTIBALL_BLK:
  1825. X                    case STICKY_BLK:
  1826. X                    case PAD_SHRINK_BLK:
  1827. X                    case PAD_EXPAND_BLK:
  1828. X                        break;
  1829. X
  1830. X                    default:
  1831. X                        return True;
  1832. X                }
  1833. X            }
  1834. X        }
  1835. X    
  1836. X    /* Only all done when explosions are finished */
  1837. X    if (blocksExploding > 0)
  1838. X        return True;
  1839. X    else
  1840. X        return False;
  1841. X}
  1842. X
  1843. X#if NeedFunctionPrototypes
  1844. Xstatic void ClearBlock(int row, int col)
  1845. X#else
  1846. Xstatic void ClearBlock(row, col)
  1847. X    int row;
  1848. X    int col;
  1849. X#endif
  1850. X{
  1851. X    struct aBlock *blockP;
  1852. X
  1853. X    /* Pointer to the block we want */
  1854. X    blockP = &blocks[row][col];
  1855. X
  1856. X    /* Initialise everything in block */
  1857. X    blockP->occupied             = False;
  1858. X    blockP->exploding             = False;
  1859. X    blockP->x                     = 0;
  1860. X    blockP->y                     = 0;
  1861. X    blockP->width                 = 0;
  1862. X    blockP->height                 = 0;
  1863. X    blockP->hitPoints             = 0;
  1864. X    blockP->blockType             = NONE_BLK;
  1865. X    blockP->explodeStartFrame     = 0;
  1866. X    blockP->explodeNextFrame     = 0;
  1867. X    blockP->explodeSlide         = 0;
  1868. X    blockP->counterSlide         = 0;
  1869. X    blockP->bonusSlide             = 0;
  1870. X    blockP->blockOffsetY         = 0;
  1871. X    blockP->blockOffsetX         = 0;
  1872. X    blockP->lastFrame             = 0;
  1873. X    blockP->nextFrame             = 0;
  1874. X    blockP->currentFrame         = 0;
  1875. X    blockP->random                 = False;
  1876. X    blockP->ballHitIndex         = 0;
  1877. X    blockP->balldx                 = 0;
  1878. X    blockP->balldy                 = 0;
  1879. X
  1880. X    /* Destroy the top region of the block */
  1881. X    if (blockP->regionTop != (Region) NULL)
  1882. X    {
  1883. X        XDestroyRegion(blockP->regionTop);
  1884. X        blockP->regionTop = (Region) NULL;
  1885. X    }
  1886. X
  1887. X    /* Destroy the bottom region of the block */
  1888. X    if (blockP->regionBottom != (Region) NULL)
  1889. X    {
  1890. X        XDestroyRegion(blockP->regionBottom);
  1891. X        blockP->regionBottom = (Region) NULL;
  1892. X    }
  1893. X
  1894. X    /* Destroy the left region of the block */
  1895. X    if (blockP->regionLeft != (Region) NULL)
  1896. X    {
  1897. X        XDestroyRegion(blockP->regionLeft);
  1898. X        blockP->regionLeft = (Region) NULL;
  1899. X    }
  1900. X
  1901. X    /* Destroy the right region of the block */
  1902. X    if (blockP->regionRight != (Region) NULL)
  1903. X    {
  1904. X        XDestroyRegion(blockP->regionRight);
  1905. X        blockP->regionRight = (Region) NULL;
  1906. X    }
  1907. X}
  1908. X
  1909. X
  1910. X#if NeedFunctionPrototypes
  1911. Xvoid ClearBlockArray(void)
  1912. X#else
  1913. Xvoid ClearBlockArray()
  1914. X#endif
  1915. X{
  1916. X    int r, c;
  1917. X
  1918. X    /* Scan through all block entries and erase their contents */
  1919. X    for (r = 0; r < MAX_ROW; r++)
  1920. X    {
  1921. X        for (c = 0; c < MAX_COL; c++)
  1922. X        {
  1923. X            /* Clear the block thanks */
  1924. X            ClearBlock(r, c);
  1925. X        }
  1926. X    }
  1927. X}
  1928. X
  1929. X#if NeedFunctionPrototypes
  1930. Xvoid SetupStage(Display *display, Window window)
  1931. X#else
  1932. Xvoid SetupStage(display, window)
  1933. X    Display *display;
  1934. X    Window window;
  1935. X#endif
  1936. X{
  1937. X    char levelPath[1024];
  1938. X    char *str;
  1939. X    char str2[1024];
  1940. X    static int bgrnd = 1;
  1941. X    u_long newLevel;
  1942. X
  1943. X    bgrnd++;
  1944. X    if (bgrnd == 12) bgrnd = 2;
  1945. X    DrawStageBackground(display, window, bgrnd);
  1946. X
  1947. X    ClearAllBalls();
  1948. X    currentPaddleSize   = PADDLE_HUGE;
  1949. X    ResetPaddleStart(display, window);
  1950. X    ResetBallStart(display, playWindow);
  1951. X
  1952. X    ClearBullets();
  1953. X    SetNumberBullets(NUMBER_OF_BULLETS_NEW_LEVEL);
  1954. X    ResetNumberBonus();
  1955. X
  1956. X    TurnSpecialsOff(display);        
  1957. X    SetReverseOff();
  1958. X    DisplayScore(display, scoreWindow, score);
  1959. X    DisplayLevelInfo(display, levelWindow, level);
  1960. X    DrawSpecials(display);
  1961. X
  1962. X    /* map the level number for the filename so that after the maximum
  1963. X     * level is reached it will wrap around to 1 again but will not
  1964. X       * affect the level number
  1965. X        */
  1966. X       newLevel = level % (MAX_NUM_LEVELS + 1);
  1967. X      if (newLevel == 0) newLevel = 1;
  1968. X
  1969. X    /* Construct the level filename */
  1970. X    if ((str = getenv("XBOING_LEVELS_DIR")) != NULL)
  1971. X        sprintf(levelPath, "%s/level%ld.data", str, newLevel);
  1972. X    else
  1973. X        sprintf(levelPath, "%s/level%ld.data", LEVEL_INSTALL_DIR, newLevel);
  1974. X
  1975. X    if (ReadNextLevel(display, window, levelPath) == False)
  1976. X        ShutDown(display, 1, "Sorry, email: jck@citri.edu.au with bug.");
  1977. X    
  1978. X    /* Display level name for all to see */
  1979. X    sprintf(str2, "- %s -", GetLevelName());
  1980. X    SetCurrentMessage(display, messWindow, str2, True);
  1981. X
  1982. X    XFlush(display);
  1983. X}
  1984. END_OF_FILE
  1985. if test 55711 -ne `wc -c <'blocks.c'`; then
  1986.     echo shar: \"'blocks.c'\" unpacked with wrong size!
  1987. fi
  1988. # end of 'blocks.c'
  1989. fi
  1990. echo shar: End of archive 2 \(of 30\).
  1991. cp /dev/null ark2isdone
  1992. MISSING=""
  1993. 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 27 28 29 30 ; do
  1994.     if test ! -f ark${I}isdone ; then
  1995.     MISSING="${MISSING} ${I}"
  1996.     fi
  1997. done
  1998. if test "${MISSING}" = "" ; then
  1999.     echo You have unpacked all 30 archives.
  2000.     echo "Now execute sdecode.sh to build files."
  2001.     rm -f ark[1-9]isdone ark[1-9][0-9]isdone
  2002. else
  2003.     echo You still need to unpack the following archives:
  2004.     echo "        " ${MISSING}
  2005. fi
  2006. ##  End of shell archive.
  2007. exit 0
  2008.