home *** CD-ROM | disk | FTP | other *** search
/ Source Code 1994 March / Source_Code_CD-ROM_Walnut_Creek_March_1994.iso / compsrcs / x / volume20 / xboing / part09 < prev    next >
Encoding:
Text File  |  1993-09-03  |  55.1 KB  |  2,147 lines
  1. Newsgroups: comp.sources.x
  2. From: jck@kimba.catt.citri.edu.au (Justin Kibell)
  3. Subject: v20i116:  xboing - a simple blockout type game, Part09/26
  4. Message-ID: <1993Sep3.123236.7290@sparky.sterling.com>
  5. X-Md4-Signature: 238ed23b807b02c28a7d0a546b3751ff
  6. Sender: chris@sparky.sterling.com (Chris Olson)
  7. Organization: Sterling Software
  8. Date: Fri, 3 Sep 1993 12:32:36 GMT
  9. Approved: chris@sterling.com
  10.  
  11. Submitted-by: jck@kimba.catt.citri.edu.au (Justin Kibell)
  12. Posting-number: Volume 20, Issue 116
  13. Archive-name: xboing/part09
  14. Environment: X11, xpm, color
  15.  
  16. #! /bin/sh
  17. # This is a shell archive.  Remove anything before this line, then feed it
  18. # into a shell via "sh file" or similar.  To overwrite existing files,
  19. # type "sh file -c".
  20. # Contents:  main.c sounds/weeek.au.uue xab
  21. # Wrapped by chris@sparky on Fri Sep  3 07:14:45 1993
  22. PATH=/bin:/usr/bin:/usr/ucb:/usr/local/bin:/usr/lbin ; export PATH
  23. echo If this archive is complete, you will see the following message:
  24. echo '          "shar: End of archive 9 (of 26)."'
  25. if test -f 'main.c' -a "${1}" != "-c" ; then 
  26.   echo shar: Will not clobber existing file \"'main.c'\"
  27. else
  28.   echo shar: Extracting \"'main.c'\" \(22087 characters\)
  29.   sed "s/^X//" >'main.c' <<'END_OF_FILE'
  30. X#include "copyright.h"
  31. X
  32. X/*
  33. X *  Include file dependencies:
  34. X */
  35. X
  36. X#include <stdio.h>
  37. X#include <stdlib.h>
  38. X#include <stddef.h>
  39. X#include <X11/Xlib.h>
  40. X#include <X11/Xutil.h>
  41. X#include <X11/Xos.h>
  42. X#include <X11/keysym.h>
  43. X
  44. X#include "score.h"
  45. X#include "presents.h"
  46. X#include "special.h"
  47. X#include "audio.h"
  48. X#include "mess.h"
  49. X#include "ball.h"
  50. X#include "gun.h"
  51. X#include "sfx.h"
  52. X#include "init.h"
  53. X#include "blocks.h"
  54. X#include "level.h"
  55. X#include "bonus.h"
  56. X#include "stage.h"
  57. X#include "paddle.h"
  58. X#include "intro.h"
  59. X#include "inst.h"
  60. X#include "highscore.h"
  61. X#include "keys.h"
  62. X
  63. X#include "main.h"
  64. X
  65. X/*
  66. X *  Internal macro definitions:
  67. X */
  68. X
  69. X#define PADDLE_ANIMATE_DELAY    5
  70. X#define BONUS_SEED                2000    
  71. X
  72. X/*
  73. X *  Internal type declarations:
  74. X */
  75. X
  76. X#if NeedFunctionPrototypes
  77. Xstatic KeySym     GetKeySym(XEvent event);
  78. Xstatic void     handleGameMode(Display *display);
  79. Xstatic void     handleEventLoop(Display *display);
  80. Xstatic void     ToggleGamePaused(Display *display, Window window);
  81. Xstatic void     SetGamePaused(Display *display);
  82. Xstatic void     handleGameStates(Display *display);
  83. Xstatic void     sleepSync(Display *display, unsigned long ms);
  84. X#else
  85. Xstatic void     sleepSync();
  86. Xstatic void     handleGameStates();
  87. Xstatic KeySym     GetKeySym();
  88. Xstatic void     handleGameMode();
  89. Xstatic void     handleEventLoop();
  90. Xstatic void     ToggleGamePaused();
  91. Xstatic void     SetGamePaused();
  92. X#endif
  93. X
  94. X/*
  95. X *  Internal variable declarations:
  96. X */
  97. X
  98. X
  99. Xint paddleMotion = 0;
  100. Xint paddleDx = 0;
  101. Xint speedLevel = 5;
  102. Xint frame, gameActive;
  103. Xint mode;
  104. Xstatic int iconified = False;
  105. Xlong speed;
  106. Xstatic int userDelay = 1;
  107. Xstatic int paddleControl;
  108. Xstatic time_t pauseStartTime;
  109. Xtime_t pausedTime;
  110. X
  111. X#if NeedFunctionPrototypes
  112. Xvoid SetUserSpeed(int delay)
  113. X#else
  114. Xvoid SetUserSpeed(delay)
  115. X    int delay;
  116. X#endif
  117. X{
  118. X    int temp;
  119. X
  120. X    /* Set an entire game speedup or slowdown speed */
  121. X    temp = (long) (speed / userDelay);
  122. X    userDelay = delay;
  123. X    speed = (long) (temp * userDelay);
  124. X    speedLevel = 10 - delay;
  125. X}
  126. X
  127. X#if NeedFunctionPrototypes
  128. Xint GetPaddleControlMode(void)
  129. X#else
  130. Xint GetPaddleControlMode()
  131. X#endif
  132. X{
  133. X    /* Get the paddle control mode */
  134. X    return paddleControl;
  135. X}
  136. X
  137. X#if NeedFunctionPrototypes
  138. Xvoid SetPaddleControlMode(int type)
  139. X#else
  140. Xvoid SetPaddleControlMode(type)
  141. X    int type;
  142. X#endif
  143. X{
  144. X    /* Set the paddle control mode to the new mode */
  145. X    paddleControl = type;
  146. X}
  147. X
  148. X#if NeedFunctionPrototypes
  149. Xvoid SetGameSpeed(int delay)
  150. X#else
  151. Xvoid SetGameSpeed(delay)
  152. X    int delay;
  153. X#endif
  154. X{
  155. X    /* This is the speed used in the sleeping routine */
  156. X    if (delay >= 0)
  157. X        speed = (long) (delay * userDelay);
  158. X}
  159. X
  160. X#if NeedFunctionPrototypes
  161. Xstatic void sleepSync(Display *display, unsigned long ms)
  162. X#else
  163. Xstatic void sleepSync(display, ms)
  164. X    Display *display;
  165. X    unsigned long ms;
  166. X#endif
  167. X{
  168. X    struct timeval st, et;
  169. X    long SyncTime;
  170. X
  171. X    gettimeofday(&st, NULL);
  172. X    XSync(display, False);
  173. X    gettimeofday(&et, NULL);
  174. X
  175. X    SyncTime = (((et.tv_sec - st.tv_sec) * 1000) +
  176. X               ((et.tv_usec - st.tv_usec) / 1000) );
  177. X
  178. X    if ((ms) > ((1000 / 60) + SyncTime))
  179. X        ms_sleep(ms - SyncTime);
  180. X}
  181. X
  182. X#if NeedFunctionPrototypes
  183. Xstatic KeySym GetKeySym(XEvent event)
  184. X#else
  185. Xstatic KeySym GetKeySym(event)
  186. X    XEvent event;
  187. X#endif
  188. X{
  189. X    int count;
  190. X    char key;
  191. X    KeySym keysym;
  192. X    XComposeStatus compose;
  193. X
  194. X    /* Lookup a keysym using the event key */
  195. X    count = XLookupString(&event.xkey, &key, 1, &keysym, &compose);
  196. X
  197. X    return keysym;
  198. X}
  199. X
  200. X#if NeedFunctionPrototypes
  201. Xint paddleIsMoving(void)
  202. X#else
  203. Xint paddleIsMoving()
  204. X#endif
  205. X{
  206. X    /* Returns direction of paddle 1 right -1 left 0 stopped */
  207. X    return paddleMotion;
  208. X}
  209. X
  210. X#if NeedFunctionPrototypes
  211. Xvoid handlePaddleMoving(Display *display)
  212. X#else
  213. Xvoid handlePaddleMoving(display)
  214. X    Display *display;
  215. X#endif
  216. X{
  217. X    static oldx = 0;
  218. X    int rx, ry, x, y;
  219. X    unsigned int mask;
  220. X    Window root, child;
  221. X
  222. X    if (paddleControl == CONTROL_KEYS)
  223. X    {
  224. X        switch (paddleMotion)
  225. X        {
  226. X            case 1:        /* Move the paddle to the right 1 increment */
  227. X                MovePaddle(display, playWindow, 
  228. X                    PADDLE_RIGHT, currentPaddleSize, 0);
  229. X                break;
  230. X
  231. X            case -1:        /* Move the paddle to the left 1 increment */
  232. X                MovePaddle(display, playWindow, 
  233. X                    PADDLE_LEFT, currentPaddleSize, 0);
  234. X                break;
  235. X
  236. X            default:
  237. X                break;
  238. X        }
  239. X    } else if (paddleControl == CONTROL_MOUSE)
  240. X    {
  241. X        /* Obtain the position of the pointer in the play window */
  242. X        if (XQueryPointer(display, playWindow, &root, &child, 
  243. X            &rx, &ry, &x, &y, &mask) == True)
  244. X        {
  245. X            /* Has the pointer moved since our last poll */
  246. X            if (x != oldx)
  247. X            {
  248. X                paddleDx = x - oldx;
  249. X
  250. X                /* Move the paddle to the position of the mouse pointer */
  251. X                MovePaddle(display, playWindow, 
  252. X                    PADDLE_NONE, currentPaddleSize, x);
  253. X                oldx = x;
  254. X
  255. X                /* Adjust the paddle motion variable so the ball moves when in
  256. X                 * the BALL_READY state and BALL_CREATE state.
  257. X                 */
  258. X                if (x > oldx)
  259. X                    paddleMotion = 1;
  260. X                else
  261. X                    paddleMotion = -1;
  262. X            }
  263. X            else
  264. X            {
  265. X                /* Reset to no motion */
  266. X                paddleMotion = 0;
  267. X                paddleDx = 0;
  268. X            }
  269. X        }
  270. X    }
  271. X}
  272. X
  273. X
  274. X#if NeedFunctionPrototypes
  275. Xstatic void ToggleGamePaused(Display *display, Window window)
  276. X#else
  277. Xstatic void ToggleGamePaused(display, window)
  278. X    Display *display;
  279. X    Window window;
  280. X#endif
  281. X{
  282. X    if (mode == MODE_PAUSE)
  283. X    {
  284. X        /* Finished pause resume game */
  285. X        mode = MODE_GAME;
  286. X        SetCurrentMessage(display, messWindow, "- Play ball -", False);
  287. X        
  288. X        /* How many seconds were we paused for? */
  289. X        pausedTime += (time(NULL) - pauseStartTime);
  290. X
  291. X         XSelectInput(display, mainWindow, 
  292. X            KeyPressMask | KeyReleaseMask | ButtonPressMask |
  293. X               ButtonReleaseMask | ExposureMask | StructureNotifyMask);
  294. X
  295. X         GrabPointer(display, window);
  296. X    }
  297. X    else 
  298. X        SetGamePaused(display);
  299. X}
  300. X
  301. X#if NeedFunctionPrototypes
  302. Xstatic void SetGamePaused(Display *display)
  303. X#else
  304. Xstatic void SetGamePaused(display)
  305. X    Display *display;
  306. X#endif
  307. X{
  308. X    if (mode == MODE_GAME)
  309. X    {
  310. X        /* Set game to paused mode */
  311. X        mode = MODE_PAUSE;
  312. X        SetCurrentMessage(display, messWindow, 
  313. X            "- Game paused -", False);
  314. X        
  315. X        /* we need to keep track of how long we were paused so that later
  316. X         * in the highscore thing I can take that off the time.
  317. X         */
  318. X        pauseStartTime = time(NULL);
  319. X
  320. X        XSelectInput(display, mainWindow, 
  321. X            KeyPressMask | ExposureMask | StructureNotifyMask);
  322. X
  323. X        UnGrabPointer(display);
  324. X    }
  325. X}
  326. X
  327. X#if NeedFunctionPrototypes
  328. Xvoid handleIconify(Display *display, XUnmapEvent *event)
  329. X#else
  330. Xvoid handleIconify(display, event)
  331. X    Display *display;
  332. X    XUnmapEvent *event;
  333. X#endif
  334. X{
  335. X    ToggleGamePaused(display, mainWindow);
  336. X}
  337. X
  338. X#if NeedFunctionPrototypes
  339. Xvoid SelectiveRedraw(Display *display)
  340. X#else
  341. Xvoid SelectiveRedraw(display)
  342. X    Display *display;
  343. X#endif
  344. X{
  345. X    switch (mode)
  346. X    {
  347. X        case MODE_GAME:
  348. X        case MODE_PAUSE:
  349. X            RedrawPlayWindow(display, playWindow);
  350. X            break;
  351. X
  352. X        case MODE_INTRO:
  353. X            RedrawIntroduction(display, playWindow);
  354. X            break;
  355. X
  356. X        case MODE_INSTRUCT:
  357. X            RedrawInstructions(display, playWindow);
  358. X            break;
  359. X
  360. X        case MODE_KEYS:
  361. X            RedrawKeys(display, playWindow);
  362. X            break;
  363. X
  364. X        case MODE_BONUS:
  365. X            RedrawBonus(display, mainWindow);
  366. X            break;
  367. X
  368. X        case MODE_HIGHSCORE:
  369. X            RedrawHighScore(display, playWindow);
  370. X            break;
  371. X
  372. X        default:
  373. X            break;
  374. X    }
  375. X
  376. X    /* Redisplay the message and the level/score info */
  377. X    RedrawLevelInfo(display, levelWindow);
  378. X    DisplayCurrentMessage(display, messWindow);
  379. X
  380. X    /* To be sure - to be sure */
  381. X    XFlush(display);
  382. X}
  383. X
  384. X#if NeedFunctionPrototypes
  385. Xvoid handleExposure(Display *display, XEvent event)
  386. X#else
  387. Xvoid handleExposure(display, event)
  388. X    Display *display;
  389. X    XEvent event;
  390. X#endif
  391. X{
  392. X    /* Only redraw window once so wait until all expose events have sent
  393. X     * and then redraw all that we need to redraw based on current game
  394. X     * mode.
  395. X     */
  396. X    if (event.xexpose.count == 0)
  397. X        SelectiveRedraw(display);
  398. X}
  399. X
  400. X#if NeedFunctionPrototypes
  401. Xvoid handleMouseButtons(Display *display, XEvent event, int Down)
  402. X#else
  403. Xvoid handleMouseButtons(display, event, Down)
  404. X    Display *display;
  405. X    XEvent event;
  406. X    int Down;
  407. X#endif
  408. X{
  409. X    if (Down == True)
  410. X    {
  411. X        /* Button pressed down */
  412. X        switch(event.xbutton.button)
  413. X        {
  414. X            /* Shoot a bullet */
  415. X            case Button1:
  416. X            case Button2: 
  417. X            case Button3:
  418. X                /* If we are playing the game and a ball needs to be started
  419. X                 * then start it otherwise shoot a bullet.
  420. X                 */
  421. X                if (mode == MODE_GAME)
  422. X                    if (ActivateWaitingBall() == False)
  423. X                        shootBullet(display, playWindow);
  424. X                break;
  425. X        }
  426. X    }
  427. X}
  428. X
  429. X#if NeedFunctionPrototypes
  430. Xvoid handleKeyPress(Display *display, KeySym keysym, int Pressed)
  431. X#else
  432. Xvoid handleKeyPress(display, keysym, Pressed)
  433. X    Display *display;
  434. X    KeySym keysym;
  435. X    int Pressed;
  436. X#endif
  437. X{
  438. X    int temp;
  439. X
  440. X    if (Pressed == False)
  441. X    {
  442. X        /* key was released */
  443. X        paddleMotion = 0;
  444. X    }
  445. X    else
  446. X    {
  447. X        /* Switch on the key just pressed down */
  448. X        switch (keysym)
  449. X        {
  450. X            case XK_Left:
  451. X            case XK_j:
  452. X            case XK_J:
  453. X                /* Set paddle to move left */
  454. X                if (mode == MODE_GAME)
  455. X                    paddleMotion = -1;
  456. X                break;
  457. X    
  458. X            case XK_k:
  459. X            case XK_K:
  460. X                /* Shoot a bullet if available */
  461. X                if (mode == MODE_GAME)
  462. X                    if (ActivateWaitingBall() == False)
  463. X                        shootBullet(display, playWindow);
  464. X                break;
  465. X    
  466. X            case XK_Right:
  467. X            case XK_l:
  468. X            case XK_L:
  469. X                /* Set paddle to move right */
  470. X                if (mode == MODE_GAME)
  471. X                    paddleMotion = 1;
  472. X                break;
  473. X
  474. X            case XK_Escape:
  475. X                if (mode == MODE_GAME)
  476. X                {
  477. X                    /* Abort game and return to intros */
  478. X                    SetGameSpeed(FAST_SPEED);
  479. X                    ResetIntroduction();
  480. X                    mode = MODE_INTRO;
  481. X
  482. X                    SetCurrentMessage(display, messWindow, 
  483. X                        "Game aborted.", True);
  484. X                }
  485. X                break;
  486. X
  487. X            case XK_minus:
  488. X                if (mode == MODE_GAME)
  489. X                {
  490. X                    SkipToNextLevel(display, playWindow);
  491. X                    SetCurrentMessage(display, messWindow,
  492. X                        "Skipping to next level ...", True);
  493. X                }
  494. X                break;
  495. X
  496. X            case XK_space:
  497. X                if (mode == MODE_INTRO || mode == MODE_HIGHSCORE 
  498. X                  || mode == MODE_INSTRUCT || mode == MODE_KEYS)
  499. X                {
  500. X                    SetGameSpeed(FAST_SPEED);
  501. X                    gameActive = False;
  502. X                    mode = MODE_GAME;
  503. X                }
  504. X
  505. X                if (mode == MODE_BONUS)
  506. X                    SetBonusWait(BONUS_FINISH, frame);
  507. X                else if (mode == MODE_PRESENTS)    
  508. X                    QuickFinish(display, mainWindow);
  509. X                break;
  510. X
  511. X
  512. X            case XK_H:    /* Personal highscores */
  513. X                if (mode == MODE_INTRO || mode == MODE_INSTRUCT 
  514. X                    || mode == MODE_KEYS || mode == MODE_HIGHSCORE)
  515. X                {
  516. X                    SetGameSpeed(FAST_SPEED);
  517. X                    ResetHighScore(PERSONAL);
  518. X                    mode = MODE_HIGHSCORE;
  519. X
  520. X                    /* Play a bit of sound */
  521. X                    if (noSound == False)
  522. X                        playSoundFile("toggle", 50);
  523. X                    
  524. X                }
  525. X                break;
  526. X
  527. X            case XK_h:    /* Global highscores */
  528. X                if (mode == MODE_INTRO || mode == MODE_INSTRUCT 
  529. X                    || mode == MODE_KEYS || mode == MODE_HIGHSCORE)
  530. X                {
  531. X                    SetGameSpeed(FAST_SPEED);
  532. X                    ResetHighScore(GLOBAL);
  533. X                    mode = MODE_HIGHSCORE;
  534. X
  535. X                    /* Play a bit of sound */
  536. X                    if (noSound == False)
  537. X                        playSoundFile("toggle", 50);
  538. X                }
  539. X                break;
  540. X
  541. X            case XK_c:
  542. X            case XK_C:
  543. X                /* Cycle through the introduction screens if note in a game */
  544. X                if (mode == MODE_INTRO)
  545. X                {
  546. X                    SetGameSpeed(FAST_SPEED);
  547. X                    ResetInstructions();
  548. X                    mode = MODE_INSTRUCT;
  549. X                } else if (mode == MODE_INSTRUCT)
  550. X                {
  551. X                    SetGameSpeed(FAST_SPEED);
  552. X                    ResetKeys();
  553. X                    mode = MODE_KEYS;
  554. X                } else if (mode == MODE_KEYS)
  555. X                {
  556. X                    SetGameSpeed(FAST_SPEED);
  557. X                    ResetHighScore(GLOBAL);
  558. X                    mode = MODE_HIGHSCORE;
  559. X                } else if (mode == MODE_HIGHSCORE)
  560. X                {
  561. X                    SetGameSpeed(FAST_SPEED);
  562. X                    ResetIntroduction();
  563. X                    mode = MODE_INTRO;
  564. X                } 
  565. X                break;
  566. X
  567. X            case XK_a:
  568. X            case XK_A:
  569. X                if (noSound == False)
  570. X                {
  571. X                    /* Try and turn audio off */
  572. X                    FreeAudioSystem();
  573. X
  574. X                    noSound = True;
  575. X                    SetCurrentMessage(display, messWindow, 
  576. X                        "- Audio OFF -", True);
  577. X                }
  578. X                else
  579. X                {
  580. X                    /* Try and turn audio on */
  581. X                    if (SetUpAudioSystem(display) == False)
  582. X                    {
  583. X                        /* Unable to turn audio on */
  584. X                        noSound = True;
  585. X                        SetCurrentMessage(display, messWindow, 
  586. X                            "- Audio unavailable -", True);
  587. X                    }
  588. X                    else
  589. X                    {
  590. X                        /* Audio is now active */
  591. X                        noSound = False;
  592. X                        SetCurrentMessage(display, messWindow, 
  593. X                            "- Audio ON -", True);
  594. X                    }
  595. X                }
  596. X                break;
  597. X
  598. X            case XK_s:
  599. X            case XK_S:
  600. X                if (mode == MODE_INTRO || mode == MODE_INSTRUCT 
  601. X                    || mode == MODE_KEYS || mode == MODE_HIGHSCORE)
  602. X                {
  603. X                    /* toggle the special effects system */
  604. X                    if (getSpecialEffects(display) == True)
  605. X                    {
  606. X                        /* Turn off special effects */
  607. X                        useSpecialEffects(False);
  608. X
  609. X                        SetCurrentMessage(display, messWindow, 
  610. X                            "- SFX OFF -", True);
  611. X                    }
  612. X                    else
  613. X                    {
  614. X                        /* Cannot use sfx on this display */
  615. X                        if (getSpecialEffects(display) == -1)
  616. X                        {
  617. X                            SetCurrentMessage(display, messWindow, 
  618. X                                "- SFX Unavailable -", True);
  619. X                        }
  620. X                        else
  621. X                        {
  622. X                            /* Try and turn on special effects */
  623. X                            useSpecialEffects(True);
  624. X
  625. X                            SetCurrentMessage(display, messWindow, 
  626. X                                "- SFX ON -", True);
  627. X                        }
  628. X                    }
  629. X                }
  630. X                break;
  631. X
  632. X            case XK_g:
  633. X            case XK_G:
  634. X                /* Toggle game mode */
  635. X                if (GetPaddleControlMode() == CONTROL_KEYS)
  636. X                {
  637. X                    SetCurrentMessage(display, messWindow, 
  638. X                        "Control: Mouse", True);
  639. X                    SetPaddleControlMode(CONTROL_MOUSE);
  640. X                }
  641. X                else
  642. X                {
  643. X                    SetCurrentMessage(display, messWindow, 
  644. X                        "Control: Keys", True);
  645. X                    SetPaddleControlMode(CONTROL_KEYS);
  646. X                }
  647. X
  648. X                /* Play a bit of sound */
  649. X                if (noSound == False)
  650. X                    playSoundFile("toggle", 50);
  651. X                    
  652. X                /* If looking at the keys screen then update the text
  653. X                 * indicating which control mode you are using.
  654. X                 */
  655. X                if (mode == MODE_KEYS)
  656. X                    RedrawKeys(display, playWindow);
  657. X
  658. X                break;
  659. X
  660. X            case XK_p:
  661. X            case XK_P:
  662. X                ToggleGamePaused(display, mainWindow);
  663. X                break;
  664. X
  665. X            case XK_i:
  666. X            case XK_I:
  667. X                /* Iconify the window quickly */
  668. X                XIconifyWindow(display, mainWindow, 0);
  669. X                break;
  670. X
  671. X            case XK_d:    
  672. X            case XK_D:    
  673. X                /* Kill the ball - why I don't know */
  674. X                if (mode == MODE_GAME)
  675. X                {
  676. X                    if ((temp = GetAnActiveBall()) >= 0)
  677. X                    {
  678. X                        /* Erase and reset ball to new one */
  679. X                        ClearBallNow(display, playWindow, temp);
  680. X                    }
  681. X
  682. X                }
  683. X                break;
  684. X
  685. X            case XK_1:    /* Set speed to speed 1 */
  686. X                SetUserSpeed(9);
  687. X                SetCurrentMessage(display, messWindow, "Warp 1", True);
  688. X                if (noSound == False) playSoundFile("tone1", 50);
  689. X                break;
  690. X
  691. X            case XK_2:    /* Set speed to speed 2 */
  692. X                SetUserSpeed(8);
  693. X                SetCurrentMessage(display, messWindow, "Warp 2", True);
  694. X                if (noSound == False) playSoundFile("tone2", 50);
  695. X                break;
  696. X
  697. X            case XK_3:    /* Set speed to speed 3 */
  698. X                SetUserSpeed(7);
  699. X                SetCurrentMessage(display, messWindow, "Warp 3", True);
  700. X                if (noSound == False) playSoundFile("tone3", 50);
  701. X                break;
  702. X
  703. X            case XK_4:    /* Set speed to speed 4 */
  704. X                SetUserSpeed(6);
  705. X                SetCurrentMessage(display, messWindow, "Warp 4", True);
  706. X                if (noSound == False) playSoundFile("tone4", 50);
  707. X                break;
  708. X
  709. X            case XK_5:    /* Set speed to speed 5 */
  710. X                SetUserSpeed(5);
  711. X                SetCurrentMessage(display, messWindow, "Warp 5", True);
  712. X                if (noSound == False) playSoundFile("tone5", 50);
  713. X                break;
  714. X
  715. X            case XK_6:    /* Set speed to speed 6 */
  716. X                SetUserSpeed(4);
  717. X                SetCurrentMessage(display, messWindow, "Warp 6", True);
  718. X                if (noSound == False) playSoundFile("tone6", 50);
  719. X                break;
  720. X
  721. X            case XK_7:    /* Set speed to speed 7 */
  722. X                SetUserSpeed(3);
  723. X                SetCurrentMessage(display, messWindow, "Warp 7", True);
  724. X                if (noSound == False) playSoundFile("tone7", 50);
  725. X                break;
  726. X
  727. X            case XK_8:    /* Set speed to speed 8 */
  728. X                SetUserSpeed(2);
  729. X                SetCurrentMessage(display, messWindow, "Warp 8", True);
  730. X                if (noSound == False) playSoundFile("tone8", 50);
  731. X                break;
  732. X
  733. X            case XK_9:    /* Set speed to speed 9 */
  734. X                SetUserSpeed(1);
  735. X                SetCurrentMessage(display, messWindow, "Warp 9", True);
  736. X                if (noSound == False) playSoundFile("tone9", 50);
  737. X                break;
  738. X
  739. X            case XK_Q:
  740. X            case XK_q:
  741. X                if (mode == MODE_GAME || mode == MODE_BONUS)
  742. X                {
  743. X                    /* Save out scores when quitting */
  744. X                    UpdateHighScores();
  745. X                }
  746. X
  747. X                /* Shut down and exit game */
  748. X                ShutDown(display, 0, "Thank you for playing XBoing.");
  749. X                break;
  750. X
  751. X            default:
  752. X                /* Do nothing */
  753. X                break;
  754. X        }
  755. X    }
  756. X}
  757. X
  758. X#if NeedFunctionPrototypes
  759. Xstatic void handleGameMode(Display *display)
  760. X#else
  761. Xstatic void handleGameMode(display)
  762. X    Display *display;
  763. X#endif
  764. X{
  765. X    static int bonusRow = 0;
  766. X    static int bonusCol = 0;
  767. X    static int nextBonusFrame = 0;
  768. X
  769. X    /* If we are going to play then setup first level */
  770. X    if (gameActive == False)
  771. X    {
  772. X        /* Choose a random velocity for the ball */
  773. X
  774. X        /* Always start at level 1 or level specified */
  775. X        SetLevelNumber(GetStartingLevel());
  776. X
  777. X        /* Set some important variables */
  778. X        livesLeft             = 3;
  779. X        score                 = 0;
  780. X        nextBonusFrame         = 0;
  781. X        currentPaddleSize     = PADDLE_HUGE;
  782. X        pausedTime            = 0;
  783. X        bonusBlock             = False;
  784. X
  785. X        /* Setup the stage and load 1st level */
  786. X        SetupStage(display, playWindow);
  787. X
  788. X        /* Start game play */
  789. X        gameActive = True;
  790. X
  791. X        /* Keep track of the game duration - shown in highscores */
  792. X        gameTime = time(NULL);
  793. X    }
  794. X
  795. X    /* If we need to move the paddle then do so */
  796. X    if ((frame % PADDLE_ANIMATE_DELAY) == 0)
  797. X        handlePaddleMoving(display);
  798. X
  799. X    if (mode == MODE_GAME)
  800. X    {
  801. X        HandleBallMode(display, playWindow);
  802. X
  803. X        /* Add bonus coin block at random intervals */
  804. X        if (nextBonusFrame == 0 && bonusBlock == False)
  805. X            nextBonusFrame = frame + (rand() % BONUS_SEED);
  806. X
  807. X        /* Do we need to add a bonus coin? */
  808. X        if (nextBonusFrame <= frame && bonusBlock == False)
  809. X        {
  810. X            /* Add the bonus block now - different types */
  811. X            switch (rand() % 10)
  812. X            {
  813. X                case 0: case 1: 
  814. X                case 2: case 3: 
  815. X                case 4: case 5: 
  816. X                case 6: case 7:
  817. X                    /* Add a normal bonus block */
  818. X                    AddBonusBlock(display, playWindow, &bonusRow, &bonusCol, 
  819. X                        BONUS_BLK);
  820. X                    break;
  821. X
  822. X                case 8:
  823. X                    /* Add the x2 bonus block */
  824. X                    AddBonusBlock(display, playWindow, &bonusRow, &bonusCol, 
  825. X                        BONUSX2_BLK);
  826. X                    break;
  827. X
  828. X                case 9:
  829. X                    /* Add the x4 bonus block */
  830. X                    AddBonusBlock(display, playWindow, &bonusRow, &bonusCol, 
  831. X                        BONUSX4_BLK);
  832. X                    break;
  833. X
  834. X            }
  835. X
  836. X            nextBonusFrame = 0;
  837. X        }
  838. X    }
  839. X
  840. X    HandleBulletMode(display, playWindow);
  841. X
  842. X    /* If any blocks need exploding then do so */
  843. X    ExplodeBlocksPending(display, playWindow);
  844. X
  845. X    /* So blocks need animation all the time so do it */
  846. X    HandlePendingAnimations(display, playWindow);
  847. X
  848. X    /* See if the level is finished and update level info if needed */
  849. X    if (mode == MODE_GAME)
  850. X        CheckGameRules(display, playWindow);
  851. X}
  852. X
  853. X#if NeedFunctionPrototypes
  854. Xstatic void handleGameStates(Display *display)
  855. X#else
  856. Xstatic void handleGameStates(display)
  857. X    Display *display;
  858. X#endif
  859. X{
  860. X    /* Update the message window if any new messages come along */
  861. X    DisplayCurrentMessage(display, messWindow);
  862. X
  863. X    /* In game effects */
  864. X    switch (currentSfxMode())
  865. X    {
  866. X        case SFX_SHAKE:
  867. X            /* Something exploded or bumped the screen */
  868. X            WindowShakeEffect(display, playWindow);
  869. X            break;
  870. X
  871. X        case SFX_NONE:
  872. X        default:
  873. X            break;
  874. X    }
  875. X
  876. X    switch (mode)
  877. X    {
  878. X        case MODE_GAME:
  879. X            handleGameMode(display);
  880. X            break;
  881. X
  882. X        case MODE_PRESENTS:
  883. X            Presents(display, mainWindow);
  884. X            break;
  885. X
  886. X        case MODE_BONUS:
  887. X            DoBonus(display, mainWindow);
  888. X            break;
  889. X
  890. X        case MODE_INTRO:
  891. X            Introduction(display, playWindow);
  892. X            break;
  893. X
  894. X        case MODE_INSTRUCT:
  895. X            Instructions(display, playWindow);
  896. X            break;
  897. X
  898. X        case MODE_KEYS:
  899. X            Keys(display, playWindow);
  900. X            break;
  901. X
  902. X        case MODE_HIGHSCORE:
  903. X            HighScore(display, playWindow);
  904. X            break;
  905. X
  906. X        case MODE_PAUSE:
  907. X            break;
  908. X    }
  909. X
  910. X    /* Flush the display */
  911. X    XFlush(display);
  912. X}
  913. X
  914. X#if NeedFunctionPrototypes
  915. Xstatic void handleEventLoop(Display *display)
  916. X#else
  917. Xstatic void handleEventLoop(display)
  918. X    Display *display;
  919. X#endif
  920. X{
  921. X    XEvent event;
  922. X    int pending;
  923. X    KeySym keysym;
  924. X
  925. X    pending = frame = 0;
  926. X
  927. X    /* Initial mode for game is Introduction */
  928. X    mode = MODE_PRESENTS;
  929. X
  930. X    /* No special effects yet */
  931. X    changeSfxMode(SFX_NONE);
  932. X
  933. X    /* Flush all events until app is fully mapped */
  934. X    do
  935. X    {
  936. X        /* handle audio device events if they exist */
  937. X        audioDeviceEvents();
  938. X
  939. X        /* Get the next event */
  940. X        XNextEvent(display, &event);
  941. X    }
  942. X    while (event.type != MapNotify);
  943. X
  944. X    /* Grab the pointer to the main window */
  945. X    GrabPointer(display, mainWindow);
  946. X
  947. X    /* Loop forever and ever */
  948. X    while (True)
  949. X    {
  950. X        /* handle and audio device events if supported */
  951. X        audioDeviceEvents();
  952. X
  953. X        /* Sleep a bit if not iconified */
  954. X        if (iconified == False)
  955. X            sleepSync(display, speed);
  956. X
  957. X        /* See if any events are waiting for me to handle */
  958. X        if (iconified == False && mode != MODE_PAUSE)
  959. X        {
  960. X            /* Get an event but don't wait if none arrives */
  961. X            pending = XPending(display);
  962. X            frame++;
  963. X        }
  964. X        else
  965. X        {
  966. X            /* Wait here for an event and then get the number waiting */
  967. X            XPeekEvent(display, &event);
  968. X            pending = XPending(display);
  969. X        }
  970. X        
  971. X        /* Handle any events pending */
  972. X        while (pending > 0)
  973. X        {
  974. X            /* Get the next X event thanks */
  975. X            XNextEvent(display, &event);
  976. X
  977. X            switch(event.type)
  978. X            {
  979. X                case UnmapNotify:
  980. X                    /* Turn off just all events except the mapping ones */
  981. X                    XSelectInput(display, mainWindow, StructureNotifyMask);
  982. X                    handleIconify(display, (XUnmapEvent *) &event);
  983. X                    iconified = True;
  984. X                    break;
  985. X
  986. X                case MapNotify:
  987. X                    /* Turn back on all the events that are needed */
  988. X                    XSelectInput(display, mainWindow, 
  989. X                        KeyPressMask | KeyReleaseMask | ButtonPressMask |
  990. X                           ButtonReleaseMask | ExposureMask | StructureNotifyMask);
  991. X
  992. X                    SelectiveRedraw(display);
  993. X                     GrabPointer(display, mainWindow);
  994. X                    iconified = False;
  995. X
  996. X                    break;
  997. X
  998. X                case ButtonRelease:
  999. X                    handleMouseButtons(display, event, False);
  1000. X                    break;
  1001. X
  1002. X                case ButtonPress:
  1003. X                    handleMouseButtons(display, event, True);
  1004. X                    break;
  1005. X
  1006. X                case KeyRelease:
  1007. X                    keysym = GetKeySym(event);
  1008. X                    handleKeyPress(display, keysym, False);
  1009. X                    break;
  1010. X
  1011. X                case KeyPress:
  1012. X                    keysym = GetKeySym(event);
  1013. X                    handleKeyPress(display, keysym, True);
  1014. X                    break;
  1015. X
  1016. X                case Expose:
  1017. X                    handleExposure(display, event);
  1018. X                    break;
  1019. X
  1020. X                default:
  1021. X                    break;
  1022. X            }
  1023. X
  1024. X            /* Decrement the number of pending events */
  1025. X            pending--;
  1026. X        }
  1027. X
  1028. X        /* handle all game states and animations */
  1029. X        if (iconified == False) 
  1030. X            handleGameStates(display);
  1031. X    }
  1032. X
  1033. X    /* NOT REACHED */
  1034. X}
  1035. X
  1036. X#if NeedFunctionPrototypes
  1037. Xvoid main(int argc, char **argv)
  1038. X#else
  1039. Xvoid main(argc, argv)
  1040. X    int argc;
  1041. X    char **argv;
  1042. X#endif
  1043. X{
  1044. X    static Display *display;
  1045. X
  1046. X    /* Initialise everything and return display */
  1047. X    display = InitialiseGame(argv, argc);
  1048. X
  1049. X    SetGameSpeed(FAST_SPEED);
  1050. X    gameActive = False;
  1051. X    iconified = False;
  1052. X
  1053. X    /* main event loop */
  1054. X    handleEventLoop(display);
  1055. X
  1056. X    /* NOTREACHED */
  1057. X}
  1058. END_OF_FILE
  1059.   if test 22087 -ne `wc -c <'main.c'`; then
  1060.     echo shar: \"'main.c'\" unpacked with wrong size!
  1061.   fi
  1062.   chmod +x 'main.c'
  1063.   # end of 'main.c'
  1064. fi
  1065. if test -f 'sounds/weeek.au.uue' -a "${1}" != "-c" ; then 
  1066.   echo shar: Will not clobber existing file \"'sounds/weeek.au.uue'\"
  1067. else
  1068.   echo shar: Extracting \"'sounds/weeek.au.uue'\" \(4799 characters\)
  1069.   sed "s/^X//" >'sounds/weeek.au.uue' <<'END_OF_FILE'
  1070. Xbegin 664 weeek.au
  1071. XM+G-N9    "    UG     0  'T     !          !S>O[W\^_LZ>CGY.+@
  1072. XMW^#BY.7FYN?J[>_S^?Y]>G=S<6]M;W-V=GA[?OSY^GUY>G=R;6IE85Y=7F!D
  1073. XM9VIJ;7!V?'_Z]O'MZ^GGY>'?W]_@XN3FY^GK[>_S]_KZ^WYY=7-R<W9V='5Z
  1074. XM?7Y_?WIU=75P;6IE7UU=75Y@8V9H:W!X?/[W\>[LZ>?DX=_=W=W>W^'CY>?I
  1075. XM[/#W_OY]>'-O;FYO<7-U>7W[^OO]?'=R<G%N:V=A7EQ<75Y@9&9I;7%W?/KO
  1076. XMZNGGY>3CX-[>WM_AY.?HZ.GJ[O/X_/W_>G=U=GAX>7M\?_[^_G][=F]M;6MH
  1077. XM96!=6UM<7E]B96AK;G)]^N_JZ>?EY.'?WMW=W=[@X^;EYNGL[O/X^_Y]=W1S
  1078. XM;V]O<W9Y>GM[>WUV<&]O;FIG85U<6UQ=7F%F:&IM<GWX[^KHY^7CX-[=W-S=
  1079. XMW^'CY.3EZ.WQ]/K_?7IV<W%O;G!W>W[__?S\?W=O;FYL:&9?7%I96EQ=8&9G
  1080. XM:6UR?/7NZNCGY.'?WMS;V]S=W^'CY>7H[/#U^/Q^>W=S<&]O<'1W>WQ]?GUX
  1081. XM;VQL;&MH96!<6UI;75YA9VEJ;W1^]N_JZ.?DX=_>W-O;W=[?X.'BX^;J[>_U
  1082. XM^?U\>'%N;&QL;G%T=WI\?GQQ;6UL:69D7UQ:65I<7F!F9VEO=_KQ[.?GY>+@
  1083. XMWMW<V]K<W=[?W^'BY>KN\?G^>W=T;FQL;&QO<G9Y>'EW;VMJ:VIG96!<65A9
  1084. XM7%U?9&AJ;'+]].WGY.+@WMW;V]K:W-W?W^#AXN3I[O3X_7MT<G%N;&UN;W-W
  1085. XM?'MW<6MH9VAF8V!<65A96EU>869H:VYU_?#KY.'@W][<V]K:VMO=WM[?X.+F
  1086. XMZ^[R]OG_=6]L:FEI:VYO=7IX<VQF9F9E8F)?6UA76%M>869J:FUS?^_LYN+A
  1087. XMX-_=VMG8V-K;W-[?X.'DZ.[V_7Q[=7%M:FIJ;&UO<WAV<FQG9F=H961A7%E7
  1088. XM5UI=7V5F:&IM>O3NZ>3@W][<VMC8V-G:V]W>WM_BY>KP^GUZ=&]M:6=H:&QO
  1089. XM=7=U;FAC8F5F9&%>6UA765M>86=J;&UN>?+LY^+@WMW<V=?6U]C9V]W>WN#E
  1090. XMZN[T_7MV=&]M:VII:FUR=W9O:&)@86)B8F!=6E=86UY@9&=I;&YT_O#JY-_>
  1091. XMWMS:U];6U]?9V]W?W^'DZ>_Z>W5R;VQI:&IK;&UQ=7%K9&!A9&)?7UU:6%=8
  1092. XM6UUA9VIL;G+^\NOGX=W;VMK8U];5UM?9W-W?X>7I[?'\=V]M;&IG9VAJ;&UP
  1093. XM;FIE86)A7EY>7%I75UE=7V-I;7!O<'GX[>CBWMS:V=C6U=;6U=;8V]W@Y.GM
  1094. XM]/QX;VMI:&=H:FUN;VYI8UY>7EU=7%I85E976EQ@9FUU=W9[^.[IXMW9U]?7
  1095. XMUM;5U=75U]C;WN/H[?+Y?WAO;&EH9F=J;7!M95Y<6EA65E975U=76%E;76%K
  1096. XM>?GQ[.GFXM_=VM?5T]'1T=/6V=K;W=_AY.CN^'MQ:VAF9FEL;FYI8UY;6%11
  1097. XM4%!14U176EQ=7V%F;GKX[>7?V]G8U=34T]+1T=+3U-;8V][BZ.[X?GAR;FMJ
  1098. XM:VQN;&9?7%E544]-34Y/4%-76EU?86AN=OKOY=[;V-;4TM'0S\_/S]?BS\W=
  1099. XMY>_GYOKHV-?:ULS+T'-*1#\[/#X]0D0X-C@T/5%4UK_)Q\G=P+2XMK>^PMM@
  1100. XM^,_#RG!94E+NWM'!T/;DYL.WN;U^,RHO1TY"+1\D*S!/:T]82%JTHZ&MRM"W
  1101. XMJ*O03T ^:G933SPX5<&]Q-?@OK*ZQL3%N:Z_/RDF5<8P'AHFZE0M)CZ[M+/ 
  1102. XML*JSK*RNQTO4Q=,X+$K3338^UK[*U[RXO;NUM+RZMK7T)2/1S!X;)2T_+"D[
  1103. XM2%>QJM_#IJ2IQL"ON<KB2T)68UDY.,W45];'P[ZYN+J\M+=7-S#P92$J,2(N
  1104. XM22DF3FU3R='1M*VNM;ROL+N\S]C!R6Y=Y=OXW6U3T-)NXNQC2SQ.:#<Y2S0W
  1105. XM>$0S4F9!;=A7;\G*WM'$S,S!R\^^OLK Q,_'Q]]LZ>]WY^;P4D3DV3Y-4#1$
  1106. XM5SHX0D8_4V9)5^E\YN3<W-S&T=*^P<*\O;Z[O,78W=[LS<S?U6! 4-=#-CPR
  1107. XM-#TZ/#U$7U57_%]LT]/Y_,W,SL'&Q;NWN[[ Q<K;Z6AOZ6WFZ'E>0UCN1$A+
  1108. XM0$M,4$9%7%-<6%IB5V_?;V;HY-O:V-GBU]K7T]',T,_-SL_.T]G4W.KO[/9M
  1109. XM:5Y:5E543DM+3$Q+3DU+3U555%A>9FE[].W?UM#-RLG'Q\7%Q<;(R,S3U];-
  1110. XMSUA'3$],2$18041,1TM&1TI53TQ-3_O0S.SLW-[/YFN]Q]7#O;V^N;^[R<Z[
  1111. XMQMY2/3@X1D<U-CE(0CY&/#@_94\_2E%TW\7"Q;*MLKJTL+6YN[FZNK/(3%/=
  1112. XM_CHS+R@L,3$G)3 W.#T\.4G O=;0N+*OKK&RKZFLM[*PK[2TK[S?/#M+."\I
  1113. XM(R,F*BDC*"XZ0#I/Y+^OM+BSK:FLKZVOKJVRM;JZMKFXU2\W3#XS*"8F)C,N
  1114. XM(RDM/#XY9F;1L+2YM*^HJZZJL:^KK[*]O+"\5#H\03PR*R,D+# J*"DN.CU,
  1115. XM3EG&MK:XM:VJK*NNLJRJK;*WL;A!2UD[.R\K)R0N+B4L*C W,U=,4+V]N[:T
  1116. XMJZZMJ:^MIZJMLK*P2T;01CHS+"DF*R\D)RPL,S$_3D;-N<*WLJVJKZBIK::I
  1117. XMJZNPPE-LST<R+B@J*"HH(B8J+C P/D]SO;ZZLJZFJJFDIZ.EIZB^[,3J73LL
  1118. XM*R8I+"(A)R,K+BTV.WK"S+BQKZ6FIJ*FH*&EI<;QN=A:.R@I)R<N'AXF("TN
  1119. XM*3@\V+G3LJZLGZ6DH**>H:FZW[W!93TI*"DG+1\=(2(N+"@T.MJYR;>NIY^B
  1120. XMH*"BGJ2VO,'#UD4T*B@L+20>'B0H+"TK.E;%NK^NIZ2>GZ&?IZNON+K17$4W
  1121. XM+RTK)A\A)2,I*"LU/L_&PZVGI)^?GZ>MJJ^TOMY</ST\+2@D(R@F*"@I-D!5
  1122. XMS\>PJ:2@I:NMKJNOO,QJ65U&.2PF+"PJ*R@M-T!N]N&RJ:6HKK*TK:ZXT5=G
  1123. XM[E1(+B8R,#(O*3,]2LK?V["JI:R[OKBSM<).0FUK3SXH+38S/"TL1%3+O<>T
  1124. XMK*JKOKR\O+?434I!3$XN+B\O.3HU.4[8NK6YKZZ\L;#+O<;SSU=!534O/3$N
  1125. XM-3<[7>W(N;VRL-2[L\^\SEW-24W9,C-!-3L].TG;R+JUP[R\QKJ^\NIP[?4_
  1126. XM2C<S/3HZ.3YOPKVWN;K!N;+0P<U8V.9 4#HN1C0O/3A"P\+!M,*]M[:^P<YM
  1127. XMT=9'2$,M/CPN/#E"O,#+M<7-K;3+N]MHN7A <"\R5"\O03?JMN;&OTZPKOF_
  1128. XMV$JXSS]?,3=^.#-*2<6OR,3?V*NZT^1"UL)'2"XL5#PW/3_/L;6_\]*LK[K[
  1129. XM0\C'5U J+4\W/CXZR[>WW52_MZZ^/=_*8,TW*D4_2ME"?;+ S\/5QK3)2^!2
  1130. XM/O(S+4,Y?[Y5S+]IM+CFP-;9OD8V2S@]3T9JQ\#+6L:\Q<-,>=D[4D0N5L_3
  1131. XMQNI?R[G!V&U*U-TV.D1 O\!4SU;6K/]0TDK8:#(Y0UV]S4_7XKNR6WWFZ\P[
  1132. XM,SY&RL5=9/K:K\Q&RFO,WR\_1EVYVT[8<+RS1WC5;,@V,DD_Q,-)[N_=KN!'
  1133. XMQ6+.7"U&0V&W7D_.:;:X/\W0Y<LR.E1(N<I TVS'KT)4Q5O+.B]20<&[/7G>
  1134. XMVJQ:0KYJQTTM3D?.LT),TNBNV#K&YLY8+4)*UK!,0,W<K\,XSLS3:"X\4-^P
  1135. XM5SG0W++ ->')VFDO.5+>KV4VU-"ROC;WQ=%V,3A3SZYQ--[&L,(W6\?,7# U
  1136. XM3,FN73/NOZ_%.5S$RE\P-$[#KU$P8;ROT3=6Q<A9,#52NJY),6NVKN W7,7'
  1137. XM6"\U6K2O/C%MLZYB-ES+QE$O-%RPL3LQ?:^N43I=T,)7+S1KK;,W,O"OL5 \
  1138. XM3-V_6S$S^JNW-S3RK[-=/T#UOF@U,^*KO#LX?+.VZD,Y6\'_.3/CKL-$/V:Z
  1139. XMNLQ,-U#*WD4YWK?/6D]DR<#$6SI)Y^Q21MG(<W[Y^=G.R&Q#4%IA7F3)TU=O
  1140. XMX=;4V-=72UU965%FR-1=9OS:T,S44DM87FY=;-7F:_;IXM[0U5]66%9H:??6
  1141. XMZ6=D;^[FV-Y?5EIA^?7PW^UM;_7L\^3>=F-H8FW^^^_N=&=L_.SBWNM\?GIS
  1142. XM>G=W>W-I96M[[>7G[_=]<')R<7MW;&AH=^WIZNWR^7AX=G?X^7EM:7;Q[.KL
  1143. XM\OMX=&]O???^<6QT^^_IZNWU>'%L;'WY_7MN;WG][^OO^'EN:FMX^/3U_G[_
  1144. XM^^SHZ^WZ<FIG;WW^_'MT<W3Z[NSL]7EN;7?\^/7W_/[\]?#N[_5]<F]P=7O]
  1145. XM^??W^/G[^_GW^GIQ<7-U>_OU\N_R^O[[]?9_>'1Q;W)X>_W[_7U^_?K[_O[]
  1146. XM_/O]_OW[]_3W_/W\_7QZ>GU^>W5R=O_Y^?S\_/Q]>7Q__OU_>GO\^/G[^/?\
  1147. XK?7=U=GAZ>GW^_/O^??SX^GUW>7W__?]_^?3U^?[[^/G^>GK__GUY=WW]_O?\
  1148. X 
  1149. Xend
  1150. END_OF_FILE
  1151.   if test 4799 -ne `wc -c <'sounds/weeek.au.uue'`; then
  1152.     echo shar: \"'sounds/weeek.au.uue'\" unpacked with wrong size!
  1153.   fi
  1154.   # end of 'sounds/weeek.au.uue'
  1155. fi
  1156. if test -f 'xab' -a "${1}" != "-c" ; then 
  1157.   echo shar: Will not clobber existing file \"'xab'\"
  1158. else
  1159.   echo shar: Extracting \"'xab'\" \(24327 characters\)
  1160.   sed "s/^X//" >'xab' <<'END_OF_FILE'
  1161. X                                    frame + EXPLODE_DELAY);
  1162. X                                SetBlockUpForExplosion(r, c+1, 
  1163. X                                    frame + EXPLODE_DELAY);
  1164. X                                SetBlockUpForExplosion(r-1, c, 
  1165. X                                    frame + EXPLODE_DELAY);
  1166. X                                SetBlockUpForExplosion(r, c-1, 
  1167. X                                    frame + EXPLODE_DELAY);
  1168. X                                SetBlockUpForExplosion(r-1, c-1, 
  1169. X                                    frame + EXPLODE_DELAY);
  1170. X                                SetBlockUpForExplosion(r-1, c+1, 
  1171. X                                    frame + EXPLODE_DELAY);
  1172. X                                SetBlockUpForExplosion(r+1, c-1, 
  1173. X                                    frame + EXPLODE_DELAY);
  1174. X                                SetBlockUpForExplosion(r+1, c+1, 
  1175. X                                    frame + EXPLODE_DELAY);
  1176. X
  1177. X                                /* Special effect where screen shakes 
  1178. X                                 * during explosion 
  1179. X                                 */
  1180. X                                SetSfxEndFrame(frame + 70);
  1181. X                                changeSfxMode(SFX_SHAKE);
  1182. X                                break;
  1183. X
  1184. X                            case BULLET_BLK:
  1185. X                                SetCurrentMessage(display, messWindow, 
  1186. X                                    "More ammunition, cool!", True);
  1187. X                                AddABullet(display);
  1188. X                                AddABullet(display);
  1189. X                                AddABullet(display);
  1190. X                                AddABullet(display);
  1191. X                                break;
  1192. X
  1193. X                            case BONUS_BLK:
  1194. X                                IncNumberBonus();
  1195. X
  1196. X                                if (GetNumberBonus() <= MAX_BONUS)
  1197. X                                    sprintf(str, 
  1198. X                                        "- Bonus #%d -", GetNumberBonus());
  1199. X                                else
  1200. X                                    sprintf(str, "- Super Bonus -");
  1201. X
  1202. X                                SetCurrentMessage(display, messWindow, str, 
  1203. X                                    True);
  1204. X                                bonusBlock = False;
  1205. X
  1206. X                                /* Turn on killer mode after 10 bonuses */
  1207. X                                if (GetNumberBonus() == 10)
  1208. X                                {
  1209. X                                    /* Turn on killer mode */
  1210. X                                    ToggleKiller(display, True);
  1211. X                                    DrawSpecials(display);
  1212. X
  1213. X                                    SetCurrentMessage(display, messWindow, 
  1214. X                                        "- Killer Mode -", True);
  1215. X                                }
  1216. X                                break;
  1217. X
  1218. X                            case BONUSX2_BLK:
  1219. X                                Togglex2Bonus(display, True);
  1220. X                                Togglex4Bonus(display, False);
  1221. X                                DrawSpecials(display);
  1222. X
  1223. X                                bonusBlock = False;
  1224. X                                SetCurrentMessage(display, messWindow, 
  1225. X                                    "- x2 Bonus -", True);
  1226. X                                break;
  1227. X
  1228. X                            case BONUSX4_BLK:
  1229. X                                Togglex2Bonus(display, False);
  1230. X                                Togglex4Bonus(display, True);
  1231. X                                DrawSpecials(display);
  1232. X
  1233. X                                bonusBlock = False;
  1234. X                                SetCurrentMessage(display, messWindow, 
  1235. X                                    "- x4 Bonus -", True);
  1236. X                                break;
  1237. X
  1238. X                            default :
  1239. X                                break;
  1240. X                        }
  1241. X
  1242. X                        /* Reset to a non exploding block */
  1243. X                        ClearBlock(r, c);
  1244. X                    }
  1245. X                }
  1246. X            }
  1247. X        }
  1248. X    }
  1249. X}
  1250. X
  1251. X#if NeedFunctionPrototypes
  1252. Xvoid DrawTheBlock(Display *display, Window window, int x, int y, 
  1253. X    int blockType, int slide)
  1254. X#else
  1255. Xvoid DrawTheBlock(display, window, x, y, blockType, slide)
  1256. X    Display *display;
  1257. X    Window window;
  1258. X    int x;
  1259. X    int y; 
  1260. X    int blockType;
  1261. X    int slide;
  1262. X#endif
  1263. X{
  1264. X    switch(blockType)
  1265. X    {
  1266. X        case PAD_SHRINK_BLK:    /* Paddle shrink block */
  1267. X            RenderShape(display, window, paddleshrink,
  1268. X                paddleshrinkM, x, y, 40, 15, True);
  1269. X            break;
  1270. X
  1271. X        case PAD_EXPAND_BLK:    /* Paddle expand block */
  1272. X            RenderShape(display, window, paddleexpand,
  1273. X                paddleexpandM, x, y, 40, 15, True);
  1274. X            break;
  1275. X
  1276. X        case BULLET_BLK:    /* Draw a bullet shape */
  1277. X            RenderShape(display, window, yellowblock, yellowblockM, 
  1278. X                x, y, 40, 20, True);
  1279. X            DrawTheBullet(display, window, x+6, y+10);
  1280. X            DrawTheBullet(display, window, x+15, y+10);
  1281. X            DrawTheBullet(display, window, x+24, y+10);
  1282. X            DrawTheBullet(display, window, x+33, y+10);
  1283. X            break;
  1284. X
  1285. X        case MULTIBALL_BLK:    /* Draw multiple ball block */
  1286. X            RenderShape(display, window, multiball, multiballM, 
  1287. X                x, y, 40, 20, True);
  1288. X            break;
  1289. X
  1290. X        case STICKY_BLK:    /* Draw sticky block */
  1291. X            RenderShape(display, window, sticky, stickyM, 
  1292. X                x, y, 32, 32, True);
  1293. X            break;
  1294. X
  1295. X        case RED_BLK:    /* Draw a red block shape */
  1296. X            RenderShape(display, window, redblock, redblockM, 
  1297. X                x, y, 40, 20, True);
  1298. X            break;
  1299. X
  1300. X        case BLACK_BLK:        /* Draw a solid wall block */    
  1301. X            RenderShape(display, window, blackblock, blackblockM, 
  1302. X                x, y, 50, 30, True);
  1303. X            break;
  1304. X
  1305. X        case GREEN_BLK:        /* Draw a green block */
  1306. X            RenderShape(display, window, greenblock, greenblockM, 
  1307. X                x, y, 40, 20, True);
  1308. X            break;
  1309. X
  1310. X        case BLUE_BLK:        /* Draw a blue block */
  1311. X            RenderShape(display, window, blueblock, blueblockM, 
  1312. X                x, y, 40, 20, True);
  1313. X            break;
  1314. X
  1315. X        case YELLOW_BLK:    /* Draw a yellow block */
  1316. X            RenderShape(display, window, yellowblock, yellowblockM, 
  1317. X                x, y, 40, 20, True);
  1318. X            break;
  1319. X
  1320. X        case TAN_BLK:        /* Draw a tan block */
  1321. X            RenderShape(display, window, tanblock, tanblockM, 
  1322. X                x, y, 40, 20, True);
  1323. X            break;
  1324. X
  1325. X        case PURPLE_BLK:    /* Draw a purple block */
  1326. X            RenderShape(display, window, purpleblock, purpleblockM, 
  1327. X                x, y, 40, 20, True);
  1328. X            break;
  1329. X
  1330. X        case COUNTER_BLK:    /* Draw a frame of counter block */
  1331. X            RenderShape(display, window, counterblock[slide], 
  1332. X                counterblockM[slide], x, y, 40, 20, True);
  1333. X            break;
  1334. X
  1335. X        case BONUSX2_BLK:    /* Draw a bonus x2 coin block */
  1336. X            RenderShape(display, window, x2bonus[slide], 
  1337. X                x2bonusM[slide], x, y, 27, 27, True);
  1338. X            break;
  1339. X
  1340. X        case BONUSX4_BLK:    /* Draw a bonus x4 coin block */
  1341. X            RenderShape(display, window, x4bonus[slide], 
  1342. X                x4bonusM[slide], x, y, 27, 27, True);
  1343. X            break;
  1344. X
  1345. X        case BONUS_BLK:    /* Draw a bonus coin block */
  1346. X            RenderShape(display, window, Bonus[slide], 
  1347. X                BonusM[slide], x, y, 27, 27, True);
  1348. X            break;
  1349. X
  1350. X        case BOMB_BLK:        /* Draw a bomb block */
  1351. X            RenderShape(display, window, bombblock, bombblockM, 
  1352. X                x, y, 30, 30, True);
  1353. X            break;
  1354. X
  1355. X        case DEATH_BLK:        /* Draw the pirate death block */
  1356. X            RenderShape(display, window, death[slide], deathM[slide], 
  1357. X                x, y, 30, 30, True);
  1358. X            break;
  1359. X
  1360. X        case REVERSE_BLK:    /* Draw the reverse block */
  1361. X            RenderShape(display, window, revblock, revblockM, 
  1362. X                x, y, 33, 16, True);
  1363. X            break;
  1364. X
  1365. X        case EXTRABALL_BLK:    /* Draw the extra ball block */
  1366. X            RenderShape(display, window, extraball[slide], extraballM[slide], 
  1367. X                x, y, 30, 19, True);
  1368. X            break;
  1369. X
  1370. X        case HYPERSPACE_BLK:    /* Draw the hyperspace block */
  1371. X            RenderShape(display, window, hyperblock, hyperblockM, 
  1372. X                x, y, 31, 31, True);
  1373. X            break;
  1374. X
  1375. X        case MGUN_BLK:    /* Draw the machine gun block */
  1376. X            RenderShape(display, window, mgunblock, mgunblockM, 
  1377. X                x, y, 35, 15, True);
  1378. X            break;
  1379. X
  1380. X        case WALLOFF_BLK:    /* Draw the wall off block */
  1381. X            RenderShape(display, window, walloffblock, walloffblockM, 
  1382. X                x, y, 27, 23, True);
  1383. X            break;
  1384. X    }
  1385. X}
  1386. X
  1387. X#if NeedFunctionPrototypes
  1388. Xstatic void SetBlockUpForExplosion(int row, int col, int frame)
  1389. X#else
  1390. Xstatic void SetBlockUpForExplosion(row, col, frame)
  1391. X    int row;
  1392. X    int col;
  1393. X    int frame;
  1394. X#endif
  1395. X{
  1396. X    struct aBlock *blockP;
  1397. X
  1398. X    if (row < 0 || row >= MAX_ROW) return;
  1399. X    if (col < 0 || col >= MAX_COL) return;
  1400. X
  1401. X    /* Obtain a pointer to the affected block */
  1402. X    blockP = &blocks[row][col];
  1403. X
  1404. X    /* Do not have any effect on a specials block */
  1405. X    if (blockP->blockType == HYPERSPACE_BLK) return;
  1406. X
  1407. X    /* If it isn't occupied then why blow it up */
  1408. X    if (blockP->occupied == 1 && blockP->exploding == False)
  1409. X    {
  1410. X        /* Keep track of how many blocks are exploding */
  1411. X        blocksExploding++;
  1412. X
  1413. X        /* Some special variables used for timing */
  1414. X        blockP->explodeStartFrame     = frame;
  1415. X        blockP->explodeNextFrame     = frame;
  1416. X        blockP->explodeSlide         = 1;
  1417. X        blockP->exploding             = True;
  1418. X    }
  1419. X}
  1420. X
  1421. X
  1422. X#if NeedFunctionPrototypes
  1423. Xvoid DrawBlock(Display *display, Window window, int row, int col, int blockType)
  1424. X#else
  1425. Xvoid DrawBlock(display, window, row, col, blockType)
  1426. X    Display *display;
  1427. X    Window window;
  1428. X    int row;
  1429. X    int col;
  1430. X    int blockType;
  1431. X#endif
  1432. X{
  1433. X    struct aBlock *blockP;
  1434. X
  1435. X    if (row < 0 || row > MAX_ROW) 
  1436. X    {
  1437. X        ErrorMessage("Block out of bounds row.");
  1438. X        return;
  1439. X    }
  1440. X
  1441. X    if (col < 0 || col > MAX_COL) 
  1442. X    {
  1443. X        ErrorMessage("Block out of bounds column.");
  1444. X        return;
  1445. X    }
  1446. X
  1447. X    /* Pointer to the block in question */
  1448. X    blockP = &blocks[row][col];
  1449. X
  1450. X    switch(blockType)
  1451. X    {
  1452. X        case KILL_BLK:        /* Special block - blow it up */
  1453. X            PlaySoundForBlock(blockP->blockType);
  1454. X
  1455. X            if (blockP->blockType != BLACK_BLK)
  1456. X                SetBlockUpForExplosion(row, col, frame);
  1457. X            break;
  1458. X
  1459. X        default:            /* Your average block - draw it */
  1460. X            DrawTheBlock(display, window, blockP->x, blockP->y, 
  1461. X                blockType, blockP->counterSlide);
  1462. X    }
  1463. X}
  1464. X
  1465. X#if NeedFunctionPrototypes
  1466. Xvoid FreeBlockPixmaps(Display *display)
  1467. X#else
  1468. Xvoid FreeBlockPixmaps(display)
  1469. X    Display *display;
  1470. X#endif
  1471. X{
  1472. X    int i;
  1473. X
  1474. X    /* Free the memory associated with the block pixmaps */
  1475. X    if (redblock)        XFreePixmap(display, redblock);            
  1476. X    if (redblockM)        XFreePixmap(display, redblockM);
  1477. X    if (blueblock)        XFreePixmap(display, blueblock);        
  1478. X    if (blueblockM)        XFreePixmap(display, blueblockM);
  1479. X    if (greenblock)        XFreePixmap(display, greenblock);        
  1480. X    if (greenblockM)    XFreePixmap(display, greenblockM);
  1481. X    if (tanblock)        XFreePixmap(display, tanblock);            
  1482. X    if (tanblockM)        XFreePixmap(display, tanblockM);
  1483. X    if (yellowblock)    XFreePixmap(display, yellowblock);        
  1484. X    if (yellowblockM)    XFreePixmap(display, yellowblockM);
  1485. X    if (purpleblock)    XFreePixmap(display, purpleblock);        
  1486. X    if (purpleblockM)    XFreePixmap(display, purpleblockM);
  1487. X    if (blackblock)        XFreePixmap(display, blackblock);        
  1488. X    if (blackblockM)    XFreePixmap(display, blackblockM);
  1489. X    if (bombblock)        XFreePixmap(display, bombblock);        
  1490. X    if (bombblockM)        XFreePixmap(display, bombblockM);
  1491. X    if (revblock)        XFreePixmap(display, revblock);        
  1492. X    if (revblockM)        XFreePixmap(display, revblockM);
  1493. X    if (hyperblock)        XFreePixmap(display, hyperblock);        
  1494. X    if (hyperblockM)    XFreePixmap(display, hyperblockM);
  1495. X    if (mgunblock)        XFreePixmap(display, mgunblock);        
  1496. X    if (mgunblockM)        XFreePixmap(display, mgunblockM);
  1497. X    if (walloffblock)    XFreePixmap(display, walloffblock);        
  1498. X    if (walloffblockM)    XFreePixmap(display, walloffblockM);
  1499. X    if (multiball)        XFreePixmap(display, multiball);        
  1500. X    if (multiballM)        XFreePixmap(display, multiballM);
  1501. X    if (sticky)            XFreePixmap(display, sticky);        
  1502. X    if (stickyM)        XFreePixmap(display, stickyM);
  1503. X    if (paddleexpand)    XFreePixmap(display, paddleexpand);        
  1504. X    if (paddleexpandM)    XFreePixmap(display, paddleexpandM);
  1505. X    if (paddleshrink)    XFreePixmap(display, paddleshrink);        
  1506. X    if (paddleshrinkM)    XFreePixmap(display, paddleshrinkM);
  1507. X
  1508. X    for (i = 0; i < 5; i++)
  1509. X    {
  1510. X        /* Free the frames for the death block */
  1511. X        if (death[i])    XFreePixmap(display, death[i]);     
  1512. X        if (deathM[i])    XFreePixmap(display, deathM[i]);
  1513. X    }
  1514. X
  1515. X    for (i = 0; i < 6; i++)
  1516. X    {
  1517. X        if (counterblock[i])    XFreePixmap(display, counterblock[i]);     
  1518. X        if (counterblockM[i])    XFreePixmap(display, counterblockM[i]);
  1519. X    }
  1520. X
  1521. X    for (i = 0; i < 4; i++)
  1522. X    {
  1523. X        if (x2bonus[i])            XFreePixmap(display, x2bonus[i]);     
  1524. X        if (x2bonusM[i])        XFreePixmap(display, x2bonusM[i]);
  1525. X
  1526. X        if (x4bonus[i])            XFreePixmap(display, x4bonus[i]);     
  1527. X        if (x4bonusM[i])        XFreePixmap(display, x4bonusM[i]);
  1528. X
  1529. X        if (Bonus[i])            XFreePixmap(display, Bonus[i]);     
  1530. X        if (BonusM[i])            XFreePixmap(display, BonusM[i]);
  1531. X    }
  1532. X
  1533. X    for (i = 0; i < 2; i++)
  1534. X    {
  1535. X        if (extraball[i])        XFreePixmap(display, extraball[i]);     
  1536. X        if (extraballM[i])        XFreePixmap(display, extraballM[i]);
  1537. X    }
  1538. X
  1539. X    for (i = 0; i < 3; i++)
  1540. X    {
  1541. X        if (exgreenblock[i])       XFreePixmap(display, exgreenblock[i]);     
  1542. X        if (exgreenblockM[i])   XFreePixmap(display, exgreenblockM[i]);
  1543. X
  1544. X        if (exyellowblock[i])   XFreePixmap(display, exyellowblock[i]);
  1545. X        if (exyellowblockM[i])  XFreePixmap(display, exyellowblockM[i]);
  1546. X
  1547. X        if (exredblock[i])         XFreePixmap(display, exredblock[i]);
  1548. X        if (exredblockM[i])     XFreePixmap(display, exredblockM[i]);
  1549. X
  1550. X        if (exblueblock[i])     XFreePixmap(display, exblueblock[i]);
  1551. X        if (exblueblockM[i])    XFreePixmap(display, exblueblockM[i]);
  1552. X
  1553. X        if (extanblock[i])         XFreePixmap(display, extanblock[i]);
  1554. X        if (extanblockM[i])     XFreePixmap(display, extanblockM[i]);
  1555. X
  1556. X        if (excounterblock[i])  XFreePixmap(display, excounterblock[i]);
  1557. X        if (excounterblockM[i]) XFreePixmap(display, excounterblockM[i]);
  1558. X
  1559. X        if (exbombblock[i])     XFreePixmap(display, exbombblock[i]);
  1560. X        if (exbombblockM[i])    XFreePixmap(display, exbombblockM[i]);
  1561. X        
  1562. X        if (expurpleblock[i])   XFreePixmap(display, expurpleblock[i]);
  1563. X        if (expurpleblockM[i])  XFreePixmap(display, expurpleblockM[i]);
  1564. X        
  1565. X        if (exx2bonus[i])         XFreePixmap(display, exx2bonus[i]);
  1566. X        if (exx2bonusM[i])         XFreePixmap(display, exx2bonusM[i]);
  1567. X
  1568. X        if (exdeath[i])            XFreePixmap(display, exdeath[i]);     
  1569. X        if (exdeathM[i])        XFreePixmap(display, exdeathM[i]);
  1570. X    }
  1571. X}
  1572. X
  1573. X#if NeedFunctionPrototypes
  1574. Xstatic void CalculateBlockGeometry(int row, int col)
  1575. X#else
  1576. Xstatic void CalculateBlockGeometry(row, col)
  1577. X    int row, col;
  1578. X#endif
  1579. X{
  1580. X    struct aBlock *blockP;
  1581. X    XPoint points[4];
  1582. X    int halfWidth, halfHeight;
  1583. X
  1584. X    /* Pointer to the correct block we need - speed things up */
  1585. X    blockP = &blocks[row][col];
  1586. X
  1587. X    switch (blockP->blockType)
  1588. X    {
  1589. X        case COUNTER_BLK:
  1590. X            blockP->width             = BLOCK_WIDTH;
  1591. X            blockP->height            = BLOCK_HEIGHT;
  1592. X            blockP->blockOffsetX    = (colWidth - BLOCK_WIDTH) / 2;
  1593. X            blockP->blockOffsetY     = (rowHeight - BLOCK_HEIGHT) / 2;
  1594. X            break;
  1595. X
  1596. X        case MGUN_BLK:
  1597. X            blockP->width             = 35;
  1598. X            blockP->height            = 15;
  1599. X            blockP->blockOffsetX    = (colWidth - 35) / 2;
  1600. X            blockP->blockOffsetY     = (rowHeight - 15) / 2;
  1601. X            break;
  1602. X
  1603. X        case WALLOFF_BLK:
  1604. X            blockP->width             = 27;
  1605. X            blockP->height            = 23;
  1606. X            blockP->blockOffsetX    = (colWidth - 27) / 2;
  1607. X            blockP->blockOffsetY     = (rowHeight - 23) / 2;
  1608. X            break;
  1609. X
  1610. X        case REVERSE_BLK:
  1611. X            blockP->width             = 33;
  1612. X            blockP->height            = 16;
  1613. X            blockP->blockOffsetX    = (colWidth - 33) / 2;
  1614. X            blockP->blockOffsetY     = (rowHeight - 16) / 2;
  1615. X            break;
  1616. X
  1617. X        case EXTRABALL_BLK:
  1618. X            blockP->width             = 30;
  1619. X            blockP->height            = 19;
  1620. X            blockP->blockOffsetX    = (colWidth - 30) / 2;
  1621. X            blockP->blockOffsetY     = (rowHeight - 19) / 2;
  1622. X            break;
  1623. X
  1624. X        case HYPERSPACE_BLK:
  1625. X            blockP->width             = 31;
  1626. X            blockP->height            = 31;
  1627. X            blockP->blockOffsetX    = (colWidth - 31) / 2;
  1628. X            blockP->blockOffsetY     = (rowHeight - 31) / 2;
  1629. X            break;
  1630. X
  1631. X        case BOMB_BLK:
  1632. X        case DEATH_BLK:
  1633. X            blockP->width             = 30;
  1634. X            blockP->height            = 30;
  1635. X            blockP->blockOffsetX    = (colWidth - 30) / 2;
  1636. X            blockP->blockOffsetY     = (rowHeight - 30) / 2;
  1637. X            break;
  1638. X
  1639. X        case STICKY_BLK:
  1640. X            blockP->width             = 32;
  1641. X            blockP->height            = 32;
  1642. X            blockP->blockOffsetX    = (colWidth - 32) / 2;
  1643. X            blockP->blockOffsetY     = (rowHeight - 32) / 2;
  1644. X            break;
  1645. X
  1646. X        case BLACK_BLK:
  1647. X            blockP->width             = 50;
  1648. X            blockP->height            = 30;
  1649. X            blockP->blockOffsetX    = (colWidth - 50) / 2;
  1650. X            blockP->blockOffsetY     = (rowHeight - 30) / 2;
  1651. X            break;
  1652. X
  1653. X        case PAD_SHRINK_BLK:
  1654. X        case PAD_EXPAND_BLK:
  1655. X            blockP->width             = 40;
  1656. X            blockP->height            = 15;
  1657. X            blockP->blockOffsetX    = (colWidth - 40) / 2;
  1658. X            blockP->blockOffsetY     = (rowHeight - 15) / 2;
  1659. X            break;
  1660. X
  1661. X        case BONUS_BLK:
  1662. X        case BONUSX4_BLK:
  1663. X        case BONUSX2_BLK:
  1664. X            blockP->width             = 27;
  1665. X            blockP->height            = 27;
  1666. X            blockP->blockOffsetX    = (colWidth - 27) / 2;
  1667. X            blockP->blockOffsetY     = (rowHeight - 27) / 2;
  1668. X            break;
  1669. X
  1670. X        default:        /* All other blocks */
  1671. X            blockP->width             = BLOCK_WIDTH;
  1672. X            blockP->height            = BLOCK_HEIGHT;
  1673. X            blockP->blockOffsetX    = (colWidth - BLOCK_WIDTH) / 2;
  1674. X            blockP->blockOffsetY     = (rowHeight - BLOCK_HEIGHT) / 2;
  1675. X            break;
  1676. X
  1677. X    }    
  1678. X
  1679. X    /* Calculate the offset within the block grid */
  1680. X    blockP->x = (col * colWidth) + blockP->blockOffsetX;
  1681. X    blockP->y = (row * rowHeight) + blockP->blockOffsetY;
  1682. X
  1683. X    /* Used below */
  1684. X    halfWidth = blockP->x + (blockP->width / 2);
  1685. X    halfHeight = blockP->y + (blockP->height / 2);
  1686. X
  1687. X    /* Create the XPoint array for the top region */
  1688. X    points[0].x = blockP->x;
  1689. X    points[0].y = blockP->y;
  1690. X    points[1].x = halfWidth;
  1691. X    points[1].y = halfHeight;
  1692. X    points[2].x = blockP->x + blockP->width;
  1693. X    points[2].y = blockP->y;
  1694. X    points[3].x = points[0].x;
  1695. X    points[3].y = points[0].y;
  1696. X
  1697. X    /* Create the top region for the block */
  1698. X    blockP->regionTop = XPolygonRegion(points, 4, EvenOddRule);
  1699. X
  1700. X    /* Create the XPoint array for the bottom region */
  1701. X    points[0].x = blockP->x;
  1702. X    points[0].y = blockP->y + blockP->height;
  1703. X    points[1].x = halfWidth;
  1704. X    points[1].y = halfHeight;
  1705. X    points[2].x = blockP->x + blockP->width;
  1706. X    points[2].y = points[0].y;
  1707. X    points[3].x = points[0].x;
  1708. X    points[3].y = points[0].y;
  1709. X
  1710. X    /* Create the bottom region for the block */
  1711. X    blockP->regionBottom = XPolygonRegion(points, 4, EvenOddRule);
  1712. X
  1713. X    /* Create the XPoint array for the left region */
  1714. X    points[0].x = blockP->x;
  1715. X    points[0].y = blockP->y;
  1716. X    points[1].x = halfWidth;
  1717. X    points[1].y = halfHeight;
  1718. X    points[2].x = blockP->x;
  1719. X    points[2].y = blockP->y + blockP->height;
  1720. X    points[3].x = points[0].x;
  1721. X    points[3].y = points[0].y;
  1722. X
  1723. X    /* Create the left region for the block */
  1724. X    blockP->regionLeft = XPolygonRegion(points, 4, EvenOddRule);
  1725. X
  1726. X    /* Create the XPoint array for the right region */
  1727. X    points[0].x = blockP->x + blockP->width;
  1728. X    points[0].y = blockP->y;
  1729. X    points[1].x = halfWidth;
  1730. X    points[1].y = halfHeight;
  1731. X    points[2].x = points[0].x;
  1732. X    points[2].y = blockP->y + blockP->height;
  1733. X    points[3].x = points[0].x;
  1734. X    points[3].y = points[0].y;
  1735. X
  1736. X    /* Create the right region for the block */
  1737. X    blockP->regionRight = XPolygonRegion(points, 4, EvenOddRule);
  1738. X}
  1739. X
  1740. X#if NeedFunctionPrototypes
  1741. Xvoid AddNewBlock(Display *display, Window window, int row, int col,
  1742. X    int blockType, int counterSlide)
  1743. X#else
  1744. Xvoid AddNewBlock(display, window, row, col, blockType, counterSlide)
  1745. X    Display *display;
  1746. X    Window window;
  1747. X    int row;
  1748. X    int col;
  1749. X    int blockType;
  1750. X    int counterSlide;
  1751. X#endif
  1752. X{
  1753. X    struct aBlock *blockP;
  1754. X
  1755. X    if (row > MAX_ROW || row < 0) return;
  1756. X    if (col > MAX_COL || col < 0) return;
  1757. X
  1758. X    /* Pointer to the block we want */
  1759. X    blockP = &blocks[row][col];
  1760. X
  1761. X    /* Now set the block structure with new values */
  1762. X    blockP->blockType         = blockType;
  1763. X    blockP->occupied         = 1;
  1764. X    blockP->counterSlide     = counterSlide;
  1765. X
  1766. X    /* Handle the special case for a random block */
  1767. X    if (blockType == RANDOM_BLK)
  1768. X    {
  1769. X        /* Setup the random block so it has a next frame and new type */
  1770. X        blockP->random       = True;
  1771. X        blockP->blockType = RED_BLK;
  1772. X        blockP->nextFrame = frame + 1;
  1773. X    }
  1774. X
  1775. X    /* Work out all the block geometry stuff */
  1776. X    CalculateBlockGeometry(row, col);
  1777. X    
  1778. X    /* Add the number of points that will be awarded for each block */
  1779. X    switch(blockType)
  1780. X    {
  1781. X        case BULLET_BLK:
  1782. X            blockP->hitPoints = 50;
  1783. X            break;
  1784. X
  1785. X        case RED_BLK:
  1786. X            blockP->hitPoints = 100;
  1787. X            break;
  1788. X
  1789. X        case GREEN_BLK:
  1790. X            blockP->hitPoints = 120;
  1791. X            break;
  1792. X
  1793. X        case BLUE_BLK:
  1794. X            blockP->hitPoints = 110;
  1795. X            break;
  1796. X
  1797. X        case TAN_BLK:
  1798. X            blockP->hitPoints = 130;
  1799. X            break;
  1800. X
  1801. X        case YELLOW_BLK:
  1802. X            blockP->hitPoints = 140;
  1803. X            break;
  1804. X
  1805. X        case PURPLE_BLK:
  1806. X            blockP->hitPoints = 150;
  1807. X            break;
  1808. X
  1809. X        case BOMB_BLK:
  1810. X            blockP->hitPoints = 50;
  1811. X            break;
  1812. X
  1813. X        case COUNTER_BLK:
  1814. X            blockP->hitPoints = 200;
  1815. X            break;
  1816. X
  1817. X        case EXTRABALL_BLK:
  1818. X            blockP->nextFrame = frame + EXTRABALL_DELAY;
  1819. X            blockP->hitPoints = 100;
  1820. X            break;
  1821. X
  1822. X        case HYPERSPACE_BLK:
  1823. X        case MGUN_BLK:
  1824. X        case WALLOFF_BLK:
  1825. X        case REVERSE_BLK:
  1826. X        case MULTIBALL_BLK:
  1827. X        case STICKY_BLK:
  1828. X        case PAD_SHRINK_BLK:
  1829. X        case PAD_EXPAND_BLK:
  1830. X            blockP->hitPoints = 100;
  1831. X            break;
  1832. X
  1833. X        case DEATH_BLK:
  1834. X            blockP->hitPoints = -1000;
  1835. X            blockP->nextFrame = frame + DEATH_DELAY2;
  1836. X            break;
  1837. X
  1838. X        default:
  1839. X            break;
  1840. X    }
  1841. X
  1842. X    /* Draw the blocks please */
  1843. X    DrawBlock(display, window, row, col, blockType);
  1844. X}
  1845. X
  1846. X#if NeedFunctionPrototypes
  1847. Xvoid SkipToNextLevel(Display *display, Window window)
  1848. X#else
  1849. Xvoid SkipToNextLevel(display, window)
  1850. X    Display *display;
  1851. X    Window window;
  1852. X#endif
  1853. X{
  1854. X    struct aBlock *blockP;
  1855. X    int r, c;
  1856. X
  1857. X    /* This will kill all blocks that need to go before next level can
  1858. X     * be reached. Used in debug mode and maybe in special bonus mode.
  1859. X     */
  1860. X
  1861. X    for (r = 0; r < MAX_ROW; r++)
  1862. X        for (c = 0; c < MAX_COL; c++)
  1863. X        {
  1864. X            /* Pointer to the block we want */
  1865. X            blockP = &blocks[r][c];
  1866. X
  1867. X            if (blockP->occupied == True) 
  1868. X            {
  1869. X                switch (blockP->blockType)
  1870. X                {
  1871. X                    case BONUSX2_BLK:
  1872. X                    case BONUSX4_BLK:
  1873. X                    case BONUS_BLK:
  1874. X                    case BLACK_BLK:
  1875. X                    case BULLET_BLK:
  1876. X                    case BOMB_BLK:
  1877. X                    case DEATH_BLK:
  1878. X                    case REVERSE_BLK:
  1879. X                    case HYPERSPACE_BLK:
  1880. X                    case EXTRABALL_BLK:
  1881. X                    case MGUN_BLK:
  1882. X                    case WALLOFF_BLK:
  1883. X                    case MULTIBALL_BLK:
  1884. X                    case STICKY_BLK:
  1885. X                    case PAD_SHRINK_BLK:
  1886. X                    case PAD_EXPAND_BLK:
  1887. X                        break;
  1888. X
  1889. X                    default:
  1890. X                        DrawBlock(display, window, r, c, KILL_BLK);
  1891. X                        break;
  1892. X                }
  1893. X            }
  1894. X        }
  1895. X}
  1896. X
  1897. X#if NeedFunctionPrototypes
  1898. Xvoid RedrawAllBlocks(Display *display, Window window)
  1899. X#else
  1900. Xvoid RedrawAllBlocks(display, window)
  1901. X    Display *display;
  1902. X    Window window;
  1903. X#endif
  1904. X{
  1905. X    struct aBlock *blockP;
  1906. X    int r, c;
  1907. X
  1908. X    for (r = 0; r < MAX_ROW; r++)
  1909. X        for (c = 0; c < MAX_COL; c++)
  1910. X        {
  1911. X            /* Pointer to the block we want */
  1912. X            blockP = &blocks[r][c];
  1913. X
  1914. X            if (blockP->occupied == True)
  1915. X                DrawBlock(display, window, r, c, blockP->blockType);
  1916. X        }
  1917. X}
  1918. X
  1919. X#if NeedFunctionPrototypes
  1920. Xint StillActiveBlocks(void)
  1921. X#else
  1922. Xint StillActiveBlocks()
  1923. X#endif
  1924. X{
  1925. X    struct aBlock *blockP;
  1926. X    int r, c;
  1927. X
  1928. X    /* Check all blocks to see if they still are active */
  1929. X    for (r = 0; r < MAX_ROW; r++)
  1930. X        for (c = 0; c < MAX_COL; c++)
  1931. X        {
  1932. X            /* Pointer to the block we want */
  1933. X            blockP = &blocks[r][c];
  1934. X
  1935. X            if (blockP->occupied == True) 
  1936. X            {
  1937. X                switch (blockP->blockType)
  1938. X                {
  1939. X                    /* These blocks don't count */
  1940. X                    case BONUSX2_BLK:
  1941. X                    case BONUSX4_BLK:
  1942. X                    case BONUS_BLK:
  1943. X                    case BLACK_BLK:
  1944. X                    case BULLET_BLK:
  1945. X                    case BOMB_BLK:
  1946. X                    case DEATH_BLK:
  1947. X                    case REVERSE_BLK:
  1948. X                    case HYPERSPACE_BLK:
  1949. X                    case EXTRABALL_BLK:
  1950. X                    case MGUN_BLK:
  1951. X                    case WALLOFF_BLK:
  1952. X                    case MULTIBALL_BLK:
  1953. X                    case STICKY_BLK:
  1954. X                    case PAD_SHRINK_BLK:
  1955. X                    case PAD_EXPAND_BLK:
  1956. X                        break;
  1957. X
  1958. X                    default:
  1959. X                        return True;
  1960. X                }
  1961. X            }
  1962. X        }
  1963. X    
  1964. X    /* Only all done when explosions are finished */
  1965. X    if (blocksExploding > 0)
  1966. X        return True;
  1967. X    else
  1968. X        return False;
  1969. X}
  1970. X
  1971. X#if NeedFunctionPrototypes
  1972. Xstatic void ClearBlock(int row, int col)
  1973. X#else
  1974. Xstatic void ClearBlock(row, col)
  1975. X    int row;
  1976. X    int col;
  1977. X#endif
  1978. X{
  1979. X    struct aBlock *blockP;
  1980. X
  1981. X    /* Pointer to the block we want */
  1982. X    blockP = &blocks[row][col];
  1983. X
  1984. X    /* Initialise everything in block */
  1985. X    blockP->occupied             = False;
  1986. X    blockP->exploding             = False;
  1987. X    blockP->x                     = 0;
  1988. X    blockP->y                     = 0;
  1989. X    blockP->width                 = 0;
  1990. X    blockP->height                 = 0;
  1991. X    blockP->hitPoints             = 0;
  1992. X    blockP->blockType             = NONE_BLK;
  1993. X    blockP->explodeStartFrame     = 0;
  1994. X    blockP->explodeNextFrame     = 0;
  1995. X    blockP->explodeSlide         = 0;
  1996. X    blockP->counterSlide         = 0;
  1997. X    blockP->bonusSlide             = 0;
  1998. X    blockP->blockOffsetY         = 0;
  1999. X    blockP->blockOffsetX         = 0;
  2000. X    blockP->lastFrame             = 0;
  2001. X    blockP->nextFrame             = 0;
  2002. X    blockP->currentFrame         = 0;
  2003. X    blockP->random                 = False;
  2004. X    blockP->ballHitIndex         = 0;
  2005. X    blockP->balldx                 = 0;
  2006. X    blockP->balldy                 = 0;
  2007. X
  2008. X    /* Destroy the top region of the block */
  2009. X    if (blockP->regionTop != (Region) NULL)
  2010. X    {
  2011. X        XDestroyRegion(blockP->regionTop);
  2012. X        blockP->regionTop = (Region) NULL;
  2013. X    }
  2014. X
  2015. X    /* Destroy the bottom region of the block */
  2016. X    if (blockP->regionBottom != (Region) NULL)
  2017. X    {
  2018. X        XDestroyRegion(blockP->regionBottom);
  2019. X        blockP->regionBottom = (Region) NULL;
  2020. X    }
  2021. X
  2022. X    /* Destroy the left region of the block */
  2023. X    if (blockP->regionLeft != (Region) NULL)
  2024. X    {
  2025. X        XDestroyRegion(blockP->regionLeft);
  2026. X        blockP->regionLeft = (Region) NULL;
  2027. X    }
  2028. X
  2029. X    /* Destroy the right region of the block */
  2030. X    if (blockP->regionRight != (Region) NULL)
  2031. X    {
  2032. X        XDestroyRegion(blockP->regionRight);
  2033. X        blockP->regionRight = (Region) NULL;
  2034. X    }
  2035. X}
  2036. X
  2037. X
  2038. X#if NeedFunctionPrototypes
  2039. Xvoid ClearBlockArray(void)
  2040. X#else
  2041. Xvoid ClearBlockArray()
  2042. X#endif
  2043. X{
  2044. X    int r, c;
  2045. X
  2046. X    /* Scan through all block entries and erase their contents */
  2047. X    for (r = 0; r < MAX_ROW; r++)
  2048. X    {
  2049. X        for (c = 0; c < MAX_COL; c++)
  2050. X        {
  2051. X            /* Clear the block thanks */
  2052. X            ClearBlock(r, c);
  2053. X        }
  2054. X    }
  2055. X}
  2056. X
  2057. X#if NeedFunctionPrototypes
  2058. Xvoid SetupStage(Display *display, Window window)
  2059. X#else
  2060. Xvoid SetupStage(display, window)
  2061. X    Display *display;
  2062. X    Window window;
  2063. X#endif
  2064. X{
  2065. X    char levelPath[1024];
  2066. X    char *str;
  2067. X    char str2[1024];
  2068. X    static int bgrnd = 1;
  2069. X    u_long newLevel;
  2070. X
  2071. X    bgrnd++;
  2072. X    if (bgrnd == 12) bgrnd = 2;
  2073. X    DrawStageBackground(display, window, bgrnd);
  2074. X
  2075. X    ClearAllBalls();
  2076. X    currentPaddleSize   = PADDLE_HUGE;
  2077. X    ResetPaddleStart(display, window);
  2078. X    ResetBallStart(display, playWindow);
  2079. X
  2080. X    ClearBullets();
  2081. X    SetNumberBullets(NUMBER_OF_BULLETS_NEW_LEVEL);
  2082. X    ResetNumberBonus();
  2083. X
  2084. X    TurnSpecialsOff(display);        
  2085. X    SetReverseOff();
  2086. X    DisplayScore(display, scoreWindow, score);
  2087. X    DisplayLevelInfo(display, levelWindow, level);
  2088. X    DrawSpecials(display);
  2089. X
  2090. X    /* map the level number for the filename so that after the maximum
  2091. X     * level is reached it will wrap around to 1 again but will not
  2092. X       * affect the level number
  2093. X        */
  2094. X       newLevel = level % (MAX_NUM_LEVELS + 1);
  2095. X      if (newLevel == 0) newLevel = 1;
  2096. X
  2097. X    /* Construct the level filename */
  2098. X    if ((str = getenv("XBOING_LEVELS_DIR")) != NULL)
  2099. X        sprintf(levelPath, "%s/level%ld.data", str, newLevel);
  2100. X    else
  2101. X        sprintf(levelPath, "%s/level%ld.data", LEVEL_INSTALL_DIR, newLevel);
  2102. X
  2103. X    if (ReadNextLevel(display, window, levelPath) == False)
  2104. X        ShutDown(display, 1, "Sorry, email: jck@citri.edu.au with bug.");
  2105. X    
  2106. X    /* Display level name for all to see */
  2107. X    sprintf(str2, "- %s -", GetLevelName());
  2108. X    SetCurrentMessage(display, messWindow, str2, True);
  2109. X
  2110. X    XFlush(display);
  2111. X}
  2112. END_OF_FILE
  2113.   if test 24327 -ne `wc -c <'xab'`; then
  2114.     echo shar: \"'xab'\" unpacked with wrong size!
  2115.   fi
  2116.   # end of 'xab'
  2117. fi
  2118. echo shar: End of archive 9 \(of 26\).
  2119. cp /dev/null ark9isdone
  2120. MISSING=""
  2121. for I in 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 ; do
  2122.     if test ! -f ark${I}isdone ; then
  2123.     MISSING="${MISSING} ${I}"
  2124.     fi
  2125. done
  2126. if test "${MISSING}" = "" ; then
  2127.     echo You have unpacked all 26 archives.
  2128.     rm -f ark[1-9]isdone ark[1-9][0-9]isdone
  2129.     echo "merging split files..."
  2130.     cat blocks.c[12] > blocks.c
  2131.     rm blocks.c[12]
  2132.     echo "blocks.c done"
  2133.     cat bitmaps/earth.xpm.Z.u.[ab] > bitmaps/earth.xpm.Z.uue
  2134.     rm bitmaps/earth.xpm.Z.u.[ab]
  2135.     echo "bitmaps/earth.xpm.Z.uue done"
  2136. else
  2137.     echo You still must unpack the following archives:
  2138.     echo "        " ${MISSING}
  2139. fi
  2140. exit 0
  2141. exit 0 # Just in case...
  2142. -- 
  2143.   // chris@Sterling.COM           | Send comp.sources.x submissions to:
  2144. \X/  Amiga - The only way to fly! |    sources-x@sterling.com
  2145.  "It's intuitively obvious to the |
  2146.   most casual observer..."        | GCS d+/-- p+ c++ l+ m+ s++/+ g+ w+ t+ r+ x+
  2147.