home *** CD-ROM | disk | FTP | other *** search
/ Source Code 1994 March / Source_Code_CD-ROM_Walnut_Creek_March_1994.iso / compsrcs / x / volume19 / xinvadrs / part02 < prev    next >
Encoding:
Text File  |  1993-04-27  |  54.3 KB  |  2,089 lines

  1. Newsgroups: comp.sources.x
  2. From: jonathan@Think.COM (Jonny Goldman)
  3. Subject: v19i007:  xinvaders - space invaders for X, Part02/03
  4. Message-ID: <1993Mar8.220509.11707@sparky.imd.sterling.com>
  5. X-Md4-Signature: f46a8cd43c466b4fbfe7c30ba1d18bd4
  6. Date: Mon, 8 Mar 1993 22:05:09 GMT
  7. Approved: chris@sparky.imd.sterling.com
  8.  
  9. Submitted-by: jonathan@Think.COM (Jonny Goldman)
  10. Posting-number: Volume 19, Issue 7
  11. Archive-name: xinvaders/part02
  12. Environment: X11
  13. Supersedes: xinvaders: Volume 8, Issue 62-66
  14.  
  15. #! /bin/sh
  16. # This is a shell archive.  Remove anything before this line, then feed it
  17. # into a shell via "sh file" or similar.  To overwrite existing files,
  18. # type "sh file -c".
  19. # Contents:  Makefile base.c main.c spacers.c vaders.c widget.c
  20. # Wrapped by chris@sparky on Mon Mar  8 15:41:52 1993
  21. PATH=/bin:/usr/bin:/usr/ucb:/usr/local/bin:/usr/lbin ; export PATH
  22. echo If this archive is complete, you will see the following message:
  23. echo '          "shar: End of archive 2 (of 3)."'
  24. if test -f 'Makefile' -a "${1}" != "-c" ; then 
  25.   echo shar: Will not clobber existing file \"'Makefile'\"
  26. else
  27.   echo shar: Extracting \"'Makefile'\" \(9091 characters\)
  28.   sed "s/^X//" >'Makefile' <<'END_OF_FILE'
  29. X# Makefile generated by imake - do not edit!
  30. X# $XConsortium: imake.c,v 1.51 89/12/12 12:37:30 jim Exp $
  31. X#
  32. X# The cpp used on this machine replaces all newlines and multiple tabs and
  33. X# spaces in a macro expansion with a single space.  Imake tries to compensate
  34. X# for this, but is not always successful.
  35. X#
  36. X
  37. X###########################################################################
  38. X# Makefile generated from "Imake.tmpl" and <Imakefile>
  39. X# $XConsortium: Imake.tmpl,v 1.77 89/12/18 17:01:37 jim Exp $
  40. X#
  41. X# Platform-specific parameters may be set in the appropriate .cf
  42. X# configuration files.  Site-wide parameters may be set in the file
  43. X# site.def.  Full rebuilds are recommended if any parameters are changed.
  44. X#
  45. X# If your C preprocessor doesn't define any unique symbols, you'll need
  46. X# to set BOOTSTRAPCFLAGS when rebuilding imake (usually when doing
  47. X# "make Makefile", "make Makefiles", or "make World").
  48. X#
  49. X# If you absolutely can't get imake to work, you'll need to set the
  50. X# variables at the top of each Makefile as well as the dependencies at the
  51. X# bottom (makedepend will do this automatically).
  52. X#
  53. X
  54. X###########################################################################
  55. X# platform-specific configuration parameters - edit sun.cf to change
  56. X
  57. X# platform:  $XConsortium: sun.cf,v 1.38 89/12/23 16:10:10 jim Exp $
  58. X# operating system:  SunOS 4.1.1
  59. X
  60. X###########################################################################
  61. X# site-specific configuration parameters - edit site.def to change
  62. X
  63. X# site:  $XConsortium: site.def,v 1.21 89/12/06 11:46:50 jim Exp $
  64. X
  65. X            SHELL = /bin/sh
  66. X
  67. X              TOP = .
  68. X      CURRENT_DIR = .
  69. X
  70. X               AR = ar cq
  71. X  BOOTSTRAPCFLAGS =
  72. X               CC = cc
  73. X
  74. X         COMPRESS = compress
  75. X              CPP = /lib/cpp $(STD_CPP_DEFINES)
  76. X    PREPROCESSCMD = cc -E $(STD_CPP_DEFINES)
  77. X          INSTALL = install
  78. X               LD = ld
  79. X             LINT = lint
  80. X      LINTLIBFLAG = -C
  81. X         LINTOPTS = -axz
  82. X               LN = ln -s
  83. X             MAKE = make
  84. X               MV = mv
  85. X               CP = cp
  86. X           RANLIB = ranlib
  87. X  RANLIBINSTFLAGS =
  88. X               RM = rm -f
  89. X     STD_INCLUDES =
  90. X  STD_CPP_DEFINES =
  91. X      STD_DEFINES =
  92. X EXTRA_LOAD_FLAGS =
  93. X  EXTRA_LIBRARIES =
  94. X             TAGS = ctags
  95. X
  96. X    SHAREDCODEDEF = -DSHAREDCODE
  97. X         SHLIBDEF = -DSUNSHLIB
  98. X
  99. X    PROTO_DEFINES =
  100. X
  101. X     INSTPGMFLAGS =
  102. X
  103. X     INSTBINFLAGS = -m 0755
  104. X     INSTUIDFLAGS = -m 4755
  105. X     INSTLIBFLAGS = -m 0664
  106. X     INSTINCFLAGS = -m 0444
  107. X     INSTMANFLAGS = -m 0444
  108. X     INSTDATFLAGS = -m 0444
  109. X    INSTKMEMFLAGS = -m 4755
  110. X
  111. X          DESTDIR =
  112. X
  113. X     TOP_INCLUDES = -I$(INCROOT)
  114. X
  115. X      CDEBUGFLAGS = -O
  116. X        CCOPTIONS = -pipe
  117. X      COMPATFLAGS =
  118. X
  119. X      ALLINCLUDES = $(STD_INCLUDES) $(TOP_INCLUDES) $(INCLUDES) $(EXTRA_INCLUDES)
  120. X       ALLDEFINES = $(ALLINCLUDES) $(STD_DEFINES) $(PROTO_DEFINES) $(DEFINES) $(COMPATFLAGS)
  121. X           CFLAGS = $(CDEBUGFLAGS) $(CCOPTIONS) $(ALLDEFINES)
  122. X        LINTFLAGS = $(LINTOPTS) -DLINT $(ALLDEFINES)
  123. X           LDLIBS = $(SYS_LIBRARIES) $(EXTRA_LIBRARIES)
  124. X        LDOPTIONS = $(CDEBUGFLAGS) $(CCOPTIONS)
  125. X   LDCOMBINEFLAGS = -X -r
  126. X
  127. X        MACROFILE = sun.cf
  128. X           RM_CMD = $(RM) *.CKP *.ln *.BAK *.bak *.o core errs ,* *~ *.a .emacs_* tags TAGS make.log MakeOut
  129. X
  130. X    IMAKE_DEFINES =
  131. X
  132. X         IRULESRC = $(CONFIGDIR)
  133. X        IMAKE_CMD = $(IMAKE) -DUseInstalled -I$(IRULESRC) $(IMAKE_DEFINES)
  134. X
  135. X     ICONFIGFILES = $(IRULESRC)/Imake.tmpl $(IRULESRC)/Imake.rules \
  136. X            $(IRULESRC)/Project.tmpl $(IRULESRC)/site.def \
  137. X            $(IRULESRC)/$(MACROFILE) $(EXTRA_ICONFIGFILES)
  138. X
  139. X###########################################################################
  140. X# X Window System Build Parameters
  141. X# $XConsortium: Project.tmpl,v 1.63 89/12/18 16:46:44 jim Exp $
  142. X
  143. X###########################################################################
  144. X# X Window System make variables; this need to be coordinated with rules
  145. X# $XConsortium: Project.tmpl,v 1.63 89/12/18 16:46:44 jim Exp $
  146. X
  147. X          PATHSEP = /
  148. X        USRLIBDIR = $(DESTDIR)/usr/lib
  149. X           BINDIR = $(DESTDIR)/usr/bin/X11
  150. X          INCROOT = $(DESTDIR)/usr/include
  151. X     BUILDINCROOT = $(TOP)
  152. X      BUILDINCDIR = $(BUILDINCROOT)/X11
  153. X      BUILDINCTOP = ..
  154. X           INCDIR = $(INCROOT)/X11
  155. X           ADMDIR = $(DESTDIR)/usr/adm
  156. X           LIBDIR = $(USRLIBDIR)/X11
  157. X        CONFIGDIR = $(LIBDIR)/config
  158. X       LINTLIBDIR = $(USRLIBDIR)/lint
  159. X
  160. X          FONTDIR = $(LIBDIR)/fonts
  161. X         XINITDIR = $(LIBDIR)/xinit
  162. X           XDMDIR = $(LIBDIR)/xdm
  163. X           AWMDIR = $(LIBDIR)/awm
  164. X           TWMDIR = $(LIBDIR)/twm
  165. X           GWMDIR = $(LIBDIR)/gwm
  166. X          MANPATH = $(DESTDIR)/usr/man
  167. X    MANSOURCEPATH = $(MANPATH)/man
  168. X           MANDIR = $(MANSOURCEPATH)1
  169. X        LIBMANDIR = $(MANSOURCEPATH)3
  170. X      XAPPLOADDIR = $(LIBDIR)/app-defaults
  171. X
  172. X        SOXLIBREV = 4.2
  173. X          SOXTREV = 4.0
  174. X         SOXAWREV = 4.0
  175. X        SOOLDXREV = 4.0
  176. X         SOXMUREV = 4.0
  177. X        SOXEXTREV = 4.0
  178. X
  179. X       FONTCFLAGS = -t
  180. X
  181. X     INSTAPPFLAGS = $(INSTDATFLAGS)
  182. X
  183. X            IMAKE = imake
  184. X           DEPEND = makedepend
  185. X              RGB = rgb
  186. X            FONTC = bdftosnf
  187. X        MKFONTDIR = mkfontdir
  188. X        MKDIRHIER = /bin/sh $(BINDIR)/mkdirhier.sh
  189. X
  190. X        CONFIGSRC = $(TOP)/config
  191. X        CLIENTSRC = $(TOP)/clients
  192. X          DEMOSRC = $(TOP)/demos
  193. X           LIBSRC = $(TOP)/lib
  194. X          FONTSRC = $(TOP)/fonts
  195. X       INCLUDESRC = $(TOP)/X11
  196. X        SERVERSRC = $(TOP)/server
  197. X          UTILSRC = $(TOP)/util
  198. X        SCRIPTSRC = $(UTILSRC)/scripts
  199. X       EXAMPLESRC = $(TOP)/examples
  200. X       CONTRIBSRC = $(TOP)/../contrib
  201. X           DOCSRC = $(TOP)/doc
  202. X           RGBSRC = $(TOP)/rgb
  203. X        DEPENDSRC = $(UTILSRC)/makedepend
  204. X         IMAKESRC = $(CONFIGSRC)
  205. X         XAUTHSRC = $(LIBSRC)/Xau
  206. X          XLIBSRC = $(LIBSRC)/X
  207. X           XMUSRC = $(LIBSRC)/Xmu
  208. X       TOOLKITSRC = $(LIBSRC)/Xt
  209. X       AWIDGETSRC = $(LIBSRC)/Xaw
  210. X       OLDXLIBSRC = $(LIBSRC)/oldX
  211. X      XDMCPLIBSRC = $(LIBSRC)/Xdmcp
  212. X      BDFTOSNFSRC = $(FONTSRC)/bdftosnf
  213. X     MKFONTDIRSRC = $(FONTSRC)/mkfontdir
  214. X     EXTENSIONSRC = $(TOP)/extensions
  215. X
  216. X  DEPEXTENSIONLIB = $(USRLIBDIR)/libXext.a
  217. X     EXTENSIONLIB =  -lXext
  218. X
  219. X          DEPXLIB = $(DEPEXTENSIONLIB)
  220. X             XLIB = $(EXTENSIONLIB) -lX11
  221. X
  222. X      DEPXAUTHLIB = $(USRLIBDIR)/libXau.a
  223. X         XAUTHLIB =  -lXau
  224. X
  225. X        DEPXMULIB =
  226. X           XMULIB = -lXmu
  227. X
  228. X       DEPOLDXLIB =
  229. X          OLDXLIB = -loldX
  230. X
  231. X      DEPXTOOLLIB =
  232. X         XTOOLLIB = -lXt
  233. X
  234. X        DEPXAWLIB =
  235. X           XAWLIB = -lXaw
  236. X
  237. X      DEPXDMCPLIB = $(USRLIBDIR)/libXdmcp.a
  238. X         XDMCPLIB =  -lXdmcp
  239. X
  240. X LINTEXTENSIONLIB = $(USRLIBDIR)/llib-lXext.ln
  241. X         LINTXLIB = $(USRLIBDIR)/llib-lX11.ln
  242. X          LINTXMU = $(USRLIBDIR)/llib-lXmu.ln
  243. X        LINTXTOOL = $(USRLIBDIR)/llib-lXt.ln
  244. X          LINTXAW = $(USRLIBDIR)/llib-lXaw.ln
  245. X
  246. X          DEPLIBS = $(DEPXAWLIB) $(DEPXMULIB) $(DEPXTOOLLIB) $(DEPXLIB)
  247. X
  248. X         DEPLIBS1 = $(DEPLIBS)
  249. X         DEPLIBS2 = $(DEPLIBS)
  250. X         DEPLIBS3 = $(DEPLIBS)
  251. X
  252. X###########################################################################
  253. X# Imake rules for building libraries, programs, scripts, and data files
  254. X# rules:  $XConsortium: Imake.rules,v 1.67 89/12/18 17:14:15 jim Exp $
  255. X
  256. X###########################################################################
  257. X# start of Imakefile
  258. X
  259. XLOCAL_LIBRARIES = $(XAWLIB) $(XMULIB) $(XTOOLLIB) $(XLIB)
  260. X
  261. XOBJS = spacers.o base.o widget.o main.o vaders.o shot.o score.o
  262. X
  263. XSRCS = spacers.c base.c widget.c main.c vaders.c shot.c score.c
  264. X
  265. XINCLUDES = -I$(TOP) -I$(TOP)/X11
  266. X
  267. X PROGRAM = xinvaders
  268. X
  269. Xall:: xinvaders
  270. X
  271. Xxinvaders: $(OBJS) $(DEPLIBS)
  272. X    $(RM) $@
  273. X    $(CC) -o $@ $(OBJS) $(LDOPTIONS) $(LOCAL_LIBRARIES) $(LDLIBS) $(EXTRA_LOAD_FLAGS)
  274. X
  275. Xsaber_xinvaders:
  276. X    #load $(ALLDEFINES) $(SRCS) $(LOCAL_LIBRARIES) $(SYS_LIBRARIES) $(EXTRA_LIBRARIES)
  277. X
  278. Xosaber_xinvaders:
  279. X    #load $(ALLDEFINES) $(OBJS) $(LOCAL_LIBRARIES) $(SYS_LIBRARIES) $(EXTRA_LIBRARIES)
  280. X
  281. Xinstall:: xinvaders
  282. X    $(INSTALL) -c $(INSTPGMFLAGS)   xinvaders $(BINDIR)
  283. X
  284. Xinstall.man:: xinvaders.man
  285. X    $(INSTALL) -c $(INSTMANFLAGS) xinvaders.man $(MANDIR)/xinvaders.1
  286. X
  287. Xdepend::
  288. X    $(DEPEND) -s "# DO NOT DELETE" -- $(ALLDEFINES) -- $(SRCS)
  289. X
  290. Xlint:
  291. X    $(LINT) $(LINTFLAGS) $(SRCS) $(LINTLIBS)
  292. Xlint1:
  293. X    $(LINT) $(LINTFLAGS) $(FILE) $(LINTLIBS)
  294. X
  295. Xclean::
  296. X    $(RM) $(PROGRAM)
  297. X
  298. X###########################################################################
  299. X# common rules for all Makefiles - do not edit
  300. X
  301. Xemptyrule::
  302. X
  303. Xclean::
  304. X    $(RM_CMD) \#*
  305. X
  306. XMakefile::
  307. X    -@if [ -f Makefile ]; then \
  308. X    echo "    $(RM) Makefile.bak; $(MV) Makefile Makefile.bak"; \
  309. X    $(RM) Makefile.bak; $(MV) Makefile Makefile.bak; \
  310. X    else exit 0; fi
  311. X    $(IMAKE_CMD) -DTOPDIR=$(TOP) -DCURDIR=$(CURRENT_DIR)
  312. X
  313. Xtags::
  314. X    $(TAGS) -w *.[ch]
  315. X    $(TAGS) -xw *.[ch] > TAGS
  316. X
  317. Xsaber:
  318. X    #load $(ALLDEFINES) $(SRCS)
  319. X
  320. Xosaber:
  321. X    #load $(ALLDEFINES) $(OBJS)
  322. X
  323. X###########################################################################
  324. X# empty rules for directories that do not have SUBDIRS - do not edit
  325. X
  326. Xinstall::
  327. X    @echo "install in $(CURRENT_DIR) done"
  328. X
  329. Xinstall.man::
  330. X    @echo "install.man in $(CURRENT_DIR) done"
  331. X
  332. XMakefiles::
  333. X
  334. Xincludes::
  335. X
  336. X###########################################################################
  337. X# dependencies generated by makedepend
  338. X
  339. END_OF_FILE
  340.   if test 9091 -ne `wc -c <'Makefile'`; then
  341.     echo shar: \"'Makefile'\" unpacked with wrong size!
  342.   fi
  343.   # end of 'Makefile'
  344. fi
  345. if test -f 'base.c' -a "${1}" != "-c" ; then 
  346.   echo shar: Will not clobber existing file \"'base.c'\"
  347. else
  348.   echo shar: Extracting \"'base.c'\" \(7113 characters\)
  349.   sed "s/^X//" >'base.c' <<'END_OF_FILE'
  350. X/* 
  351. XCopyright notice:
  352. X
  353. XThis is mine.  I'm only letting you use it.  Period.  Feel free to rip off
  354. Xany of the code you see fit, but have the courtesy to give me credit.
  355. XOtherwise great hairy beasties will rip your eyes out and eat your flesh
  356. Xwhen you least expect it.
  357. X
  358. XJonny Goldman <jonathan@think.com>
  359. X
  360. XWed May  8 1991
  361. X*/
  362. X
  363. X/* base.c - handle movement, etc. of the base. */
  364. X
  365. X#include "vaders.h"
  366. X
  367. Xextern int paused;
  368. XBoolean basedestroyed;
  369. X
  370. Xstatic Boolean showingexplosion = FALSE;
  371. X
  372. Xvoid DrawBuildings();
  373. X
  374. X#define BASEY (gameheight-base->height)
  375. X
  376. Xtypedef struct _BaseRec {
  377. X  int x;            /* Location. */
  378. X  int v;            /* velocity */
  379. X  int width, height;        /* box of this base. */
  380. X  XImage *shape_image;        /* an XImage for the spaceship */
  381. X} BaseRec, *Base;
  382. X
  383. XBaseRec baserec;
  384. X
  385. XBase base = &baserec;
  386. X
  387. XXImage *explosion;
  388. X
  389. X#define BaseNearPoint(base, x, y)    \
  390. X  ((base)->x <= (x) && (x) < (base)->x + (base)->width  && \
  391. X   y <= BASEY + (base)->height && y > BASEY)
  392. X
  393. X#include "base1.bit"
  394. X#include "base2.bit"
  395. X#include "explode1.bit"
  396. X#include "explode2.bit"
  397. X
  398. Xint ReadBaseImage()
  399. X{
  400. X  unsigned int width, height;
  401. X  int x_hot, y_hot;
  402. X  char *data, filename[255];
  403. X  int status;
  404. X
  405. X  base->width = (scale == 1) ? base1_width : base2_width;
  406. X  base->height = (scale == 1) ? base1_height : base2_height;
  407. X
  408. X  base->shape_image = XCreateImage(dpy,
  409. X                   DefaultVisual(dpy, DefaultScreen(dpy)),
  410. X                   1,
  411. X                   XYBitmap,
  412. X                   0,
  413. X                   (scale == 1) ? base1_bits : base2_bits,
  414. X                   base->width, base->height,
  415. X                   8, 0);
  416. X
  417. X  base->shape_image->bitmap_bit_order = LSBFirst;
  418. X  base->shape_image->byte_order = LSBFirst;
  419. X
  420. X  explosion = XCreateImage(dpy,
  421. X               DefaultVisual(dpy, DefaultScreen(dpy)),
  422. X               1,
  423. X               XYBitmap,
  424. X               0,
  425. X               (scale == 1) ? explode1_bits : explode2_bits,
  426. X               (scale == 1) ? explode1_width : explode2_width,
  427. X               (scale == 1) ? explode1_height : explode2_height,
  428. X               8, 0);
  429. X  explosion->bitmap_bit_order = LSBFirst;
  430. X  explosion->byte_order = LSBFirst;
  431. X  
  432. X  return BitmapSuccess;
  433. X}
  434. X
  435. Xvoid InitBase()
  436. X{
  437. X    if( ReadBaseImage() != BitmapSuccess) {
  438. X      fprintf(stderr, "Error reading base image.\n");
  439. X      exit(20);
  440. X    }
  441. X    basedestroyed = TRUE;
  442. X    showingexplosion = FALSE;
  443. X    basetimerid = NULL;
  444. X    base->v = 0;
  445. X}
  446. X
  447. X
  448. X
  449. Xvoid PaintBase(gc)
  450. XGC gc;
  451. X{
  452. X  XPutImage(dpy, gamewindow, gc, base->shape_image,
  453. X        0, 0, base->x, gameheight-base->height, base->width, base->height);
  454. X}
  455. X
  456. X
  457. XShowBase(i, gc)
  458. Xint i;
  459. XGC gc;
  460. X{
  461. X  XPutImage(dpy, labelwindow, gc, base->shape_image,
  462. X        0, 0, i*(base->width+2), gameheight/2-(3*base->height),
  463. X        base->width, base->height);
  464. X}
  465. X
  466. XPaintBasesLeft()
  467. X{
  468. X  int i;
  469. X  XDrawString(dpy, labelwindow, scoregc,
  470. X          0, gameheight-(4*base->height),
  471. X          "Bases", 5);
  472. X  for(i = 0; i < basesleft; i++) {
  473. X    ShowBase(i, basegc);
  474. X  }
  475. X}
  476. X
  477. X
  478. Xvoid ShowExplosion(gc)
  479. XGC gc;
  480. X{
  481. X  XPutImage(dpy, gamewindow, gc, explosion,
  482. X          0, 0, base->x, gameheight-base->height, explosion->width, explosion->height);
  483. X}
  484. X
  485. Xvoid DestroyBase()
  486. X{
  487. X  if(!paused) {
  488. X    PaintBase(backgc);
  489. X    basedestroyed = TRUE;
  490. X    showingexplosion = TRUE;
  491. X    ShowExplosion(basegc);
  492. X    if (basetimerid) XtRemoveTimeOut(basetimerid);
  493. X    basetimerid = XtAddTimeOut(1000, MoveBase, (Opaque) MoveBase);
  494. X  }
  495. X}
  496. X
  497. X
  498. XBoolean ShotHitsBase(x,y)
  499. Xint x,y;
  500. X{
  501. X  if(!basedestroyed && BaseNearPoint(base, x, y)) {
  502. X    DestroyBase();
  503. X    return TRUE;
  504. X  }
  505. X  return FALSE;
  506. X}
  507. X
  508. XResetGame()
  509. X{
  510. X  static Arg args[1];
  511. X
  512. X  spacer_shown = 0;
  513. X  SuspendTimers();
  514. X  XClearWindow(dpy, gamewindow);
  515. X  paused = 1;
  516. X  InitScore();
  517. X  basesleft--;
  518. X  level = 1;
  519. X  CreateVaders(level);
  520. X  spacer_counter = 1000;
  521. X  numshots = 0;
  522. X  numvshots = 0;
  523. X  PaintAllVaders();
  524. X  PaintBasesLeft();
  525. X  InitBuildings();
  526. X  DrawBuildings();
  527. X  lastscore = 0;
  528. X  PaintScore();
  529. X  XSync(dpy, 0);
  530. X  basedestroyed = FALSE;
  531. X  base->x = base->v = 0;
  532. X  showingexplosion = FALSE;
  533. X  PaintBase(basegc);
  534. X  XtSetArg(args[0], XtNlabel, "Start");
  535. X  XtSetValues(pausebutton, args, 1);
  536. X}
  537. X
  538. X/*ARGSUSED*/
  539. Xvoid MoveBase(closure, id)
  540. XOpaque closure;
  541. XXtIntervalId id;
  542. X{
  543. X  if (closure != (Opaque) MoveBase) return;
  544. X  if(!paused) {
  545. X    if (basedestroyed) {
  546. X      if (showingexplosion) {
  547. X    ShowExplosion(backgc);
  548. X    showingexplosion = FALSE;
  549. X    basetimerid = XtAddTimeOut(2000, MoveBase, (Opaque) MoveBase);
  550. X    return;
  551. X      }
  552. X      if (basesleft <= 0) {
  553. X    ResetGame();
  554. X    return;
  555. X      }
  556. X      base->x = 0;
  557. X      basesleft--;
  558. X      ShowBase(basesleft, backgc);
  559. X      PaintBase(basegc);
  560. X      PaintScore();
  561. X      basedestroyed = FALSE;
  562. X      base->v = 0;
  563. X    }
  564. X
  565. X    if (!paused)
  566. X      basetimerid = XtAddTimeOut(basewait, MoveBase, (Opaque) MoveBase);
  567. X    if(base->v) {
  568. X      PaintBase(backgc);
  569. X      base->x += base->v;
  570. X      base->x = (base->x < 0) ? 0 :
  571. X      ((base->x > gamewidth-base->width) ? gamewidth-base->width : base->x);
  572. X      PaintBase(basegc);
  573. X    }
  574. X  }
  575. X}
  576. X
  577. Xvoid MoveLeft()
  578. X{
  579. X  if(!paused) base->v= -scale;
  580. X}
  581. X
  582. X
  583. Xvoid MoveRight()
  584. X{
  585. X  if(!paused) base->v = scale;
  586. X}
  587. X
  588. X
  589. Xvoid Stop()
  590. X{
  591. X  if(!paused)
  592. X    base->v = 0;
  593. X}
  594. X
  595. X
  596. Xvoid Fire()
  597. X{
  598. X    if (!basedestroyed&&!paused) AddShot(base->x+base->width/2, gameheight-base->height);
  599. X}
  600. X
  601. X/* this part is for the buildings */
  602. X
  603. X#define NUMBUILDINGS 4
  604. X#define HUNKROWS 4
  605. X#define NUMHUNKS 10
  606. X#define HUNKWIDTH (2*scale)
  607. X#define HUNKHEIGHT (4*scale)
  608. X#define buildingwidth HUNKWIDTH*NUMHUNKS
  609. X#define buildingheight HUNKHEIGHT*HUNKROWS
  610. X
  611. Xtypedef struct {
  612. X  int x,y;
  613. X  Boolean hunks[HUNKROWS][NUMHUNKS];
  614. X} BuildingRec, *Building;
  615. X
  616. XBuildingRec buildings[NUMBUILDINGS];
  617. X
  618. X
  619. Xvoid DrawBuildingHunk(building, r, c, gc)
  620. XBuilding building;
  621. Xint r,c;
  622. XGC gc;
  623. X{
  624. X  int x, y;
  625. X
  626. X  x = building->x+c*HUNKWIDTH;
  627. X  y = gameheight-scale*45+r*HUNKHEIGHT;
  628. X
  629. X  XFillRectangle(dpy, gamewindow, gc, x, y, HUNKWIDTH, HUNKHEIGHT);
  630. X}
  631. X
  632. Xvoid ToastHunk(building,r,c)
  633. XBuilding building;
  634. Xint r,c;
  635. X{
  636. X  building->hunks[r][c] = FALSE;
  637. X  DrawBuildingHunk(building, r, c, backgc);
  638. X}
  639. X
  640. XBoolean ShotHitsBuilding(x, y)
  641. Xint x,y;
  642. X{
  643. X  int i, r, c;
  644. X  Building building;
  645. X
  646. X  for(i=0; i< NUMBUILDINGS; i++) {
  647. X    building = &buildings[i];
  648. X    if(x>=building->x && x<building->x+buildingwidth &&
  649. X       y>=gameheight-scale*45 && y<gameheight-scale*45+buildingheight) {
  650. X      r = (y-(gameheight-scale*45))/HUNKHEIGHT;
  651. X      c = (x-building->x)/HUNKWIDTH;
  652. X      if (r<0 || r>=HUNKROWS)
  653. X    printf("Error in row");
  654. X      if (c<0 || c>=NUMHUNKS)
  655. X    printf("Error in column");
  656. X      if(building->hunks[r][c]) {
  657. X    ToastHunk(building, r,c);
  658. X    return TRUE;
  659. X      }
  660. X      return FALSE;
  661. X    }
  662. X  }
  663. X  return FALSE;
  664. X}
  665. X
  666. XInitBuildings()
  667. X{
  668. X  int i, j, k;
  669. X
  670. X  for(i=0; i< NUMBUILDINGS; i++) {
  671. X    buildings[i].x = i*((gamewidth ?
  672. X             (scale*(VWIDTH-70)) :
  673. X             (gamewidth-scale*70)))/4+scale*35+(HUNKWIDTH*NUMHUNKS)/2;
  674. X    for (j=0; j<HUNKROWS; j++)
  675. X      for (k = 0; k < NUMHUNKS; k++) 
  676. X    buildings[i].hunks[j][k] = TRUE;
  677. X  }
  678. X  j--;
  679. X
  680. X  for(i=0; i< NUMBUILDINGS; i++) {
  681. X    buildings[i].hunks[0][0] = FALSE;
  682. X    buildings[i].hunks[0][NUMHUNKS-1] = FALSE;
  683. X    for (k = 3; k < NUMHUNKS-3; k++) 
  684. X    buildings[i].hunks[j][k] = FALSE;
  685. X  }
  686. X}
  687. X
  688. Xvoid DrawBuildings()
  689. X{
  690. X  int i, j, k;
  691. X
  692. X  for(i=0; i< NUMBUILDINGS; i++) {
  693. X    for (j=0; j<HUNKROWS; j++)
  694. X      for (k = 0; k < NUMHUNKS; k++) 
  695. X    if(buildings[i].hunks[j][k]) DrawBuildingHunk(&buildings[i], j, k, buildinggc);
  696. X  }
  697. X}
  698. END_OF_FILE
  699.   if test 7113 -ne `wc -c <'base.c'`; then
  700.     echo shar: \"'base.c'\" unpacked with wrong size!
  701.   fi
  702.   # end of 'base.c'
  703. fi
  704. if test -f 'main.c' -a "${1}" != "-c" ; then 
  705.   echo shar: Will not clobber existing file \"'main.c'\"
  706. else
  707.   echo shar: Extracting \"'main.c'\" \(8498 characters\)
  708.   sed "s/^X//" >'main.c' <<'END_OF_FILE'
  709. X/* 
  710. XCopyright notice:
  711. X
  712. XThis is mine.  I'm only letting you use it.  Period.  Feel free to rip off
  713. Xany of the code you see fit, but have the courtesy to give me credit.
  714. XOtherwise great hairy beasties will rip your eyes out and eat your flesh
  715. Xwhen you least expect it.
  716. X
  717. XJonny Goldman <jonathan@think.com>
  718. X
  719. XWed May  8 1991
  720. X*/
  721. X
  722. X/* main.c -- create our windows and initialize things. */
  723. X
  724. X#define MAIN
  725. X#include "vaders.h"
  726. X#include <X11/Xaw/Form.h>
  727. X#ifndef X11R3
  728. X#include <X11/Xaw/Label.h>
  729. X#else
  730. X#include <X11/IntrinsicP.h>
  731. X#include <X11/Label.h>
  732. X#endif
  733. Xstatic int width, height;        /* Size of window. */
  734. X
  735. X#ifdef XFILESEARCHPATH
  736. Xstatic void AddPathToSearchPath();
  737. X#endif
  738. X
  739. Xstatic XrmOptionDescRec table[] = {
  740. X    {"-debug",    "*debug",    XrmoptionNoArg,    NULL},
  741. X};
  742. X
  743. Xstatic XtResource resources[] = {
  744. X    {XtNwidth, XtCWidth, XtRInt, sizeof(int),
  745. X     (Cardinal)&width, XtRImmediate, (caddr_t) VWIDTH},
  746. X    {XtNheight, XtCHeight, XtRInt, sizeof(int),
  747. X     (Cardinal)&height, XtRImmediate, (caddr_t) VHEIGHT},
  748. X    {"debug", "Debug", XtRBoolean, sizeof(Boolean),
  749. X     (Cardinal)&debug, XtRString, "off"},
  750. X    {"font", "Font", XtRString, sizeof(String),
  751. X     (Cardinal)&vaderfont, XtRString, (String)"9x15"},
  752. X    {"scale", "Scale", XtRInt, sizeof(int),
  753. X     (Cardinal)&scale, XtRImmediate, (caddr_t) 2},
  754. X    {"basewait", "BaseWait", XtRInt, sizeof(int),
  755. X     (Cardinal)&basewait, XtRImmediate, (caddr_t) 10},
  756. X    {"vaderwait", "VaderWait", XtRInt, sizeof(int),
  757. X     (Cardinal)&vaderwait, XtRImmediate, (caddr_t) 300},
  758. X    {"spacerwait", "SpacerWait", XtRInt, sizeof(int),
  759. X     (Cardinal)&spacerwait, XtRImmediate, (caddr_t) 50},
  760. X    {"shotwait", "ShotWait", XtRInt, sizeof(int),
  761. X     (Cardinal)&shotwait, XtRImmediate, (caddr_t) 10},
  762. X    {"vshotwait", "VshotWait", XtRInt, sizeof(int),
  763. X     (Cardinal)&vshotwait, XtRImmediate, (caddr_t) 30},
  764. X    {"basecolor", "BaseColor", XtRPixel, sizeof(Pixel),
  765. X     (Cardinal)&basepixel, XtRString, "cyan"},
  766. X    {"spacercolor", "SpacerColor", XtRPixel, sizeof(Pixel),
  767. X     (Cardinal)&spacerpixel, XtRString, "gray"},
  768. X    {"buildingcolor", "BuildingColor", XtRPixel, sizeof(Pixel),
  769. X     (Cardinal)&buildingpixel, XtRString, "yellow"},
  770. X    {"vader1color", "Vader1Color", XtRPixel, sizeof(Pixel),
  771. X     (Cardinal)&vader1pixel, XtRString, "blue"},
  772. X    {"vader2color", "Vader2Color", XtRPixel, sizeof(Pixel),
  773. X     (Cardinal)&vader2pixel, XtRString, "green"},
  774. X    {"vader3color", "Vader3Color", XtRPixel, sizeof(Pixel),
  775. X     (Cardinal)&vader3pixel, XtRString, "red"},
  776. X    {"shotcolor", "ShotColor", XtRPixel, sizeof(Pixel),
  777. X     (Cardinal)&shotpixel, XtRString, "lavender"},
  778. X    {"vshotcolor", "VshotColor", XtRPixel, sizeof(Pixel),
  779. X     (Cardinal)&vshotpixel, XtRString, "orange"},
  780. X    {"scorecolor", "ScoreColor", XtRPixel, sizeof(Pixel),
  781. X     (Cardinal)&scorepixel, XtRString, "white"},
  782. X    {"maxshots", "MaxShots", XtRInt, sizeof(int),
  783. X     (Cardinal) &maxshots, XtRImmediate, (caddr_t) 1},
  784. X    {"maxvshots", "MaxVshots", XtRInt, sizeof(int),
  785. X     (Cardinal) &maxvshots, XtRImmediate, (caddr_t) 6},
  786. X    {"defaultfore", "DefaultFore", XtRPixel, sizeof(Pixel),
  787. X     (Cardinal) &defaultfore, XtRString, "white"},
  788. X    {"defaultback", "DefaultBack", XtRPixel, sizeof(Pixel),
  789. X     (Cardinal) &defaultback, XtRString, "black"},
  790. X};
  791. X
  792. X
  793. X/*ARGSUSED*/
  794. Xstatic void CvtStringToFloat(args, num_args, fromVal, toVal)
  795. XArgList args;
  796. XCardinal num_args;
  797. XXrmValue    *fromVal;
  798. XXrmValue    *toVal;
  799. X{
  800. X    static float  i;
  801. X
  802. X    if (sscanf((char *)fromVal->addr, "%f", &i) == 1) {
  803. X    toVal->size = sizeof(float);
  804. X    toVal->addr = (caddr_t) &i;
  805. X    } else {
  806. X    toVal->size = 0;
  807. X    toVal->addr = NULL;
  808. X    }
  809. X}
  810. X
  811. Xstatic void AddResource(r, p)
  812. Xchar *r;
  813. XPixel *p;
  814. X{
  815. X    XrmValue value;
  816. X    XrmDatabase db = XtDatabase(dpy);
  817. X    value.size = sizeof(Pixel);
  818. X    value.addr = (caddr_t) p;
  819. X    XrmPutResource(&db, r, XtRPixel, &value);
  820. X}
  821. X
  822. XWidget
  823. XMakeCommandButton(box, name, function, vlink, hlink, data)
  824. XWidget box, vlink, hlink;
  825. Xchar *name;
  826. XXtCallbackProc function;
  827. Xcaddr_t data;
  828. X{
  829. X  Widget w;
  830. X  Arg args[10];
  831. X  Cardinal numargs;
  832. X
  833. X  numargs = 0;
  834. X  if(vlink != NULL) {
  835. X    XtSetArg(args[numargs], XtNfromVert, vlink); numargs++;
  836. X  }
  837. X  if(hlink != NULL) {
  838. X    XtSetArg(args[numargs], XtNfromHoriz, hlink); numargs++;
  839. X  }
  840. X  w = XtCreateManagedWidget(name, commandWidgetClass, box, args, numargs);
  841. X  if (function != NULL)
  842. X    XtAddCallback(w, XtNcallback, function, data);
  843. X  return w;
  844. X}
  845. X
  846. Xmain(argc, argv)
  847. XCardinal argc;
  848. Xchar **argv;
  849. X{
  850. X  static Arg args[10];
  851. X  int n;
  852. X  Widget form, button;
  853. X  extern WidgetClass labelwidgetclass;
  854. X
  855. X  me_image = NULL;
  856. X
  857. X  srandom(time(0));
  858. X#ifdef XFILESEARCHPATH
  859. X  AddPathToSearchPath(XFILESEARCHPATH);
  860. X#endif
  861. X  toplevel = XtInitialize(argv[0], "Vaders", table, XtNumber(table),
  862. X              &argc, argv);
  863. X  dpy = XtDisplay(toplevel);
  864. X  XtAddConverter(XtRString, XtRFloat, CvtStringToFloat, NULL, 0);
  865. X  XtGetApplicationResources(toplevel, (caddr_t) NULL, 
  866. X                resources, XtNumber(resources),
  867. X                NULL, (Cardinal) 0);
  868. X  AddResource("*background", &defaultback);
  869. X  if (DisplayCells(dpy, DefaultScreen(dpy)) <= 2)
  870. X    {
  871. X      basepixel = defaultfore;
  872. X      buildingpixel = defaultfore;
  873. X      vader1pixel = defaultfore;
  874. X      vader2pixel = defaultfore;
  875. X      vader3pixel = defaultfore;
  876. X      shotpixel = defaultfore;
  877. X      vshotpixel = defaultfore;
  878. X      scorepixel = defaultfore;
  879. X    }
  880. X  if (scale<1) scale = 1;
  881. X  if (scale>2) scale = 2;
  882. X  width = scale*VWIDTH;
  883. X  height = scale*VHEIGHT;
  884. X
  885. X  form = XtCreateManagedWidget ("form", formWidgetClass,
  886. X                toplevel, NULL, 0);
  887. X
  888. X  n = 0;
  889. X  XtSetArg (args[n], XtNleft, XtChainLeft); n++;
  890. X  XtSetArg (args[n], XtNright, XtChainLeft); n++;
  891. X  XtSetArg (args[n], XtNtop, XtChainTop); n++;
  892. X  XtSetArg (args[n], XtNbottom, XtChainTop); n++;
  893. X  XtSetArg (args[n], XtNwidth, width); n++;
  894. X  XtSetArg (args[n], XtNheight, height); n++;
  895. X  
  896. X  gamewidget = (VadersWidget)
  897. X    XtCreateManagedWidget("field", vadersWidgetClass, form, args, n);
  898. X
  899. X  n = 0;
  900. X  XtSetArg (args[n], XtNleft, XtChainLeft); n++;
  901. X  XtSetArg (args[n], XtNright, XtChainLeft); n++;
  902. X  XtSetArg (args[n], XtNtop, XtChainTop); n++;
  903. X  XtSetArg (args[n], XtNbottom, XtChainTop); n++;
  904. X  XtSetArg (args[n], XtNfromHoriz, gamewidget); n++;
  905. X  XtSetArg (args[n], XtNhorizDistance, 5); n++;
  906. X  XtSetArg (args[n], XtNwidth, scale*IWIDTH); n++;
  907. X  XtSetArg (args[n], XtNheight, height/2); n++;
  908. X  
  909. X  labelwidget = (VadersWidget)
  910. X    XtCreateManagedWidget("label", vadersWidgetClass, form, args, n);
  911. X
  912. X  pausebutton = MakeCommandButton(form, "pause", Pause, labelwidget, gamewidget, NULL);
  913. X  XtSetArg(args[0], XtNlabel, " Start");
  914. X  XtSetArg(args[1], XtNforeground, defaultfore);
  915. X  XtSetArg(args[2], XtNbackground, defaultback);
  916. X  XtSetArg(args[3], XtNborderColor, defaultfore);
  917. X  XtSetValues(pausebutton, args, 4);
  918. X  button = MakeCommandButton(form, "quit", Quit, pausebutton, gamewidget, NULL);
  919. X  XtSetArg(args[0], XtNlabel, " Quit ");
  920. X  XtSetArg(args[1], XtNforeground, defaultfore);
  921. X  XtSetArg(args[2], XtNbackground, defaultback);
  922. X  XtSetArg(args[3], XtNborderColor, defaultfore);
  923. X  XtSetValues(button, args, 4);
  924. X  infobutton = MakeCommandButton(form, "info", ShowInfo, button, gamewidget, NULL);
  925. X  XtSetArg(args[0], XtNlabel, " Info ");
  926. X  XtSetArg(args[1], XtNforeground, defaultfore);
  927. X  XtSetArg(args[2], XtNbackground, defaultback);
  928. X  XtSetArg(args[3], XtNborderColor, defaultfore);
  929. X  XtSetValues(infobutton, args, 4);
  930. X
  931. X  XtRealizeWidget(toplevel);
  932. X  ResetGame();
  933. X  XtMainLoop();
  934. X}
  935. X
  936. X#ifdef XFILESEARCHPATH
  937. Xstatic void
  938. XAddPathToSearchPath(path)
  939. Xchar *path;
  940. X{
  941. X     char *old, *new;
  942. X     extern char *getenv();
  943. X     
  944. X     old = getenv("XFILESEARCHPATH");
  945. X     if (old) {
  946. X#if defined(mips) || defined(hpux) || defined(sun)
  947. X      /* +1 for =, +2 for :, +3 for null */
  948. X      new = XtMalloc((Cardinal) (strlen("XFILESEARCHPATH") +
  949. X                     strlen(old) +
  950. X                     strlen(path) + 3));
  951. X      (void) strcpy(new, "XFILESEARCHPATH");
  952. X      (void) strcat(new, "=");
  953. X      (void) strcat(new, old);
  954. X      (void) strcat(new, ":");
  955. X      (void) strcat(new, path);
  956. X      putenv(new);
  957. X#else
  958. X      /* +1 for colon, +2 for null */
  959. X      new = XtMalloc((Cardinal) (strlen(old) + strlen(path) + 2));
  960. X      (void) strcpy(new, old);
  961. X      (void) strcat(new, ":");
  962. X      (void) strcat(new, path);
  963. X      setenv("XFILESEARCHPATH", new, 1);
  964. X#endif
  965. X     }
  966. X     else {
  967. X#if defined(mips) || defined(hpux) || defined(sun)
  968. X      new = XtMalloc((Cardinal) (strlen("XFILESEARCHPATH") +
  969. X                     strlen(path) + 2));
  970. X      (void) strcpy(new, "XFILESEARCHPATH");
  971. X      (void) strcat(new, "=");
  972. X      (void) strcat(new, path);
  973. X      putenv(new);
  974. X#else
  975. X      setenv("XFILESEARCHPATH", path, 1);
  976. X#endif
  977. X     }
  978. X}
  979. X#endif
  980. X
  981. X#ifdef sparc
  982. XXShapeCombineMask()
  983. X{}
  984. X
  985. XXShapeQueryExtension()
  986. X{}
  987. X#endif
  988. END_OF_FILE
  989.   if test 8498 -ne `wc -c <'main.c'`; then
  990.     echo shar: \"'main.c'\" unpacked with wrong size!
  991.   fi
  992.   # end of 'main.c'
  993. fi
  994. if test -f 'spacers.c' -a "${1}" != "-c" ; then 
  995.   echo shar: Will not clobber existing file \"'spacers.c'\"
  996. else
  997.   echo shar: Extracting \"'spacers.c'\" \(3471 characters\)
  998.   sed "s/^X//" >'spacers.c' <<'END_OF_FILE'
  999. X/* 
  1000. XCopyright notice:
  1001. X
  1002. XThis is mine.  I'm only letting you use it.  Period.  Feel free to rip off
  1003. Xany of the code you see fit, but have the courtesy to give me credit.
  1004. XOtherwise great hairy beasties will rip your eyes out and eat your flesh
  1005. Xwhen you least expect it.
  1006. X
  1007. XJonny Goldman <jonathan@think.com>
  1008. X
  1009. XWed May  8 1991
  1010. X*/
  1011. X
  1012. X/* spacers.c - handle movement, etc. of the little space ships. */
  1013. X
  1014. X#include "vaders.h"
  1015. X
  1016. XBoolean spacer_shown;
  1017. X
  1018. X#define SPACERY 0
  1019. X#define SPACERV 2*scale
  1020. X
  1021. Xtypedef struct _SpacerRec {
  1022. X  int x;            /* Location. */
  1023. X  int width, height;        /* box of this rock. */
  1024. X  int score;            /* value of this guy */
  1025. X  XImage *shape_image;        /* an XImage for the spaceship */
  1026. X} SpacerRec, *Spacer;
  1027. X
  1028. XSpacerRec spacerrec;
  1029. X
  1030. XSpacer spacer = &spacerrec;
  1031. X
  1032. X#define SpacerNearPoint(spacer, x, y)    \
  1033. X  ((spacer)->x <= (x) && (x) < (spacer)->x + (spacer)->width  && \
  1034. X   y <= SPACERY + (spacer)->height && y > SPACERY)
  1035. X
  1036. Xint spacer_counter;        /* number of steps to wait for new spacer */
  1037. X
  1038. Xint showing_sexplosion = FALSE;
  1039. X
  1040. X/* now the code */
  1041. X
  1042. Xvoid PaintSpacer(gc)
  1043. X     GC gc;
  1044. X{
  1045. X    XPutImage(dpy, gamewindow, gc, spacer->shape_image,
  1046. X          0, 0, spacer->x, SPACERY, spacer->width, spacer->height);
  1047. X}
  1048. X
  1049. X
  1050. Xvoid ShowSexplosion(gc)
  1051. XGC gc;
  1052. X{
  1053. X  char score[5];
  1054. X
  1055. X  sprintf(score,"%3d", spacer->score);
  1056. X  XDrawString(dpy, gamewindow, gc, spacer->x, SPACERY+spacer->height, score, 3);
  1057. X
  1058. X}
  1059. X
  1060. X/*
  1061. X * Destroy the Spacer, much like the ship.
  1062. X */
  1063. X
  1064. Xstatic void DestroySpacer()
  1065. X{
  1066. X  score += spacer->score;
  1067. X  PaintScore();
  1068. X
  1069. X  if(!paused) {
  1070. X    PaintSpacer(backgc);
  1071. X    ShowSexplosion(spacergc);
  1072. X    if (spacertimerid)
  1073. X      XtRemoveTimeOut(spacertimerid);
  1074. X    XtAddTimeOut(1000, MoveSpacer, (Opaque) MoveSpacer);
  1075. X    showing_sexplosion = TRUE;
  1076. X    spacer_shown = FALSE;
  1077. X  }
  1078. X}
  1079. X
  1080. XBoolean ShotHitsSpacer(x, y)
  1081. X     int x, y;
  1082. X{
  1083. X  if(spacer_shown) {
  1084. X    if (SpacerNearPoint(spacer, x, y)) {
  1085. X      DestroySpacer();
  1086. X      return TRUE;
  1087. X    }
  1088. X  }
  1089. X  return FALSE;
  1090. X}
  1091. X
  1092. X
  1093. X
  1094. Xvoid MakeSpacer()
  1095. X{
  1096. X  spacer_shown = TRUE;
  1097. X
  1098. X  spacer->x=0;
  1099. X  spacer->score = 50*(random()%6+1);
  1100. X  PaintSpacer(spacergc);
  1101. X}
  1102. X  
  1103. X/*ARGSUSED*/
  1104. Xvoid MoveSpacer(closure, id)
  1105. X     Opaque closure;
  1106. X     XtIntervalId id;
  1107. X{
  1108. X  if (closure != (Opaque) MoveSpacer) return;
  1109. X  spacertimerid = XtAddTimeOut(spacerwait, MoveSpacer, (Opaque) MoveSpacer);
  1110. X  if (!paused) {
  1111. X    if (showing_sexplosion) {
  1112. X      showing_sexplosion = FALSE;
  1113. X      ShowSexplosion(backgc);
  1114. X      spacer_shown = FALSE;
  1115. X      spacer_counter = 1000;
  1116. X      return;
  1117. X    }
  1118. X    if (spacer_shown) {
  1119. X      PaintSpacer(backgc);
  1120. X      spacer->x += SPACERV;
  1121. X      if (spacer->x < gamewidth-spacer->width) {
  1122. X    PaintSpacer(spacergc);
  1123. X      } else {
  1124. X    spacer_shown = FALSE;
  1125. X    spacer_counter = 1000;
  1126. X      }
  1127. X    } else
  1128. X      if (spacer_counter-- == 0) MakeSpacer();
  1129. X  }
  1130. X}
  1131. X
  1132. X
  1133. X#include "spacer1.bit"
  1134. X#include "spacer2.bit"
  1135. X
  1136. Xint ReadSpacerImages()
  1137. X{
  1138. X  spacer->width = (scale == 1) ? spacer1_width : spacer2_width;
  1139. X  spacer->height = (scale == 1) ? spacer1_height : spacer2_height;
  1140. X
  1141. X  spacer->shape_image = XCreateImage(dpy,
  1142. X                     DefaultVisual(dpy, DefaultScreen(dpy)),
  1143. X                     1,
  1144. X                     XYBitmap,
  1145. X                     0,
  1146. X                     (scale == 1) ? spacer1_bits : spacer2_bits,
  1147. X                     spacer->width, spacer->height,
  1148. X                     8, 0);
  1149. X
  1150. X  spacer->shape_image->bitmap_bit_order = LSBFirst;
  1151. X  spacer->shape_image->byte_order = LSBFirst;
  1152. X
  1153. X  return BitmapSuccess;
  1154. X}
  1155. X
  1156. Xvoid InitSpacers()
  1157. X{
  1158. X  if(ReadSpacerImages()!= BitmapSuccess) {
  1159. X    fprintf(stderr, "Error reading Spacer image\n");
  1160. X    exit(10);
  1161. X  }
  1162. X
  1163. X  spacertimerid = NULL;
  1164. X}
  1165. END_OF_FILE
  1166.   if test 3471 -ne `wc -c <'spacers.c'`; then
  1167.     echo shar: \"'spacers.c'\" unpacked with wrong size!
  1168.   fi
  1169.   # end of 'spacers.c'
  1170. fi
  1171. if test -f 'vaders.c' -a "${1}" != "-c" ; then 
  1172.   echo shar: Will not clobber existing file \"'vaders.c'\"
  1173. else
  1174.   echo shar: Extracting \"'vaders.c'\" \(11501 characters\)
  1175.   sed "s/^X//" >'vaders.c' <<'END_OF_FILE'
  1176. X/* 
  1177. XCopyright notice:
  1178. X
  1179. XThis is mine.  I'm only letting you use it.  Period.  Feel free to rip off
  1180. Xany of the code you see fit, but have the courtesy to give me credit.
  1181. XOtherwise great hairy beasties will rip your eyes out and eat your flesh
  1182. Xwhen you least expect it.
  1183. X
  1184. XJonny Goldman <jonathan@think.com>
  1185. X
  1186. XWed May  8 1991
  1187. X*/
  1188. X
  1189. X/* vaders.c - handle movement, etc. of the vaders. */
  1190. X
  1191. X#include "vaders.h"
  1192. X
  1193. X#define NUMTYPES    3    /* How many types of vaders there are. */
  1194. X#define NUMROWS        5    /* number of rows of vaders */
  1195. X#define NUMVADERS    11    /* Maximum of vaders of each type. */
  1196. X#define BASEY 10
  1197. X#define VADERWIDTH    (14*scale)
  1198. X#define VADERHEIGHT    (12*scale)
  1199. X#define VADERYINC    (8*scale)
  1200. X
  1201. Xstatic XImage *Vader_Image[NUMTYPES][2];    /* XImages for the vaders. */
  1202. X
  1203. Xextern int basex;        /* Base location */
  1204. X
  1205. Xstatic int tick = 0;
  1206. Xstatic int vaderwaitinit;
  1207. X
  1208. Xtypedef struct _VaderRec {
  1209. X  int x, y;            /* Location. */
  1210. X  int vx, vy;            /* Velocity. */
  1211. X  int width, height;        /* size of this Vader. */
  1212. X  GC gc;            /* graphics context */
  1213. X  XImage *shape_image[2];
  1214. X  int value;
  1215. X  Boolean alive;
  1216. X  Boolean exploded;
  1217. X} VaderRec, *Vader;
  1218. X
  1219. XVaderRec vaders[NUMROWS][NUMVADERS];
  1220. X
  1221. Xint numvaders = 0;        /* Number of vaders existing. */
  1222. X
  1223. X
  1224. Xtypedef struct _BaseRec {
  1225. X  int x;            /* Location. */
  1226. X  int v;            /* velocity */
  1227. X  int width, height;        /* box of this base. */
  1228. X  XImage *shape_image;        /* an XImage for the spaceship */
  1229. X} BaseRec, *Base;
  1230. X
  1231. Xextern Base base;
  1232. X
  1233. XXImage *Explode_image;
  1234. X
  1235. X/* indicates pad around vader bitmap for better collision detection */
  1236. X#define VADERPAD     scale
  1237. X
  1238. X#define PointInVader(vader, x, y)    \
  1239. X  (x >= (vader)->x+VADERPAD && y >= (vader)->y &&        \
  1240. X   x <= (vader)->x + (vader)->width-VADERPAD  && y <= (vader)->y + (vader)->height)
  1241. X
  1242. Xstatic void PaintVader(vader, gc)
  1243. X     Vader vader;
  1244. X     GC gc;
  1245. X{
  1246. X  int rx, ry, w, h;
  1247. X  
  1248. X  w = vader->width;
  1249. X  h = vader->height;
  1250. X
  1251. X  rx = vader->x;
  1252. X  ry = vader->y;
  1253. X  
  1254. X  XPutImage(dpy, gamewindow, gc, vader->shape_image[tick],
  1255. X        0, 0, rx, ry, w, h);
  1256. X}
  1257. X
  1258. Xstatic void PaintExplodedVader(vader, gc)
  1259. X     Vader vader;
  1260. X     GC gc;
  1261. X{
  1262. X  int rx, ry, w, h;
  1263. X  
  1264. X  w = Explode_image->width;
  1265. X  h = Explode_image->height;
  1266. X
  1267. X  rx = vader->x;
  1268. X  ry = vader->y;
  1269. X  
  1270. X  XPutImage(dpy, gamewindow, gc, Explode_image,
  1271. X        0, 0, rx, ry, w, h);
  1272. X}
  1273. X
  1274. Xstatic void DestroyVader(vader)
  1275. XVader vader;
  1276. X{
  1277. X  PaintVader(vader, backgc);
  1278. X  score += vader->value;
  1279. X  PaintScore();
  1280. X  numvaders--;
  1281. X  switch (numvaders) {
  1282. X  case 32:
  1283. X  case 16:
  1284. X  case 8:
  1285. X  case 4:
  1286. X  case 2:
  1287. X  case 1:
  1288. X    vaderwait /= 2; break;
  1289. X  }
  1290. X  vader->alive = FALSE;
  1291. X  vader->exploded = TRUE;
  1292. X  PaintExplodedVader(vader, vader->gc);
  1293. X}
  1294. X
  1295. X
  1296. X
  1297. XBoolean ShotHitsVader(x, y)
  1298. X     int x, y;
  1299. X{
  1300. X  register Vader vader;
  1301. X  int i, j;
  1302. X
  1303. X  for(j = 0; j < NUMROWS; j++)
  1304. X    for (i=0 ; i<NUMVADERS ; i++) {
  1305. X      vader = &vaders[j][i];
  1306. X      if(vader->alive && PointInVader(vader, x, y)) {
  1307. X    DestroyVader(vader);
  1308. X    return TRUE;
  1309. X    }
  1310. X  }
  1311. X  return FALSE;
  1312. X}
  1313. X
  1314. X
  1315. X
  1316. Xvoid PaintAllVaders()
  1317. X{
  1318. X  int i, j;
  1319. X  Vader vader;
  1320. X
  1321. X  for(j = 0; j < NUMROWS; j++)
  1322. X    for (i=0 ; i< NUMVADERS ; i++) {
  1323. X      vader = &vaders[j][i];
  1324. X      if(vader->alive) PaintVader(vader, vader->gc);
  1325. X    }
  1326. X}
  1327. X
  1328. X/* add some random shot */
  1329. X
  1330. Xvoid SFire()
  1331. X{
  1332. X  register Vader vader;
  1333. X  int i, j, c;
  1334. X
  1335. X  for(j = 0, c = random()%NUMVADERS; j < NUMVADERS; j++) {
  1336. X    for (i= NUMROWS-1; i>=0; i--) {
  1337. X      vader = &vaders[i][(c+j)%NUMVADERS];
  1338. X      if(vader->alive) {
  1339. X    AddVshot(vader->x+vader->width/2, vader->y+vader->height);
  1340. X    return;
  1341. X      }
  1342. X    }
  1343. X  }
  1344. X}
  1345. X
  1346. Xvoid VaderBoop(tick)
  1347. Xint tick;
  1348. X{
  1349. X  XKeyboardControl vals;
  1350. X
  1351. X  vals.bell_duration = vaderwait/2;
  1352. X  vals.bell_pitch = tick ? 60 : 40;
  1353. X
  1354. X  XChangeKeyboardControl(dpy, KBBellPitch | KBBellDuration, &vals);
  1355. X  XBell(dpy, 100);
  1356. X}
  1357. X
  1358. Xstatic int createvaderp = FALSE;
  1359. X
  1360. X/*ARGSUSED*/
  1361. Xvoid MoveVaders(closure, id)
  1362. X     Opaque closure;
  1363. X     XtIntervalId id;
  1364. X{
  1365. X  register Vader vader;
  1366. X  register int i, j;
  1367. X  Boolean reversep;
  1368. X
  1369. X  reversep = FALSE;
  1370. X
  1371. X  if (closure != (Opaque) MoveVaders) return;
  1372. X  if (createvaderp) {
  1373. X    createvaderp = FALSE;
  1374. X    CreateVaders(level);
  1375. X  }
  1376. X  if (numvaders == 0 && numvshots == 0) {
  1377. X    vadertimerid = XtAddTimeOut(2000, MoveVaders, (Opaque) MoveVaders);
  1378. X    level++;
  1379. X    createvaderp = TRUE;
  1380. X    InitBuildings();
  1381. X    DrawBuildings();
  1382. X  } else {
  1383. X    vadertimerid = XtAddTimeOut(vaderwait, MoveVaders, (Opaque) MoveVaders);
  1384. X    /* this is the way to do it, but on the Sun it SUCKS!
  1385. X    VaderBoop(tick);
  1386. X    */
  1387. X    if((random()%1000)>900) SFire();
  1388. X    for(j = 0; j < NUMROWS; j++)
  1389. X      for (i=0 ; i< NUMVADERS ; i++) {
  1390. X    vader = &vaders[j][i];
  1391. X    if (vader->exploded) {
  1392. X      PaintExplodedVader(vader, backgc);
  1393. X      vader->exploded = FALSE;
  1394. X    }
  1395. X    else if (vader->alive) {
  1396. X      if (vader->vx > 0)
  1397. X        (void)ShotHitsBuilding(vader->x+vader->width, vader->y+vader->height);
  1398. X      else
  1399. X        (void)ShotHitsBuilding(vader->x, vader->y+vader->height);
  1400. X      vader->x += vader->vx;
  1401. X      if ((vader->x < (VADERWIDTH-vader->width)/2 && vader->vx < 0) || 
  1402. X          (vader->x > gamewidth-VADERWIDTH && vader->vx > 0))
  1403. X        reversep = TRUE;
  1404. X      tick = tick ? 0 : 1;
  1405. X      PaintVader(vader, vader->gc);
  1406. X      tick = tick ? 0 : 1;
  1407. X    }
  1408. X      }
  1409. X    tick = tick ? 0 : 1;
  1410. X    if (reversep) {
  1411. X      for(j = 0; j < NUMROWS; j++)
  1412. X    for (i=0 ; i< NUMVADERS ; i++) {
  1413. X      vader = &vaders[j][i];
  1414. X      if (vader->alive) {
  1415. X        PaintVader(vader, backgc);
  1416. X        vader->vx = -vader->vx;
  1417. X        vader->y = vader->y + VADERYINC;
  1418. X        PaintVader(vader, vader->gc);
  1419. X        if(vader->y >= gameheight-base->height+vader->height) {
  1420. X          ResetGame();
  1421. X          return;
  1422. X        }
  1423. X      }
  1424. X    }
  1425. X    }
  1426. X  }
  1427. X}
  1428. X
  1429. X#include "vader1a1.bit"
  1430. X#include "vader1b1.bit"
  1431. X#include "vader1a2.bit"
  1432. X#include "vader1b2.bit"
  1433. X#include "vader2a1.bit"
  1434. X#include "vader2b1.bit"
  1435. X#include "vader2a2.bit"
  1436. X#include "vader2b2.bit"
  1437. X#include "vader3a1.bit"
  1438. X#include "vader3b1.bit"
  1439. X#include "vader3a2.bit"
  1440. X#include "vader3b2.bit"
  1441. X#include "vexplod1.bit"
  1442. X#include "vexplod2.bit"
  1443. X
  1444. Xint ReadVaderImages()
  1445. X{
  1446. X  if (scale == 1) {
  1447. X    Vader_Image[0][0] = XCreateImage(dpy,
  1448. X                     DefaultVisual(dpy, DefaultScreen(dpy)),
  1449. X                     1,
  1450. X                     XYBitmap,
  1451. X                     0,
  1452. X                     vader1a1_bits,
  1453. X                     vader1a1_width, vader1a1_height,
  1454. X                     8, 0);
  1455. X    Vader_Image[0][0]->bitmap_bit_order = LSBFirst;
  1456. X    Vader_Image[0][0]->byte_order = LSBFirst;
  1457. X
  1458. X    Vader_Image[0][1] = XCreateImage(dpy,
  1459. X                     DefaultVisual(dpy, DefaultScreen(dpy)),
  1460. X                     1,
  1461. X                     XYBitmap,
  1462. X                     0,
  1463. X                     vader1b1_bits,
  1464. X                     vader1b1_width, vader1b1_height,
  1465. X                     8, 0);
  1466. X    Vader_Image[0][1]->bitmap_bit_order = LSBFirst;
  1467. X    Vader_Image[0][1]->byte_order = LSBFirst;
  1468. X
  1469. X    Vader_Image[1][0] = XCreateImage(dpy,
  1470. X                     DefaultVisual(dpy, DefaultScreen(dpy)),
  1471. X                     1,
  1472. X                     XYBitmap,
  1473. X                     0,
  1474. X                     vader2a1_bits,
  1475. X                     vader2a1_width, vader2a1_height,
  1476. X                     8, 0);
  1477. X    Vader_Image[1][0]->bitmap_bit_order = LSBFirst;
  1478. X    Vader_Image[1][0]->byte_order = LSBFirst;
  1479. X
  1480. X    Vader_Image[1][1] = XCreateImage(dpy,
  1481. X                     DefaultVisual(dpy, DefaultScreen(dpy)),
  1482. X                     1,
  1483. X                     XYBitmap,
  1484. X                     0,
  1485. X                     vader2b1_bits,
  1486. X                     vader2b1_width, vader2b1_height,
  1487. X                     8, 0);
  1488. X    Vader_Image[1][1]->bitmap_bit_order = LSBFirst;
  1489. X    Vader_Image[1][1]->byte_order = LSBFirst;
  1490. X
  1491. X    Vader_Image[2][0] = XCreateImage(dpy,
  1492. X                     DefaultVisual(dpy, DefaultScreen(dpy)),
  1493. X                     1,
  1494. X                     XYBitmap,
  1495. X                     0,
  1496. X                     vader3a1_bits,
  1497. X                     vader3a1_width, vader3a1_height,
  1498. X                     8, 0);
  1499. X    Vader_Image[2][0]->bitmap_bit_order = LSBFirst;
  1500. X    Vader_Image[2][0]->byte_order = LSBFirst;
  1501. X
  1502. X    Vader_Image[2][1] = XCreateImage(dpy,
  1503. X                     DefaultVisual(dpy, DefaultScreen(dpy)),
  1504. X                     1,
  1505. X                     XYBitmap,
  1506. X                     0,
  1507. X                     vader3b1_bits,
  1508. X                     vader3b1_width, vader3b1_height,
  1509. X                     8, 0);
  1510. X    Vader_Image[2][1]->bitmap_bit_order = LSBFirst;
  1511. X    Vader_Image[2][1]->byte_order = LSBFirst;
  1512. X
  1513. X    Explode_image = XCreateImage(dpy,
  1514. X                 DefaultVisual(dpy, DefaultScreen(dpy)),
  1515. X                 1,
  1516. X                 XYBitmap,
  1517. X                 0,
  1518. X                 vexplode1_bits,
  1519. X                 vexplode1_width, vexplode1_height,
  1520. X                 8, 0);
  1521. X
  1522. X    Explode_image->bitmap_bit_order = LSBFirst;
  1523. X    Explode_image->byte_order = LSBFirst;
  1524. X  }
  1525. X  else {
  1526. X    Vader_Image[0][0] = XCreateImage(dpy,
  1527. X                     DefaultVisual(dpy, DefaultScreen(dpy)),
  1528. X                     1,
  1529. X                     XYBitmap,
  1530. X                     0,
  1531. X                     vader1a2_bits,
  1532. X                     vader1a2_width, vader1a2_height,
  1533. X                     8, 0);
  1534. X    Vader_Image[0][0]->bitmap_bit_order = LSBFirst;
  1535. X    Vader_Image[0][0]->byte_order = LSBFirst;
  1536. X
  1537. X    Vader_Image[0][1] = XCreateImage(dpy,
  1538. X                     DefaultVisual(dpy, DefaultScreen(dpy)),
  1539. X                     1,
  1540. X                     XYBitmap,
  1541. X                     0,
  1542. X                     vader1b2_bits,
  1543. X                     vader1b2_width, vader1b2_height,
  1544. X                     8, 0);
  1545. X    Vader_Image[0][1]->bitmap_bit_order = LSBFirst;
  1546. X    Vader_Image[0][1]->byte_order = LSBFirst;
  1547. X
  1548. X    Vader_Image[1][0] = XCreateImage(dpy,
  1549. X                     DefaultVisual(dpy, DefaultScreen(dpy)),
  1550. X                     1,
  1551. X                     XYBitmap,
  1552. X                     0,
  1553. X                     vader2a2_bits,
  1554. X                     vader2a2_width, vader2a2_height,
  1555. X                     8, 0);
  1556. X    Vader_Image[1][0]->bitmap_bit_order = LSBFirst;
  1557. X    Vader_Image[1][0]->byte_order = LSBFirst;
  1558. X
  1559. X    Vader_Image[1][1] = XCreateImage(dpy,
  1560. X                     DefaultVisual(dpy, DefaultScreen(dpy)),
  1561. X                     1,
  1562. X                     XYBitmap,
  1563. X                     0,
  1564. X                     vader2b2_bits,
  1565. X                     vader2b2_width, vader2b2_height,
  1566. X                     8, 0);
  1567. X    Vader_Image[1][1]->bitmap_bit_order = LSBFirst;
  1568. X    Vader_Image[1][1]->byte_order = LSBFirst;
  1569. X
  1570. X    Vader_Image[2][0] = XCreateImage(dpy,
  1571. X                     DefaultVisual(dpy, DefaultScreen(dpy)),
  1572. X                     1,
  1573. X                     XYBitmap,
  1574. X                     0,
  1575. X                     vader3a2_bits,
  1576. X                     vader3a2_width, vader3a2_height,
  1577. X                     8, 0);
  1578. X    Vader_Image[2][0]->bitmap_bit_order = LSBFirst;
  1579. X    Vader_Image[2][0]->byte_order = LSBFirst;
  1580. X
  1581. X    Vader_Image[2][1] = XCreateImage(dpy,
  1582. X                     DefaultVisual(dpy, DefaultScreen(dpy)),
  1583. X                     1,
  1584. X                     XYBitmap,
  1585. X                     0,
  1586. X                     vader3b2_bits,
  1587. X                     vader3b2_width, vader3b2_height,
  1588. X                     8, 0);
  1589. X    Vader_Image[2][1]->bitmap_bit_order = LSBFirst;
  1590. X    Vader_Image[2][1]->byte_order = LSBFirst;
  1591. X
  1592. X    Explode_image = XCreateImage(dpy,
  1593. X                 DefaultVisual(dpy, DefaultScreen(dpy)),
  1594. X                 1,
  1595. X                 XYBitmap,
  1596. X                 0,
  1597. X                 vexplode2_bits,
  1598. X                 vexplode2_width, vexplode2_height,
  1599. X                 8, 0);
  1600. X
  1601. X    Explode_image->bitmap_bit_order = LSBFirst;
  1602. X    Explode_image->byte_order = LSBFirst;
  1603. X  }
  1604. X
  1605. X  return BitmapSuccess;
  1606. X}
  1607. X
  1608. X
  1609. Xvoid CreateVaders(level)
  1610. Xint level;
  1611. X{
  1612. X  int offset, i, j;
  1613. X  Vader vader;
  1614. X
  1615. X  offset = MIN(level, 8);
  1616. X  vaderwait = vaderwaitinit;
  1617. X  numvaders = NUMROWS*NUMVADERS;
  1618. X  for (j = 0; j < NUMROWS; j++)
  1619. X    for (i = 0; i < NUMVADERS; i++) {
  1620. X      vader = &vaders[j][i];
  1621. X      vader->x = 3 + VADERWIDTH*i+(VADERWIDTH-vader->width)/2;
  1622. X      vader->y = VADERHEIGHT*(offset+j);
  1623. X      vader->vx = scale;
  1624. X      vader->alive = TRUE;
  1625. X      vader->exploded = FALSE;
  1626. X    }
  1627. X}
  1628. X
  1629. Xvoid InitVaders()
  1630. X{
  1631. X  int i, j, k, width, height;
  1632. X  Vader vader;
  1633. X
  1634. X  level = 1;
  1635. X  if (ReadVaderImages() != BitmapSuccess) {
  1636. X    fprintf(stderr, "Error reading Invader images\n");
  1637. X    exit(10);
  1638. X  }
  1639. X
  1640. X  for (j = 0; j < NUMROWS; j++) {
  1641. X    switch (j) {
  1642. X    case 0:
  1643. X      k = 0; break;
  1644. X    case 1:
  1645. X    case 2:
  1646. X      k = 1; break;
  1647. X    case 3:
  1648. X    case 4:
  1649. X      k = 2; break;
  1650. X    }
  1651. X    width = Vader_Image[k][0]->width;
  1652. X    height = Vader_Image[k][0]->height;
  1653. X    for (i = 0; i < NUMVADERS; i++) {
  1654. X      vader = &vaders[j][i];
  1655. X      vader->shape_image[0] = Vader_Image[k][0];
  1656. X      vader->shape_image[1] = Vader_Image[k][1];
  1657. X      vader->gc = vadergc[k];
  1658. X      vader->width = width;
  1659. X      vader->height = height;
  1660. X      vader->value = 10*(3-k);
  1661. X    }
  1662. X  }
  1663. X  vaderwaitinit = vaderwait;
  1664. X  CreateVaders(level);
  1665. X  vadertimerid = NULL;
  1666. X}
  1667. END_OF_FILE
  1668.   if test 11501 -ne `wc -c <'vaders.c'`; then
  1669.     echo shar: \"'vaders.c'\" unpacked with wrong size!
  1670.   fi
  1671.   # end of 'vaders.c'
  1672. fi
  1673. if test -f 'widget.c' -a "${1}" != "-c" ; then 
  1674.   echo shar: Will not clobber existing file \"'widget.c'\"
  1675. else
  1676.   echo shar: Extracting \"'widget.c'\" \(10215 characters\)
  1677.   sed "s/^X//" >'widget.c' <<'END_OF_FILE'
  1678. X/* 
  1679. XCopyright notice:
  1680. X
  1681. XThis is mine.  I'm only letting you use it.  Period.  Feel free to rip off
  1682. Xany of the code you see fit, but have the courtesy to give me credit.
  1683. XOtherwise great hairy beasties will rip your eyes out and eat your flesh
  1684. Xwhen you least expect it.
  1685. X
  1686. XJonny Goldman <jonathan@think.com>
  1687. X
  1688. XWed May  8 1991
  1689. X*/
  1690. X
  1691. X/* widget.c -- handle things that make the playing field behave as a widget. */
  1692. X
  1693. X#include "vaders.h"
  1694. X#include <X11/Xaw/Form.h>
  1695. X
  1696. Xtypedef struct _BaseRec {
  1697. X  int x;            /* Location. */
  1698. X  int v;            /* velocity */
  1699. X  int width, height;        /* box of this base. */
  1700. X  XImage *shape_image;        /* an XImage for the spaceship */
  1701. X} BaseRec, *Base;
  1702. X
  1703. Xextern Base base;
  1704. X
  1705. Xvoid HandleFocus();
  1706. Xvoid HandleStruct();
  1707. Xvoid Pause();
  1708. X
  1709. Xstatic XtActionsRec actions[] = {
  1710. X    {"grab-focus",    (XtActionProc) TakeFocus},
  1711. X    {"left",        MoveLeft},
  1712. X    {"right",        MoveRight},
  1713. X    {"stop",        Stop},
  1714. X    {"fire",        Fire},
  1715. X    {"pause",        Pause},
  1716. X    {"quit",        Quit},
  1717. X};
  1718. X
  1719. Xstatic char defaultTranslation[] =
  1720. X     "<Btn1Down>:    left()\n\
  1721. X     <Btn1Up>:        stop()\n\
  1722. X     <Btn2Down>:    fire()\n\
  1723. X     <Btn3Down>:    right()\n\
  1724. X     <Btn3Up>:        stop()\n\
  1725. X     <KeyDown>z:    fire()\n\
  1726. X     <KeyDown>\\,:    left()\n\
  1727. X     <KeyUp>\\,:    stop()\n\
  1728. X     <KeyDown>.:    right()\n\
  1729. X     <KeyUp>.:        stop()\n\
  1730. X     <KeyDown>\\ :    fire()\n\
  1731. X     <KeyDown>p:    pause()\n\
  1732. X     <KeyDown>q:    quit()";
  1733. X
  1734. X
  1735. Xstatic void ClassInitialize() {}
  1736. X
  1737. X/*ARGSUSED*/
  1738. Xstatic void Initialize(request, w)
  1739. XWidget request, w;
  1740. X{
  1741. X    XtAddEventHandler(toplevel, (EventMask) FocusChangeMask, FALSE,
  1742. X              HandleFocus, (Opaque) NULL);
  1743. X    XtAddEventHandler(toplevel, (EventMask) StructureNotifyMask, FALSE,
  1744. X              HandleStruct, (Opaque) NULL);
  1745. X}
  1746. X
  1747. X
  1748. Xstatic void Realize(w, valueMask, attributes)
  1749. XWidget w;
  1750. XMask *valueMask;
  1751. XXSetWindowAttributes *attributes;
  1752. X{
  1753. X  XGCValues forevalues;
  1754. X  XGCValues backvalues;
  1755. X  XGCValues basevalues;
  1756. X  XGCValues buildingvalues;
  1757. X  XGCValues vader1values;
  1758. X  XGCValues vader2values;
  1759. X  XGCValues vader3values;
  1760. X  XGCValues shotvalues;
  1761. X  XGCValues scorevalues;
  1762. X  XGCValues spacervalues;
  1763. X
  1764. X  /*
  1765. X   * Safety check.
  1766. X   */
  1767. X
  1768. X  if (w->core.width == 0) w->core.width = 1;
  1769. X  if (w->core.height == 0) w->core.height = 1;
  1770. X
  1771. X  XtCreateWindow(w, (unsigned int) InputOutput, (Visual *) CopyFromParent,
  1772. X         *valueMask, attributes);
  1773. X
  1774. X  gamewidth = scale*VWIDTH;
  1775. X  gameheight = scale*VHEIGHT;
  1776. X  gamewindow = XtWindow(gamewidget);
  1777. X  labelwindow = XtWindow(labelwidget);
  1778. X
  1779. X  forevalues.background = WhitePixel(dpy, DefaultScreen(dpy));
  1780. X  forevalues.foreground = BlackPixel(dpy, DefaultScreen(dpy));
  1781. X  foregc = XCreateGC(dpy, XtWindow(w),
  1782. X             (XtGCMask) GCForeground | GCBackground, &forevalues);
  1783. X  XSetFunction(dpy, foregc, GXcopy);
  1784. X  backvalues.background = defaultback;
  1785. X  backvalues.foreground = defaultback;
  1786. X  backgc = XCreateGC(dpy, XtWindow(w),
  1787. X             (XtGCMask) GCForeground | GCBackground, &backvalues);
  1788. X  XSetFunction(dpy, backgc, GXcopy);
  1789. X  basevalues.background = defaultback;
  1790. X  basevalues.foreground = basepixel;
  1791. X  basegc = XCreateGC(dpy, XtWindow(w),
  1792. X             (XtGCMask) GCForeground | GCBackground, &basevalues);
  1793. X  XSetFunction(dpy, basegc, GXcopy);
  1794. X  buildingvalues.background = defaultback;
  1795. X  buildingvalues.foreground = buildingpixel;
  1796. X  buildinggc = XCreateGC(dpy, XtWindow(w),
  1797. X             (XtGCMask) GCForeground | GCBackground, &buildingvalues);
  1798. X  XSetFunction(dpy, buildinggc, GXcopy);
  1799. X  vader1values.background = defaultback;
  1800. X  vader1values.foreground = vader1pixel;
  1801. X  vadergc[0] = XCreateGC(dpy, XtWindow(w),
  1802. X             (XtGCMask) GCForeground | GCBackground, &vader1values);
  1803. X  XSetFunction(dpy, vadergc[0], GXcopy);
  1804. X  vader2values.background = defaultback;
  1805. X  vader2values.foreground = vader2pixel;
  1806. X  vadergc[1] = XCreateGC(dpy, XtWindow(w),
  1807. X             (XtGCMask) GCForeground | GCBackground, &vader2values);
  1808. X  XSetFunction(dpy, vadergc[1], GXcopy);
  1809. X  vader3values.background = defaultback;
  1810. X  vader3values.foreground = vader3pixel;
  1811. X  vadergc[2] = XCreateGC(dpy, XtWindow(w),
  1812. X             (XtGCMask) GCForeground | GCBackground, &vader3values);
  1813. X  XSetFunction(dpy, vadergc[2], GXcopy);
  1814. X  shotvalues.background = defaultback;
  1815. X  shotvalues.foreground = shotpixel;
  1816. X  shotgc = XCreateGC(dpy, XtWindow(w),
  1817. X             (XtGCMask) GCForeground | GCBackground, &shotvalues);
  1818. X  XSetFunction(dpy, shotgc, GXcopy);
  1819. X  scorevalues.background = defaultback;
  1820. X  scorevalues.foreground = scorepixel;
  1821. X  scorevalues.font = XLoadFont(dpy, vaderfont);
  1822. X  scoregc = XCreateGC(dpy, XtWindow(w),
  1823. X             (XtGCMask) GCForeground | GCBackground | GCFont, &scorevalues);
  1824. X  XSetFunction(dpy, scoregc, GXcopy);
  1825. X  shotvalues.background = defaultback;
  1826. X  shotvalues.foreground = vshotpixel;
  1827. X  vshotgc = XCreateGC(dpy, XtWindow(w),
  1828. X              (XtGCMask) GCForeground | GCBackground, &shotvalues);
  1829. X  XSetFunction(dpy, vshotgc, GXcopy);
  1830. X  spacervalues.background = defaultback;
  1831. X  spacervalues.foreground = spacerpixel;
  1832. X  spacergc = XCreateGC(dpy, XtWindow(w),
  1833. X               (XtGCMask) GCForeground | GCBackground, &spacervalues);
  1834. X  XSetFunction(dpy, spacergc, GXcopy);
  1835. X
  1836. X  InitBase();
  1837. X  InitBuildings();
  1838. X  InitVaders();
  1839. X  InitSpacers();
  1840. X  InitShot();
  1841. X  InitScore();
  1842. X}
  1843. X
  1844. Xvoid SuspendTimers()
  1845. X{
  1846. X  if (basetimerid) 
  1847. X    XtRemoveTimeOut(basetimerid);
  1848. X  basetimerid = NULL;
  1849. X  if (vadertimerid)
  1850. X    XtRemoveTimeOut(vadertimerid);
  1851. X  vadertimerid = NULL;
  1852. X  if (shottimerid)
  1853. X    XtRemoveTimeOut(shottimerid);
  1854. X  shottimerid = NULL;
  1855. X  if (vshottimerid)
  1856. X    XtRemoveTimeOut(vshottimerid);
  1857. X  vshottimerid = NULL;
  1858. X  if (spacertimerid)
  1859. X    XtRemoveTimeOut(spacertimerid);
  1860. X  spacertimerid = NULL;
  1861. X}
  1862. X
  1863. Xvoid EnableTimers()
  1864. X{
  1865. X  if (basetimerid == NULL)
  1866. X    basetimerid = XtAddTimeOut(basewait, MoveBase, (Opaque) MoveBase);
  1867. X  if (vadertimerid == NULL)
  1868. X    vadertimerid = XtAddTimeOut(vaderwait, MoveVaders,
  1869. X                   (Opaque) MoveVaders);
  1870. X  if(spacertimerid == NULL)
  1871. X    spacertimerid = XtAddTimeOut(spacerwait, MoveSpacer,
  1872. X                 (Opaque) MoveSpacer);
  1873. X  if (shottimerid == NULL)
  1874. X    shottimerid = XtAddTimeOut(shotwait, MoveShots,
  1875. X                   (Opaque) MoveShots);
  1876. X  if (vshottimerid == NULL)
  1877. X    vshottimerid = XtAddTimeOut(vshotwait, MoveVshots,
  1878. X                (Opaque) MoveVshots);
  1879. X}
  1880. X
  1881. X/*ARGSUSED*/
  1882. Xstatic void HandleExpose(w, event)
  1883. XWidget w;
  1884. XXEvent *event;
  1885. X{
  1886. X /*  if (event->xexpose.count) return; */
  1887. X  XSync(dpy, 0);
  1888. X  /* suspend events */
  1889. X  SuspendTimers();
  1890. X  /* rebuild the display */
  1891. X  XSync(dpy, 0);
  1892. X  XClearWindow(dpy, gamewindow);
  1893. X  if (!basedestroyed)
  1894. X    PaintBase(basegc);
  1895. X  if(spacer_shown)
  1896. X    PaintSpacer(spacergc);
  1897. X  PaintAllVaders();
  1898. X  PaintAllShots();
  1899. X  PaintBasesLeft();
  1900. X  DrawBuildings();
  1901. X  PaintScore();
  1902. X  XSync(dpy, 0);
  1903. X  /* enable events */
  1904. X  if(!paused) 
  1905. X    EnableTimers();
  1906. X}
  1907. X
  1908. X/*ARGSUSED*/
  1909. Xvoid Quit(w, closure, event)
  1910. XWidget w;
  1911. XOpaque closure;
  1912. XXEvent *event;
  1913. X{
  1914. X    XCloseDisplay(dpy);
  1915. X    exit(0);
  1916. X}
  1917. X
  1918. Xint paused = 1;
  1919. X
  1920. X/*ARGSUSED*/
  1921. Xstatic void HandleFocus(w, closure, event)
  1922. XWidget w;
  1923. XOpaque closure;
  1924. XXEvent *event;
  1925. X{
  1926. X}
  1927. X
  1928. X/*ARGSUSED*/
  1929. Xvoid Pause(w, closure, event)
  1930. XWidget w;
  1931. XOpaque closure;
  1932. XXEvent *event;
  1933. X{
  1934. X  static Arg args[1];
  1935. X  if (paused) {
  1936. X    paused = 0;
  1937. X    EnableTimers();
  1938. X    XtSetArg(args[0], XtNlabel, "Pause");
  1939. X    XtSetValues(pausebutton, args, 1);
  1940. X    HandleExpose(NULL, NULL, NULL);
  1941. X  } else {
  1942. X    paused = 1;
  1943. X    SuspendTimers();
  1944. X    XtSetArg(args[0], XtNlabel, "Resume");
  1945. X    XtSetValues(pausebutton, args, 1);
  1946. X  }
  1947. X}
  1948. X
  1949. X/*ARGSUSED*/
  1950. Xstatic void HandleStruct(w, closure, event)
  1951. XWidget w;
  1952. XOpaque closure;
  1953. XXEvent *event;
  1954. X{
  1955. X}
  1956. X
  1957. Xstatic void Destroy() {}
  1958. X
  1959. Xstatic void Resize() {}
  1960. X
  1961. Xstatic Boolean SetValues() 
  1962. X{
  1963. X  return FALSE;
  1964. X}
  1965. X
  1966. Xstatic Boolean TakeFocus()
  1967. X{
  1968. X    XSetInputFocus(dpy, gamewindow, RevertToPointerRoot, CurrentTime);
  1969. X    return TRUE;
  1970. X}
  1971. X
  1972. X#include "me.h"
  1973. X
  1974. Xvoid ShowInfo(w, closure, event)
  1975. XWidget w;
  1976. XOpaque closure;
  1977. XXEvent *event;
  1978. X{
  1979. X  int xloc, yloc;
  1980. X
  1981. X  paused = 0;
  1982. X  Pause(NULL, NULL, NULL);
  1983. X  /* rebuild the display */
  1984. X  XSync(dpy, 0);
  1985. X  XClearWindow(dpy, gamewindow);
  1986. X  if (me_image == NULL) {
  1987. X    me_image = XCreateImage(dpy,
  1988. X                DefaultVisual(dpy, DefaultScreen(dpy)),
  1989. X                1,
  1990. X                XYBitmap,
  1991. X                0,
  1992. X                (scale == 1) ? me1_bits:me2_bits,
  1993. X                (scale == 1) ? me1_width : me2_width,
  1994. X                (scale == 1) ? me1_height: me2_height,
  1995. X                8, 0);
  1996. X    me_image->bitmap_bit_order = LSBFirst;
  1997. X    me_image->byte_order = LSBFirst;
  1998. X  }
  1999. X  
  2000. X  xloc = (gamewidth-((scale == 1) ? me1_width : me2_width))/2;
  2001. X  yloc = ((scale == 1) ? me1_width : me2_width) + 10;
  2002. X
  2003. X  XPutImage(dpy, gamewindow, foregc, me_image,
  2004. X        0, 0, 
  2005. X        xloc, 0,
  2006. X        (scale == 1) ? me1_width : me2_width,
  2007. X        (scale == 1) ? me1_height: me2_height);
  2008. X
  2009. X  if (scale == 2)
  2010. X    XDrawImageString(dpy, gamewindow, scoregc, xloc, yloc, "Xinvaders, by Jonny Goldman", 27);
  2011. X  else {
  2012. X    XDrawImageString(dpy, gamewindow, scoregc, xloc+30, yloc, "Xinvaders", 9);
  2013. X    XDrawImageString(dpy, gamewindow, scoregc, xloc, yloc+15, "by Jonny Goldman", 16);
  2014. X  }
  2015. X
  2016. X  XSync(dpy, 0);
  2017. X}
  2018. X
  2019. X
  2020. XVadersClassRec vadersClassRec = {
  2021. X  {
  2022. X/* core_class fields      */
  2023. X    /* superclass         */    (WidgetClass) &widgetClassRec,
  2024. X    /* class_name         */    "Xinvaders",
  2025. X    /* widget_size        */    sizeof(VadersRec),
  2026. X    /* class_initialize   */    ClassInitialize,
  2027. X    /* class_part_initiali*/    NULL,
  2028. X    /* class_inited       */    FALSE,
  2029. X    /* initialize         */    Initialize,
  2030. X    /* initialize_hook      */    NULL,
  2031. X    /* realize            */    Realize,
  2032. X    /* actions            */    actions,
  2033. X    /* num_actions        */    XtNumber(actions),
  2034. X    /* resources          */    NULL,
  2035. X    /* num_resources      */    (Cardinal) 0,
  2036. X    /* xrm_class          */    NULLQUARK,
  2037. X    /* compress_motion    */    TRUE,
  2038. X    /* compress_exposure  */    TRUE,
  2039. X    /* compress_enterleave*/    TRUE,
  2040. X    /* visible_interest   */    FALSE,
  2041. X    /* destroy            */    Destroy,
  2042. X    /* resize             */    Resize,
  2043. X    /* expose             */    HandleExpose,
  2044. X    /* set_values         */    SetValues,
  2045. X    /* set_values_hook      */    NULL,
  2046. X    /* set_values_almost  */    NULL,
  2047. X    /* get_values_hook      */    NULL,
  2048. X    /* accept_focus       */    TakeFocus,
  2049. X    /* version          */    XtVersion,
  2050. X    /* callback_private      */    NULL,
  2051. X    /* tm_table          */    defaultTranslation,
  2052. X    /* query_geometry      */    NULL,
  2053. X    /* display_accelerator*/    NULL,
  2054. X    /* extension`      */    NULL,
  2055. X  },{
  2056. X    /* mumble             */    0       /* Make C compiler happy   */
  2057. X  }
  2058. X};
  2059. X
  2060. XWidgetClass vadersWidgetClass = (WidgetClass)&vadersClassRec;
  2061. END_OF_FILE
  2062.   if test 10215 -ne `wc -c <'widget.c'`; then
  2063.     echo shar: \"'widget.c'\" unpacked with wrong size!
  2064.   fi
  2065.   # end of 'widget.c'
  2066. fi
  2067. echo shar: End of archive 2 \(of 3\).
  2068. cp /dev/null ark2isdone
  2069. MISSING=""
  2070. for I in 1 2 3 ; do
  2071.     if test ! -f ark${I}isdone ; then
  2072.     MISSING="${MISSING} ${I}"
  2073.     fi
  2074. done
  2075. if test "${MISSING}" = "" ; then
  2076.     echo You have unpacked all 3 archives.
  2077.     rm -f ark[1-9]isdone
  2078. else
  2079.     echo You still must unpack the following archives:
  2080.     echo "        " ${MISSING}
  2081. fi
  2082. exit 0
  2083. exit 0 # Just in case...
  2084. -- 
  2085.   // chris@IMD.Sterling.COM            | Send comp.sources.x submissions to:
  2086. \X/  Amiga - The only way to fly!      |
  2087.  "It's intuitively obvious to the most |    sources-x@imd.sterling.com
  2088.   casual observer..."                  |
  2089.