Google Groups no longer supports new Usenet posts or subscriptions. Historical content remains viewable.

Dismiss

v09i027: xmines, Part01/03

23 views

Skip to first unread message

Jim McBeath

unread,

Sep 12, 1990, 4:25:55 AM9/12/90

Submitted-by: uunet!globes!ji...@uunet.UU.NET (Jim McBeath)
Posting-number: Volume 9, Issue 27
Archive-name: xmines/part01

Xmines is an X11 game, built using the Xt toolkit intrinsics and Athena
widgets, in which the player attempts to cross a minefield without getting
blown up.

The mines game was originally written as a suntools game (called minestool)
by Tom Anderson of Fluke. Brian Dalio of Silicon Compilers made some
enhancements, and Jim McBeath of Silicon Compilers (at Globetrotter
Software as of April 1990) converted it to X11 and made other enhancements.

The History file contains more details, and the signatures of the authors.

#! /bin/sh
## This is a shell archive. Remove anything before this line, then unpack
## it by saving it into a file and typing "sh file". To overwrite existing
## files, type "sh file -c". You can also feed this as standard input via
## unshar, or by typing "sh <file". If this archive is complete, you will
## see the following message at the end:
# "End of archive 1 (of 3)."
# Contents: README History Imakefile Makefile xmines.man XMines.ad
# Wrapped by jimmc@ss on Mon Sep 10 09:43:09 1990
PATH=/bin:/usr/bin:/usr/ucb ; export PATH
if test -f README -a "${1}" != "-c" ; then
echo shar: Will not over-write existing file \"README\"
else
echo shar: Extracting \"README\" $767 characters$
sed "s/^X//" >README <<'END_OF_README'
XXmines is an X11 game, built using the Xt toolkit intrinsics and Athena
Xwidgets, in which the player attempts to cross a minefield without getting
Xblown up.
X
XThe mines game was originally written as a suntools game (called minestool)
Xby Tom Anderson of Fluke. Brian Dalio of Silicon Compilers made some
Xenhancements, and Jim McBeath of Silicon Compilers (at Globetrotter
XSoftware as of April 1990) converted it to X11 and made other enhancements.
X
XThe History file contains more details, and the signatures of the authors.
X
XThe man page describes how to play the game and how to customize it
Xusing resources.
X
XXmines is copyrighted with an X11-style copyright that allows for free
Xredistribution (see any of the C files for exact wording).
X
X-Jim McBeath 10.Sep.1990
END_OF_README
if test 767 -ne `wc -c <README`; then
echo shar: \"README\" unpacked with wrong size!
fi
# end of overwriting check
fi
if test -f History -a "${1}" != "-c" ; then
echo shar: Will not over-write existing file \"History\"
else
echo shar: Extracting \"History\" $1971 characters$
sed "s/^X//" >History <<'END_OF_History'
XXMines History 22-Aug-90
X
XThe Mines game was originally written by Tom Anderson of Fluke Manufacturing.
XIt was written for suntools, and was based on his chess tool (as Tom said
Xin the notes for that version, "you might recognize the lineage"; although,
Xgiven the change to X11, this is probably more difficult now).
X
XIt was modified by Brian Dalio of Silicon Compiler Systems,
Xwho added the following features (still a sunview program)
Xin November/December 1987:
X
X - Previously occupied cells display the number of mines nearby.
X
X - At the end of the game (either after a blowup or success) when
X the complete board is displayed, the user's annotations are
X preserved. If a cell was marked safe but is really mined or if
X it was marked mined but is really safe, an X is put on top of
X what the user had placed.
X
X - If a square has been traversed, it can be moved to even if it
X isn't adjacent.
X
X - If a square is marked `ok' and is next to a traversed square it
X can be moved to. Typing `H\n' (for Hint) in the level subwindow
X marks a square next to current position `ok' if possible.
X
XJim McBeath of Silicon Compilers (now at Globetrotter Software)
Xadded the following features in February 1988:
X
X - Allow moves to any square which is adjacent to a traversed square.
X
X - If the user presses the right mouse button on the square he is on,
X give a hint.
X
XIt was converted to X11 (and the name changed from minestool to xmines)
Xby Jim McBeath in January 1990. Various cleanup, writing of man pages, etc.,
Xhappened (at low priority) over the next few months until it was posted.
X
X
XAuthors:
X
XTom Anderson, (206) 356-5895
XJohn Fluke Mfg. Co., Inc., P.O. Box C9090 M/S 245F, Everett, Wa. 98206
X{ hplsla, microsoft, uw-beaver, sun, tikal }!fluke!toma
X
XBrian Dalio
XMentor Graphics Silicon Design Division (formerly Silicon Compilers)
X(201)580-0102
Xb...@sdl.scs.com
X
XJim McBeath
XGlobetrotter Software, Inc.
X(408)741-0489
Xglobes!ji...@oliveb.olivetti.com
END_OF_History
if test 1971 -ne `wc -c <History`; then
echo shar: \"History\" unpacked with wrong size!
fi
# end of overwriting check
fi
if test -f Imakefile -a "${1}" != "-c" ; then
echo shar: Will not over-write existing file \"Imakefile\"
else
echo shar: Extracting \"Imakefile\" $338 characters$
sed "s/^X//" >Imakefile <<'END_OF_Imakefile'
X DEPLIBS = $(DEPXAWLIB) $(DEPXMULIB) $(DEPXTOOLLIB) $(DEPXLIB)
XLOCAL_LIBRARIES = $(XAWLIB) $(XMULIB) $(XTOOLLIB) $(XLIB)
X SRCS = actions.c board.c buttons.c draw.c \
X info.c main.c makeform.c msg.c
X OBJS = actions.o board.o buttons.o draw.o \
X info.o main.o makeform.o msg.o
X
XComplexProgramTarget(xmines)
END_OF_Imakefile
if test 338 -ne `wc -c <Imakefile`; then
echo shar: \"Imakefile\" unpacked with wrong size!
fi
# end of overwriting check
fi
if test -f Makefile -a "${1}" != "-c" ; then
echo shar: Will not over-write existing file \"Makefile\"
else
echo shar: Extracting \"Makefile\" $15839 characters$
sed "s/^X//" >Makefile <<'END_OF_Makefile'
X# Makefile generated by imake - do not edit!
X# $XConsortium: imake.c,v 1.51 89/12/12 12:37:30 jim Exp $
X#
X# The cpp used on this machine replaces all newlines and multiple tabs and
X# spaces in a macro expansion with a single space. Imake tries to compensate
X# for this, but is not always successful.
X#
X
X###########################################################################
X# Makefile generated from "Imake.tmpl" and <Imakefile>
X# $XConsortium: Imake.tmpl,v 1.77 89/12/18 17:01:37 jim Exp $
X#
X# Platform-specific parameters may be set in the appropriate .cf
X# configuration files. Site-wide parameters may be set in the file
X# site.def. Full rebuilds are recommended if any parameters are changed.
X#
X# If your C preprocessor doesn't define any unique symbols, you'll need
X# to set BOOTSTRAPCFLAGS when rebuilding imake (usually when doing
X# "make Makefile", "make Makefiles", or "make World").
X#
X# If you absolutely can't get imake to work, you'll need to set the
X# variables at the top of each Makefile as well as the dependencies at the
X# bottom (makedepend will do this automatically).
X#
X
X###########################################################################
X# platform-specific configuration parameters - edit sun.cf to change
X
X# platform: $XConsortium: sun.cf,v 1.38 89/12/23 16:10:10 jim Exp $
X# operating system: SunOS 4.0.3
X
X###########################################################################
X# site-specific configuration parameters - edit site.def to change
X
X# site: $XConsortium: site.def,v 1.21 89/12/06 11:46:50 jim Exp $
X
X SHELL = /bin/sh
X
X TOP = /u2/X11R4/mit
X CURRENT_DIR = ./clients/xmines
X
X AR = ar cq
X BOOTSTRAPCFLAGS =
X CC = cc
X
X COMPRESS = compress
X CPP = /lib/cpp $(STD_CPP_DEFINES)
X PREPROCESSCMD = cc -E $(STD_CPP_DEFINES)
X INSTALL = install
X LD = ld
X LINT = lint
X LINTLIBFLAG = -C
X LINTOPTS = -axz
X LN = ln -s
X MAKE = make
X MV = mv
X CP = cp
X RANLIB = ranlib
X RANLIBINSTFLAGS =
X RM = rm -f
X STD_INCLUDES =
X STD_CPP_DEFINES =
X STD_DEFINES =
X EXTRA_LOAD_FLAGS =
X EXTRA_LIBRARIES =
X TAGS = ctags
X
X SHAREDCODEDEF = -DSHAREDCODE
X SHLIBDEF = -DSUNSHLIB
X
X PROTO_DEFINES =
X
X INSTPGMFLAGS =
X
X INSTBINFLAGS = -m 0755
X INSTUIDFLAGS = -m 4755
X INSTLIBFLAGS = -m 0664
X INSTINCFLAGS = -m 0444
X INSTMANFLAGS = -m 0444
X INSTDATFLAGS = -m 0444
X INSTKMEMFLAGS = -m 4755
X
X DESTDIR =
X
X TOP_INCLUDES = -I$(TOP)
X
X CDEBUGFLAGS = -O
X CCOPTIONS =
X COMPATFLAGS =
X
X ALLINCLUDES = $(STD_INCLUDES) $(TOP_INCLUDES) $(INCLUDES) $(EXTRA_INCLUDES)
X ALLDEFINES = $(ALLINCLUDES) $(STD_DEFINES) $(PROTO_DEFINES) $(DEFINES) $(COMPATFLAGS)
X CFLAGS = $(CDEBUGFLAGS) $(CCOPTIONS) $(ALLDEFINES)
X LINTFLAGS = $(LINTOPTS) -DLINT $(ALLDEFINES)
X LDLIBS = $(SYS_LIBRARIES) $(EXTRA_LIBRARIES)
X LDOPTIONS = $(CDEBUGFLAGS) $(CCOPTIONS)
X LDCOMBINEFLAGS = -X -r
X
X MACROFILE = sun.cf
X RM_CMD = $(RM) *.CKP *.ln *.BAK *.bak *.o core errs ,* *~ *.a .emacs_* tags TAGS make.log MakeOut
X
X IMAKE_DEFINES =
X
X IRULESRC = $(CONFIGSRC)
X IMAKE_CMD = $(NEWTOP)$(IMAKE) -I$(NEWTOP)$(IRULESRC) $(IMAKE_DEFINES)
X
X ICONFIGFILES = $(IRULESRC)/Imake.tmpl $(IRULESRC)/Imake.rules \
X $(IRULESRC)/Project.tmpl $(IRULESRC)/site.def \
X $(IRULESRC)/$(MACROFILE) $(EXTRA_ICONFIGFILES)
X
X###########################################################################
X# X Window System Build Parameters
X# $XConsortium: Project.tmpl,v 1.63 89/12/18 16:46:44 jim Exp $
X
X###########################################################################
X# X Window System make variables; this need to be coordinated with rules
X# $XConsortium: Project.tmpl,v 1.63 89/12/18 16:46:44 jim Exp $
X
X PATHSEP = /
X USRLIBDIR = $(DESTDIR)/usr/lib
X BINDIR = $(DESTDIR)/usr/bin/X11
X INCROOT = $(DESTDIR)/usr/include
X BUILDINCROOT = $(TOP)
X BUILDINCDIR = $(BUILDINCROOT)/X11
X BUILDINCTOP = ..
X INCDIR = $(INCROOT)/X11
X ADMDIR = $(DESTDIR)/usr/adm
X LIBDIR = $(USRLIBDIR)/X11
X CONFIGDIR = $(LIBDIR)/config
X LINTLIBDIR = $(USRLIBDIR)/lint
X
X FONTDIR = $(LIBDIR)/fonts
X XINITDIR = $(LIBDIR)/xinit
X XDMDIR = $(LIBDIR)/xdm
X AWMDIR = $(LIBDIR)/awm
X TWMDIR = $(LIBDIR)/twm
X GWMDIR = $(LIBDIR)/gwm
X MANPATH = $(DESTDIR)/usr/man
X MANSOURCEPATH = $(MANPATH)/man
X MANDIR = $(MANSOURCEPATH)n
X LIBMANDIR = $(MANSOURCEPATH)3
X XAPPLOADDIR = $(LIBDIR)/app-defaults
X
X SOXLIBREV = 4.2
X SOXTREV = 4.0
X SOXAWREV = 4.0
X SOOLDXREV = 4.0
X SOXMUREV = 4.0
X SOXEXTREV = 4.0
X
X FONTCFLAGS = -t
X
X INSTAPPFLAGS = $(INSTDATFLAGS)
X
X IMAKE = $(IMAKESRC)/imake
X# DEPEND = $(DEPENDSRC)/makedepend
X DEPEND = makedepend
X RGB = $(RGBSRC)/rgb
X FONTC = $(BDFTOSNFSRC)/bdftosnf
X MKFONTDIR = $(MKFONTDIRSRC)/mkfontdir
X MKDIRHIER = /bin/sh $(SCRIPTSRC)/mkdirhier.sh
X
X CONFIGSRC = $(TOP)/config
X CLIENTSRC = $(TOP)/clients
X DEMOSRC = $(TOP)/demos
X LIBSRC = $(TOP)/lib
X FONTSRC = $(TOP)/fonts
X INCLUDESRC = $(TOP)/X11
X SERVERSRC = $(TOP)/server
X UTILSRC = $(TOP)/util
X SCRIPTSRC = $(UTILSRC)/scripts
X EXAMPLESRC = $(TOP)/examples
X CONTRIBSRC = $(TOP)/../contrib
X DOCSRC = $(TOP)/doc
X RGBSRC = $(TOP)/rgb
X DEPENDSRC = $(UTILSRC)/makedepend
X IMAKESRC = $(CONFIGSRC)
X XAUTHSRC = $(LIBSRC)/Xau
X XLIBSRC = $(LIBSRC)/X
X XMUSRC = $(LIBSRC)/Xmu
X TOOLKITSRC = $(LIBSRC)/Xt
X AWIDGETSRC = $(LIBSRC)/Xaw
X OLDXLIBSRC = $(LIBSRC)/oldX
X XDMCPLIBSRC = $(LIBSRC)/Xdmcp
X BDFTOSNFSRC = $(FONTSRC)/bdftosnf
X MKFONTDIRSRC = $(FONTSRC)/mkfontdir
X EXTENSIONSRC = $(TOP)/extensions
X
X# DEPEXTENSIONLIB = $(EXTENSIONSRC)/lib/libXext.a
X EXTENSIONLIB = $(DEPEXTENSIONLIB)
X
X DEPXLIB = $(DEPEXTENSIONLIB)
X XLIB = $(EXTENSIONLIB) -L$(XLIBSRC) -lX11
X
X DEPXAUTHLIB = $(XAUTHSRC)/libXau.a
X XAUTHLIB = $(DEPXAUTHLIB)
X
X DEPXMULIB =
X XMULIB = -L$(XMUSRC) -lXmu
X
X DEPOLDXLIB =
X OLDXLIB = -L$(OLDXLIBSRC) -loldX
X
X DEPXTOOLLIB =
X XTOOLLIB = -L$(TOOLKITSRC) -lXt
X
X DEPXAWLIB =
X XAWLIB = -L$(AWIDGETSRC) -lXaw
X
X LINTEXTENSIONLIB = $(EXTENSIONSRC)/lib/llib-lXext.ln
X LINTXLIB = $(XLIBSRC)/llib-lX11.ln
X LINTXMU = $(XMUSRC)/llib-lXmu.ln
X LINTXTOOL = $(TOOLKITSRC)/llib-lXt.ln
X LINTXAW = $(AWIDGETSRC)/llib-lXaw.ln
X
X DEPLIBS = $(DEPXAWLIB) $(DEPXMULIB) $(DEPXTOOLLIB) $(DEPXLIB)
X
X DEPLIBS1 = $(DEPLIBS)
X DEPLIBS2 = $(DEPLIBS)
X DEPLIBS3 = $(DEPLIBS)
X
X###########################################################################
X# Imake rules for building libraries, programs, scripts, and data files
X# rules: $XConsortium: Imake.rules,v 1.67 89/12/18 17:14:15 jim Exp $
X
X###########################################################################
X# start of Imakefile
X
X DEPLIBS = $(DEPXAWLIB) $(DEPXMULIB) $(DEPXTOOLLIB) $(DEPXLIB)
XLOCAL_LIBRARIES = $(XAWLIB) $(XMULIB) $(XTOOLLIB) $(XLIB)
X SRCS = actions.c board.c buttons.c draw.c \
X info.c main.c makeform.c msg.c
X OBJS = actions.o board.o buttons.o draw.o \
X info.o main.o makeform.o msg.o
X
X PROGRAM = xmines
X
Xall:: xmines
X
Xxmines: $(OBJS) $(DEPLIBS)
X $(RM) $@
X $(CC) -o $@ $(OBJS) $(LDOPTIONS) $(LOCAL_LIBRARIES) $(LDLIBS) $(EXTRA_LOAD_FLAGS)
X
Xinstall:: xmines
X $(INSTALL) -c $(INSTPGMFLAGS) xmines $(BINDIR)
X
Xinstall.man:: xmines.man
X $(INSTALL) -c $(INSTMANFLAGS) xmines.man $(MANDIR)/xmines.n
X
X#depend:: $(DEPEND)
X
X$(DEPEND):
X @echo "checking $@ over in $(DEPENDSRC) first..."; \
X cd $(DEPENDSRC); $(MAKE); \
X echo "okay, continuing in $(CURRENT_DIR)"
X
Xdepend::
X $(DEPEND) -s "# DO NOT DELETE" -- $(ALLDEFINES) -- $(SRCS)
X
Xlint:
X $(LINT) $(LINTFLAGS) $(SRCS) $(LINTLIBS)
Xlint1:
X $(LINT) $(LINTFLAGS) $(FILE) $(LINTLIBS)
X
Xclean::
X $(RM) $(PROGRAM)
X
X###########################################################################
X# common rules for all Makefiles - do not edit
X
Xemptyrule::
X
Xclean::
X $(RM_CMD) \#*
X
XMakefile:: $(IMAKE)
X
X$(IMAKE):
X @(cd $(IMAKESRC); if [ -f Makefile ]; then \
X echo "checking $@ in $(IMAKESRC) first..."; $(MAKE) all; else \
X echo "bootstrapping $@ from Makefile.ini in $(IMAKESRC) first..."; \
X $(MAKE) -f Makefile.ini BOOTSTRAPCFLAGS=$(BOOTSTRAPCFLAGS); fi; \
X echo "okay, continuing in $(CURRENT_DIR)")
X
XMakefile::
X -@if [ -f Makefile ]; then \
X echo " $(RM) Makefile.bak; $(MV) Makefile Makefile.bak"; \
X $(RM) Makefile.bak; $(MV) Makefile Makefile.bak; \
X else exit 0; fi
X $(IMAKE_CMD) -DTOPDIR=$(TOP) -DCURDIR=$(CURRENT_DIR)
X
Xtags::
X $(TAGS) -w *.[ch]
X $(TAGS) -xw *.[ch] > TAGS
X
X###########################################################################
X# empty rules for directories that do not have SUBDIRS - do not edit
X
Xinstall::
X @echo "install in $(CURRENT_DIR) done"
X
Xinstall.man::
X @echo "install.man in $(CURRENT_DIR) done"
X
XMakefiles::
X
Xincludes::
X
X###########################################################################
X# dependencies generated by makedepend
X
X# DO NOT DELETE
X
Xactions.o: /usr/include/X11/Intrinsic.h /usr/include/X11/Xlib.h
Xactions.o: /usr/include/sys/types.h /usr/include/sys/sysmacros.h
Xactions.o: /usr/include/X11/X.h /usr/include/X11/Xutil.h
Xactions.o: /usr/include/X11/Xresource.h /usr/include/X11/Xos.h
Xactions.o: /usr/include/strings.h /usr/include/sys/file.h
Xactions.o: /usr/include/sys/fcntlcom.h /usr/include/sys/time.h
Xactions.o: /usr/include/sys/time.h /usr/include/X11/Core.h
Xactions.o: /usr/include/X11/Composite.h /usr/include/X11/Constraint.h
Xactions.o: /usr/include/X11/Object.h /usr/include/X11/RectObj.h mines.h
Xboard.o: /usr/include/stdio.h /usr/include/strings.h /usr/include/sys/types.h
Xboard.o: /usr/include/sys/sysmacros.h /usr/include/X11/Intrinsic.h
Xboard.o: /usr/include/X11/Xlib.h /usr/include/X11/X.h
Xboard.o: /usr/include/X11/Xutil.h /usr/include/X11/Xresource.h
Xboard.o: /usr/include/X11/Xos.h /usr/include/sys/file.h
Xboard.o: /usr/include/sys/fcntlcom.h /usr/include/sys/time.h
Xboard.o: /usr/include/sys/time.h /usr/include/X11/Core.h
Xboard.o: /usr/include/X11/Composite.h /usr/include/X11/Constraint.h
Xboard.o: /usr/include/X11/Object.h /usr/include/X11/RectObj.h mines.h
Xbuttons.o: /usr/include/X11/Intrinsic.h /usr/include/X11/Xlib.h
Xbuttons.o: /usr/include/sys/types.h /usr/include/sys/sysmacros.h
Xbuttons.o: /usr/include/X11/X.h /usr/include/X11/Xutil.h
Xbuttons.o: /usr/include/X11/Xresource.h /usr/include/X11/Xos.h
Xbuttons.o: /usr/include/strings.h /usr/include/sys/file.h
Xbuttons.o: /usr/include/sys/fcntlcom.h /usr/include/sys/time.h
Xbuttons.o: /usr/include/sys/time.h /usr/include/X11/Core.h
Xbuttons.o: /usr/include/X11/Composite.h /usr/include/X11/Constraint.h
Xbuttons.o: /usr/include/X11/Object.h /usr/include/X11/RectObj.h
Xbuttons.o: /usr/include/X11/StringDefs.h /usr/include/X11/Xaw/Form.h
Xbuttons.o: /usr/include/X11/Xaw/Command.h /usr/include/X11/Xaw/Label.h
Xbuttons.o: /usr/include/X11/Xaw/Simple.h /usr/include/X11/Xmu/Converters.h
Xbuttons.o: /usr/include/X11/Xaw/AsciiText.h /usr/include/X11/Xaw/Text.h
Xbuttons.o: /usr/include/X11/Xaw/TextSink.h /usr/include/X11/Xaw/TextSrc.h
Xbuttons.o: /usr/include/X11/Xaw/AsciiSrc.h /usr/include/X11/Xaw/AsciiSink.h
Xbuttons.o: mines.h
Xdraw.o: /usr/include/X11/Intrinsic.h /usr/include/X11/Xlib.h
Xdraw.o: /usr/include/sys/types.h /usr/include/sys/sysmacros.h
Xdraw.o: /usr/include/X11/X.h /usr/include/X11/Xutil.h
Xdraw.o: /usr/include/X11/Xresource.h /usr/include/X11/Xos.h
Xdraw.o: /usr/include/strings.h /usr/include/sys/file.h
Xdraw.o: /usr/include/sys/fcntlcom.h /usr/include/sys/time.h
Xdraw.o: /usr/include/sys/time.h /usr/include/X11/Core.h
Xdraw.o: /usr/include/X11/Composite.h /usr/include/X11/Constraint.h
Xdraw.o: /usr/include/X11/Object.h /usr/include/X11/RectObj.h
Xdraw.o: /usr/include/X11/StringDefs.h mines.h bMine.xbm bMineSm.xbm bSafe.xbm
Xdraw.o: bSafeSm.xbm hMine.xbm hMineSm.xbm mine.xbm mineSm.xbm safe.xbm
Xdraw.o: safeSm.xbm e0.xbm e0Sm.xbm e1.xbm e1Sm.xbm e2.xbm e2Sm.xbm e3.xbm
Xdraw.o: e3Sm.xbm e4.xbm e4Sm.xbm e5.xbm e5Sm.xbm e6.xbm e6Sm.xbm e7.xbm
Xdraw.o: e7Sm.xbm e8.xbm e8Sm.xbm pl0.xbm pl0Sm.xbm pl1.xbm pl1Sm.xbm pl2.xbm
Xdraw.o: pl2Sm.xbm pl3.xbm pl3Sm.xbm pl4.xbm pl4Sm.xbm pl5.xbm pl5Sm.xbm
Xdraw.o: pl6.xbm pl6Sm.xbm pl7.xbm pl7Sm.xbm pl8.xbm pl8Sm.xbm
Xinfo.o: /usr/include/X11/Intrinsic.h /usr/include/X11/Xlib.h
Xinfo.o: /usr/include/sys/types.h /usr/include/sys/sysmacros.h
Xinfo.o: /usr/include/X11/X.h /usr/include/X11/Xutil.h
Xinfo.o: /usr/include/X11/Xresource.h /usr/include/X11/Xos.h
Xinfo.o: /usr/include/strings.h /usr/include/sys/file.h
Xinfo.o: /usr/include/sys/fcntlcom.h /usr/include/sys/time.h
Xinfo.o: /usr/include/sys/time.h /usr/include/X11/Core.h
Xinfo.o: /usr/include/X11/Composite.h /usr/include/X11/Constraint.h
Xinfo.o: /usr/include/X11/Object.h /usr/include/X11/RectObj.h
Xinfo.o: /usr/include/X11/StringDefs.h /usr/include/X11/Shell.h
Xinfo.o: /usr/include/X11/Xaw/Form.h /usr/include/X11/Xaw/Command.h
Xinfo.o: /usr/include/X11/Xaw/Label.h /usr/include/X11/Xaw/Simple.h
Xinfo.o: /usr/include/X11/Xmu/Converters.h mines.h
Xmain.o: /usr/include/X11/Intrinsic.h /usr/include/X11/Xlib.h
Xmain.o: /usr/include/sys/types.h /usr/include/sys/sysmacros.h
Xmain.o: /usr/include/X11/X.h /usr/include/X11/Xutil.h
Xmain.o: /usr/include/X11/Xresource.h /usr/include/X11/Xos.h
Xmain.o: /usr/include/strings.h /usr/include/sys/file.h
Xmain.o: /usr/include/sys/fcntlcom.h /usr/include/sys/time.h
Xmain.o: /usr/include/sys/time.h /usr/include/X11/Core.h
Xmain.o: /usr/include/X11/Composite.h /usr/include/X11/Constraint.h
Xmain.o: /usr/include/X11/Object.h /usr/include/X11/RectObj.h
Xmain.o: /usr/include/X11/Xatom.h /usr/include/X11/StringDefs.h
Xmain.o: /usr/include/X11/Shell.h /usr/include/stdio.h /usr/include/ctype.h
Xmain.o: mines.h patchlevel.h
Xmakeform.o: /usr/include/X11/Intrinsic.h /usr/include/X11/Xlib.h
Xmakeform.o: /usr/include/sys/types.h /usr/include/sys/sysmacros.h
Xmakeform.o: /usr/include/X11/X.h /usr/include/X11/Xutil.h
Xmakeform.o: /usr/include/X11/Xresource.h /usr/include/X11/Xos.h
Xmakeform.o: /usr/include/strings.h /usr/include/sys/file.h
Xmakeform.o: /usr/include/sys/fcntlcom.h /usr/include/sys/time.h
Xmakeform.o: /usr/include/sys/time.h /usr/include/X11/Core.h
Xmakeform.o: /usr/include/X11/Composite.h /usr/include/X11/Constraint.h
Xmakeform.o: /usr/include/X11/Object.h /usr/include/X11/RectObj.h
Xmakeform.o: /usr/include/X11/Xatom.h /usr/include/X11/StringDefs.h
Xmakeform.o: /usr/include/X11/Shell.h /usr/include/X11/Xaw/Form.h
Xmakeform.o: /usr/include/X11/Xaw/Label.h /usr/include/X11/Xaw/Simple.h
Xmakeform.o: /usr/include/X11/Xmu/Converters.h /usr/include/X11/Xaw/Command.h
Xmakeform.o: /usr/include/stdio.h /usr/include/ctype.h mines.h
Xmsg.o: /usr/include/X11/Intrinsic.h /usr/include/X11/Xlib.h
Xmsg.o: /usr/include/sys/types.h /usr/include/sys/sysmacros.h
Xmsg.o: /usr/include/X11/X.h /usr/include/X11/Xutil.h
Xmsg.o: /usr/include/X11/Xresource.h /usr/include/X11/Xos.h
Xmsg.o: /usr/include/strings.h /usr/include/sys/file.h
Xmsg.o: /usr/include/sys/fcntlcom.h /usr/include/sys/time.h
Xmsg.o: /usr/include/sys/time.h /usr/include/X11/Core.h
Xmsg.o: /usr/include/X11/Composite.h /usr/include/X11/Constraint.h
Xmsg.o: /usr/include/X11/Object.h /usr/include/X11/RectObj.h
Xmsg.o: /usr/include/X11/StringDefs.h /usr/include/X11/Xaw/Form.h
Xmsg.o: /usr/include/X11/Xaw/Label.h /usr/include/X11/Xaw/Simple.h
Xmsg.o: /usr/include/X11/Xmu/Converters.h mines.h
END_OF_Makefile
if test 15839 -ne `wc -c <Makefile`; then
echo shar: \"Makefile\" unpacked with wrong size!
fi
# end of overwriting check
fi
if test -f xmines.man -a "${1}" != "-c" ; then
echo shar: Will not over-write existing file \"xmines.man\"
else
echo shar: Extracting \"xmines.man\" $10045 characters$
sed "s/^X//" >xmines.man <<'END_OF_xmines.man'
X.TH XMINES 1 "22 August 1990" "X Version 11 Release 4"
X.SH NAME
Xxmines - a minefield game
X.SH SYNOPSIS
X\fBxmines\fP [ \fI-toolkitoption\fP ...]
X[-cellsize \fIcellsize\fP]
X[-rows \fIrows\fP]
X[-columns \fIcolumns\fP]
X[-mines \fImines\fP]
X.SH DESCRIPTION
XThe \fIxmines\fP program is a game in which you attempt to cross
Xa minefield without getting blown up.
XYou can control the size of the minefield and the density of the mines.
XAt each step, you are told how many mines are in the neighboring locations,
Xfrom which you can often deduce the locations of the mines.
XIf you are stuck, you have the option of asking for a hint if you don't
Xfeel like taking a chance on moving to a location which might contain a mine.
XXmines keeps track of how many moves and hints you have used, and how many
Xsafe and mined locations you have marked.
X.SH OPTIONS
X.I Xmines
Xaccepts all of the standard X Toolkit command line options.
XIn addition, the command line options listed below may be specified.
XEach of these command line options corresponds to a resource.
XFor more information about the effect of these command line options,
Xsee the RESOURCES section below.
X.PP
XThe command line options and the resources they represent are:
X.TP 8
X.B \-cellsize \fIsize\fP
XThis option specifies the size in pixels of each of the cells (squares)
Xin the playing field.
XThe cellsize command line option corresponds to the "cellSize" resource.
X.TP 8
X.B \-rows \fInumber\fP
XThis option specifies the number of rows in the playing field.
XThe rows command line option corresponds to the "rows" resource.
X.TP 8
X.B \-columns \fInumber\fP
XThis option specifies the number of columns in the playing field.
XThe columns command line option corresponds to the "columns" resource.
X.TP 8
X.B \-mines \fInumber\fP
XThis option specifies the number of mines to be placed in the playing field.
XThe mines command line option corresponds to the "mines" resource.
X.SH "THE DISPLAY"
X.PP
XThe \fIxmines\fP window contains the following:
Xa title line, a command widget line,
Xa count display line, a status line, and the playing field.
X.PP
XThe title line lists the class name (XMines) and the current version
Xof xmines.
X.PP
XThe command widget line contains a number of input widgets that you use
Xto control the program. These are:
X.IP "Mine count" 8
XThis text field allows you to enter a new mine count.
XThis allows you to play an easier or harder game.
XWhen you enter a return in this field, a restart is automatically done.
XNote that you must delete the old number before putting in a new number.
XIf you enter a number that is too large, \fIxmines\fP will limit it to
Xthe largest number of mines that will fit into the board;
Xhowever, this will always produce a minefield which is impossible to
Xtraverse (see the discussion under the "restart" button below).
XThis is a standard text widget, so you can cut and paste or define
Xediting translations to your own desires using the standard text
Xwidget actions.
X.IP restart 8
XWhen this button is pressed, \fIxmines\fP resets the playing field.
XThe number of mines specified in the "Mine count" widget are hidden in the
Xplaying field, and the player is placed into the upper left square.
XThe object of the game is to move the player to the goal square in the
Xlower right corner of the playing field.
X\fIXmines\fP will never place a mine in the starting square, the goal
Xsquare, or the three squares immediately adjacent to the starting square.
XThus, when you first start a game, you will always see the message
X"No mines nearby" in the status line.
XIf the number of mines is very large, it is possible to generate a
Xminefield which has no safe path from start to goal.
XIn this case, the word "(impossible)" appears in the status line.
XYou can either select a smaller number of mines and try again, or
Xsimply try again with the same number until a potentially traversable
Xminefield is generated.
X.IP hint 8
XIf you are stuck and want to know which neighboring square you can move
Xto that is guaranteed not to contain a mine, you can press this button,
Xand \fIxmines\fP will mark one of the adjacent squares as "ok", meaning
Xthere is no mine there.
XIf one of the adjacent squares is already marked as "ok" but not yet
Xtraversed, or if there are no adjacent and untraversed squares which
Xdo not contain mines, then no square is marked.
XThe number of hints you have asked for is displayed in the line below
Xthe buttons.
X.IP quit 8
XWhen this button is pressed, \fIxmines\fP exits.
X.PP
XThe count display line displays the various numbers that the program
Xkeeps track of:
X.IP Moves 8
XThe number of moves that you have made so far in this round.
X.IP Hints 8
XThe number of hints that you have asked for so far in this round.
XThis number is incremented even if you ask for a hint and no squares
Xare marked "ok".
X.IP Safes 8
XThe number of squares which are marked "ok".
XEach time you mark a square as safe, this number increments.
XEach time you unmark a safe square, either
Xby explicitly unmarking it, marking it as a mine, or moving onto it,
Xthis number is decremented.
X.IP Mines
XThe number of squares which are marked as mines.
XEach time you mark a square as mined, this number increments.
XEach time you unmark a mined square, either
Xby explicitly unmarking it, marking it as safe,
Xthis number is decremented.
X.PP
XThe status line displays messages concerning the progress of the game.
XOn a normal move, it tells you how many mines are in the adjacent squares.
XIf you reach the goal, or step on a mine, it displays an appropriate message.
X.PP
XThe playing field is an array of cells (locations, squares), each of
Xwhich can potentially contain a mine.
XOne of the squares contains a stick man which represents your current
Xlocation in the minefield.
XSquares which you have already been traversed show the number of mines which
Xare adjacent to that square.
XThe number in the same square as the stick man shows the number of mines
Xadjacent to that position.
XYou use the pointer buttons to move your man around the minefield or to
Xmark squares as safe or mined (see the section "ACTIONS" below).
X.SH X RESOURCES
X\fIXmines\fP accepts all of the standard X Toolkit resource names and classes
Xas well as:
X.TP 8
X.B "cellSize (\fPclass\fB CellSize)"
XThis resource specifies the size, in pixels, of each cell in the playing
Xfield.
XSince the pictures which are placed into the cells are pixmaps, cell sizes
Xwhich do not match the pixmap sizes lead to white space (if cell size is
Xlarger than pixmap size), or a cropped picture (if cell size is smaller than
Xpixmap size).
XThere are two sizes of pixmap available, 16 and 32.
X\fIXmines\fP will use the 16 bit pixmaps if the cell size is 31 or less,
Xand will use the 32 bit pixmaps if the cell size is 32 or greater.
X.TP 8
X.B "rows (\fPclass\fB ArraySize)"
XThis resource specifies the number of the rows in the playing field.
XThis is typically the same number as the columns resources.
X.TP 8
X.B "columns (\fPclass\fB ArraySize)"
XThis resource specifies the number of the columns in the playing field.
XThis is typically the same number as the rows resources.
X.TP 8
X.B "mines (\fPclass\fB Mines)"
XThis resource specifies the number of mines to place into the playing field.
X.SH WIDGET NAMES
XThis section describes the widget tree used in \fIxmines\fP.
XBy using these names in your resource specifications, you can configure
Xthings like colors and sizes for the various widgets.
X.PP
XThe program name is taken from the command line, and the class name is XMines.
X.PP
XThe chart below gives the widget name followed by the name of its class in
Xparentheses.
XAll of the widgets are from the Athena Widget set.
X.PP
X.nf
X.na
Xxmines(Shell - top level toolkit widget)
X form(Form)
X title(Label)
X info(Command)
X countlabel(Label)
X mineinputcount(AsciiText)
X restart(Command)
X hint(Command)
X quit(Command)
X movelabel(Label)
X movecount(Label)
X hintlabel(Label)
X hintcount(Label)
X safelabel(Label)
X safecount(Label)
X minelabel(Label)
X minecount(Label)
X message(Label)
X cell(Form)
X R%dC%d(Widget) *
Xxmines_info(ApplicationShell)
X info(Form)
X version(Label)
X text(Command)
X.fi
X.ad
X.PP
X* The widgets labeled R%dC%d are the array of cells. The %d fields are
Xfilled in with the row and column number of that cell, starting at 0.
XThus the cell in the top left corner of the array is R0C0, the cell to
Xits right is R0C1, etc.
XThese widgets are Core widgets, so they have only the basic resources.
X.SH ACTIONS
X.PP
XXMines defines four actions that can be invoked through translations.
XThese actions are:
X.IP "DrawCell(row,col)" 8
XRefreshes the specified cell.
XThis action is invoked by each cell in response to an expose event in
Xorder to refresh itself.
XIf DrawCell is invoked with no parameters, it will refresh the current cell.
X.IP "MovePlayer()" 8
XMoves the player to the cell from which the action was invoked.
XThis is normally bound to the left mouse button to allow you to move
Xaround the playing field.
XIf you move onto a mine, the game ends.
XYou can not move to a cell which is marked as mined.
XYou can move directly to any square which has been previously traversed,
Xor to any square immediately adjacent to one which has been previously
Xtraversed (except those marked as mined).
X.IP "MarkMined()" 8
XMarks the cell as a mined cell.
XThis is normally bound to the center mouse button.
XIf the cell is already marked as mined, it will be unmarked.
XIf the cell is marked as safe, it will be marked as mined.
XThe safe and mined count fields are updated.
X.IP "MarkSafe()" 8
XMarks the cell as a safe cell.
XThis is normally bound to the right mouse button.
XIf the cell is already marked as safe, it will be unmarked.
XIf the cell is marked as mined, it will be marked as safe.
XThe safe and mined count fields are updated.
X.SH COPYRIGHT
XCopyright 1987, Tom Anderson
X.br
XCopyright 1990, Globetrotter Software, Inc.
X.br
XSee \fIX(1)\fP for a full statement of rights and permissions.
X.SH AUTHORS
XTom Anderson, Fluke Manufacturing Co. Inc.
X.br
XBrian Dalio, Mentor Graphics, Silicon Design Division.
X.br
XJim McBeath, Globetrotter Software, Inc.
END_OF_xmines.man
if test 10045 -ne `wc -c <xmines.man`; then
echo shar: \"xmines.man\" unpacked with wrong size!
fi
# end of overwriting check
fi
if test -f XMines.ad -a "${1}" != "-c" ; then
echo shar: Will not over-write existing file \"XMines.ad\"
else
echo shar: Extracting \"XMines.ad\" $1114 characters$
sed "s/^X//" >XMines.ad <<'END_OF_XMines.ad'
X!App-defaults file for xmines
XXMines*Font: 9x15
XXMines*cell.borderColor: blue
XXMines*cell.*.borderColor: red
XXMines*Cell.height: 32
XXMines*Cell.width: 32
XXMines*ArraySize: 12
XXMines*Mines: 26
XXMines*Label.borderWidth: 0
XXMines*Label.justify: left
XXMines*countlabel.label: Mine count:
XXMines*mineinputcount.width: 50
XXMines*info.horizDistance: 303
XXMines*info.label: Info
XXMines*movelabel.label: Moves:
XXMines*movecount.horizDistance: 0
XXMines*movecount.label: ....
XXMines*hintlabel.label: Hints:
XXMines*hintcount.horizDistance: 0
XXMines*hintcount.label: ....
XXMines*safelabel.label: Safes:
XXMines*safecount.horizDistance: 0
XXMines*safecount.label: ....
XXMines*minelabel.label: Mines:
XXMines*minecount.horizDistance: 0
XXMines*minecount.label: ....
XXMines*message.width: 460
XXMines*message.borderWidth: 1
XXMines*cell.*.borderWidth: 1
XXMines*cell.*.translations: #override \n\
X <Btn1Down> : MovePlayer() \n\
X <Btn2Down> : MarkMined() \n\
X <Btn3Down> : MarkSafe()
XXMines*restart.accelerators: #override \n\
X <Key>Return : set() notify() unset()
XXMines*info.version.borderWidth: 0
XXMines*xmines_info.Geometry: +400+300
END_OF_XMines.ad
if test 1114 -ne `wc -c <XMines.ad`; then
echo shar: \"XMines.ad\" unpacked with wrong size!
fi
# end of overwriting check
fi
echo shar: End of archive 1 $of 3$.
cp /dev/null ark1isdone
MISSING=""
for I in 1 2 3 ; do
if test ! -f ark${I}isdone ; then
MISSING="${MISSING} ${I}"
fi
done
if test "${MISSING}" = "" ; then
echo You have unpacked all 3 archives.
rm -f ark[1-9]isdone
else
echo You still need to unpack the following archives:
echo " " ${MISSING}
fi
## End of shell archive.
exit 0

dan
----------------------------------------------------
O'Reilly && Associates ar...@sun.com / ar...@ora.com
Opinions expressed reflect those of the author only.

Jim McBeath

unread,

Sep 12, 1990, 4:26:00 AM9/12/90

Submitted-by: uunet!globes!ji...@uunet.UU.NET (Jim McBeath)
Posting-number: Volume 9, Issue 28
Archive-name: xmines/part02

# "End of archive 2 (of 3)."
# Contents: mines.h patchlevel.h actions.c board.c buttons.c draw.c
# info.c main.c makeform.c msg.c
# Wrapped by jimmc@ss on Mon Sep 10 09:43:10 1990

PATH=/bin:/usr/bin:/usr/ucb ; export PATH

if test -f mines.h -a "${1}" != "-c" ; then
echo shar: Will not over-write existing file \"mines.h\"
else
echo shar: Extracting \"mines.h\" $2111 characters$
sed "s/^X//" >mines.h <<'END_OF_mines.h'
X/*
X * Copyright (c) 1987 Tom Anderson; 20831 Frank Waters Road;
X * Stanwood, WA 98282.
X *
X * Permission to use, copy, modify, distribute, and sell this software and its
X * documentation for any purpose is hereby granted without fee, provided that
X * the above copyright notice appear in all copies and that both that
X * copyright notice and this permission notice appear in supporting
X * documentation, and that the name of Tom Anderson not be used
X * in advertising or publicity pertaining to distribution of the software
X * without specific, written prior permission. Tom Anderson makes
X * no representations about the suitability of this software for any purpose.
X * It is provided "as is" without express or implied warranty.
X *
X * TOM ANDERSON DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
X * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO
X * EVENT SHALL TOM ANDERSON BE LIABLE FOR ANY SPECIAL, INDIRECT OR
X * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
X * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
X * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
X * OF THIS SOFTWARE.
X *
X */
X
X/* #define TINY_GAME /* for debugging */
X
X/*
X * mines header
X *
X */
X
X#define BOOL int
X#ifndef TRUE
X#define TRUE 1
X#endif
X#ifndef FALSE
X#define FALSE 0
X#endif
X
X/*
X * number of board squares per side
X */
X#define MAX_BOARD_ROWS 100
X#define MAX_BOARD_COLS 100
X#define DEFAULT_BOARD_ROWS 12
X#define DEFAULT_BOARD_COLS 12
X
X/*
X * board coordinates
X */
Xtypedef struct {
X int x;
X int y;
X} BoardCoordinate;
X
X/*
X * square state
X */
Xtypedef struct {
X BOOL traversed; /* has the poor soul stepped here? */
X BOOL mined; /* is this square mined? */
X BOOL occupied; /* is this square occupied? */
X BOOL unsafe; /* has the player determined a mine here?*/
X BOOL safe; /* has the player determined no mines here?*/
X BOOL visited; /* has connected test looked here yet? */
X int nearby; /* number of mines nearby. */
X short row,col;
X Widget w;
X} Square;
X
X/* end */
END_OF_mines.h
if test 2111 -ne `wc -c <mines.h`; then
echo shar: \"mines.h\" unpacked with wrong size!

fi
# end of overwriting check
fi

if test -f patchlevel.h -a "${1}" != "-c" ; then
echo shar: Will not over-write existing file \"patchlevel.h\"
else
echo shar: Extracting \"patchlevel.h\" $1453 characters$
sed "s/^X//" >patchlevel.h <<'END_OF_patchlevel.h'
X/*
X * Copyright 1990 Globetrotter Software, Inc.
X *
X * Permission to use, copy, modify, distribute, and sell this software and its
X * documentation for any purpose is hereby granted without fee, provided that
X * the above copyright notice appear in all copies and that both that
X * copyright notice and this permission notice appear in supporting
X * documentation, and that the name of Globetrotter Software not be used
X * in advertising or publicity pertaining to distribution of the software
X * without specific, written prior permission. Globetrotter Software makes
X * no representations about the suitability of this software for any purpose.
X * It is provided "as is" without express or implied warranty.
X *
X * GLOBETROTTER SOFTWARE DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
X * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO
X * EVENT SHALL GLOBETROTTER SOFTWARE BE LIABLE FOR ANY SPECIAL, INDIRECT OR
X * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
X * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
X * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
X * OF THIS SOFTWARE.
X *
X * Author: Jim McBeath, Globetrotter Software
X * globes!ji...@oliveb.olivetti.com
X * (408)741-0489
X */
X
X/* patchlevel.h for xmines
X */
X
Xchar *MinesVersion = "XMines v1.1";
X
X/*
X * Current patchlevel is 0 - this is the original!
X */
X
X/* end */
END_OF_patchlevel.h
if test 1453 -ne `wc -c <patchlevel.h`; then
echo shar: \"patchlevel.h\" unpacked with wrong size!

fi
# end of overwriting check
fi

if test -f actions.c -a "${1}" != "-c" ; then
echo shar: Will not over-write existing file \"actions.c\"
else
echo shar: Extracting \"actions.c\" $2816 characters$
sed "s/^X//" >actions.c <<'END_OF_actions.c'
X/*
X * Copyright 1990 Globetrotter Software, Inc.
X *
X * Permission to use, copy, modify, distribute, and sell this software and its
X * documentation for any purpose is hereby granted without fee, provided that
X * the above copyright notice appear in all copies and that both that
X * copyright notice and this permission notice appear in supporting
X * documentation, and that the name of Globetrotter Software not be used
X * in advertising or publicity pertaining to distribution of the software
X * without specific, written prior permission. Globetrotter Software makes
X * no representations about the suitability of this software for any purpose.
X * It is provided "as is" without express or implied warranty.
X *
X * GLOBETROTTER SOFTWARE DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
X * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO
X * EVENT SHALL GLOBETROTTER SOFTWARE BE LIABLE FOR ANY SPECIAL, INDIRECT OR
X * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
X * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
X * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
X * OF THIS SOFTWARE.
X *
X * Author: Jim McBeath, Globetrotter Software
X * globes!ji...@oliveb.olivetti.com
X * (408)741-0489
X */
X
X/* actions.c - action functions
X */
X
X#include <X11/Intrinsic.h>
X#include "mines.h"
X
Xextern int BoardRows, BoardCols;
X
Xextern Square *GetSquare();
X
Xvoid
XDrawCell(w,ev,params,num_params)
XWidget w;
XXEvent *ev;
XString *params;
XCardinal *num_params;
X{
X int row, col;
X Square *sqp, *GetWidgetSquare();
X
X if (*num_params == 0) {
X sqp = GetWidgetSquare(w);
X DrawSquare(sqp);
X return;
X }
X if (*num_params != 2)
X return;
X row = atoi(params[0]);
X col = atoi(params[1]);
X if (row<0 || row>=BoardRows)
X return;
X if (col<0 || col>=BoardCols)
X return;
X sqp = GetSquare(row,col);
X DrawSquare(sqp);
X}
X
Xvoid
XMovePlayer(w,ev,params,num_params)
XWidget w;
XXEvent *ev;
XString *params;
XCardinal *num_params;
X{
X Square *sqp;
X
X if (*num_params != 0)
X return;
X sqp = GetWidgetSquare(w);
X if (!sqp)
X return;
X DoMove(sqp);
X}
X
Xvoid
XMarkMined(w,ev,params,num_params)
XWidget w;
XXEvent *ev;
XString *params;
XCardinal *num_params;
X{
X Square *sqp;
X
X if (*num_params != 0)
X return;
X sqp = GetWidgetSquare(w);
X if (!sqp)
X return;
X MarkSquare(sqp,FALSE);
X}
X
Xvoid
XMarkSafe(w,ev,params,num_params)
XWidget w;
XXEvent *ev;
XString *params;
XCardinal *num_params;
X{
X Square *sqp;
X
X if (*num_params != 0)
X return;
X sqp = GetWidgetSquare(w);
X if (!sqp)
X return;
X MarkSquare(sqp,TRUE);
X}
X
XXtActionsRec actions[] = {
X { "DrawCell", DrawCell},
X { "MovePlayer", MovePlayer},
X { "MarkMined", MarkMined},
X { "MarkSafe", MarkSafe},
X};
X
XInitActions(appctx)
XXtAppContext appctx;
X{
X XtAppAddActions(appctx,actions,XtNumber(actions));
X}
X
X/* end */
END_OF_actions.c
if test 2816 -ne `wc -c <actions.c`; then
echo shar: \"actions.c\" unpacked with wrong size!

fi
# end of overwriting check
fi

if test -f board.c -a "${1}" != "-c" ; then
echo shar: Will not over-write existing file \"board.c\"
else
echo shar: Extracting \"board.c\" $8437 characters$
sed "s/^X//" >board.c <<'END_OF_board.c'
X/*
X * Copyright (c) 1987 Tom Anderson; 20831 Frank Waters Road;
X * Stanwood, WA 98282.
X *
X * Permission to use, copy, modify, distribute, and sell this software and its
X * documentation for any purpose is hereby granted without fee, provided that
X * the above copyright notice appear in all copies and that both that
X * copyright notice and this permission notice appear in supporting
X * documentation, and that the name of Tom Anderson not be used
X * in advertising or publicity pertaining to distribution of the software
X * without specific, written prior permission. Tom Anderson makes
X * no representations about the suitability of this software for any purpose.
X * It is provided "as is" without express or implied warranty.
X *
X * TOM ANDERSON DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
X * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO
X * EVENT SHALL TOM ANDERSON BE LIABLE FOR ANY SPECIAL, INDIRECT OR
X * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
X * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
X * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
X * OF THIS SOFTWARE.
X *
X */
X
X/*
X * manage the board state
X *
X */
Xstatic char copyright[] = "Copyright 1987 Tom Anderson";
X
X#include <stdio.h>
X#include <strings.h>
X#include <sys/types.h>
X
X#include <X11/Intrinsic.h>
X#include "mines.h"
X
Xextern char *malloc();
X
XSquare **MainBoard;
Xint BoardRows;
Xint BoardCols;
XSquare *PlayerSquare;
XBOOL GameOver;
XBOOL Impossible;
X
Xstatic int lastlevel;
X
Xstatic char *
Xs_malloc(size)
Xint size;
X{
X char *p;
X
X p = malloc(size);
X if (!p) {
X fprintf(stderr,"Can't allocate memory for playing board\n");
X exit(1);
X }
X return p;
X}
X
Xvoid
XAllocBoard(numrows,numcols,deflevel)
Xint numrows,numcols;
Xint deflevel; /* default number of mines to put in */
X{
X int i;
X
X BoardRows = numrows;
X BoardCols = numcols;
X
X if (BoardRows < 3)
X BoardRows = 3;
X if (BoardCols < 3)
X BoardCols = 3;
X if (BoardRows > MAX_BOARD_ROWS)
X BoardRows = MAX_BOARD_ROWS;
X if (BoardCols > MAX_BOARD_COLS)
X BoardCols = MAX_BOARD_COLS;
X
X MainBoard = (Square **)s_malloc(BoardRows * sizeof(Square *));
X for (i=0; i<BoardRows; i++) {
X MainBoard[i] = (Square *)s_malloc(BoardCols * sizeof(Square));
X }
X if (deflevel>0) /* set default mine quantity */
X lastlevel = deflevel;
X else
X lastlevel = (BoardRows + BoardCols) / 2;
X}
X
X/*
X * set up the playing surface at the beginning of the game
X */
Xvoid
XInitBoard(level)
Xint level; /* number of mines */
X{
X register int i, j, minesPlaced, cutoff;
X register Square * sqp;
X int pass = 0;
X void MazeConnected();
X char *MineWarningMessage();
X
X if (level<=0) level=lastlevel;
X if (level > (BoardRows*BoardCols-5))
X level = BoardRows*BoardCols-5; /* avoid infinite loop below */
X lastlevel = level;
X SetMineCountDisplay(level);
X
X /* zero the board */
X for (i = 0 ; i < BoardRows ; i++) {
X for (j = 0 ; j < BoardCols ; j++) {
X sqp = &MainBoard[i][j];
X sqp->traversed = sqp->mined = sqp->occupied
X = sqp->unsafe = sqp->safe = FALSE;
X sqp->nearby = 0;
X sqp->visited = FALSE;
X sqp->row = i;
X sqp->col = j;
X }
X }
X
X /* make several passes over the board, placing mines at
X * a probability calculated to require about 3 passes on the average
X */
X cutoff = level / 3 + 1;
X for (minesPlaced = 0 ; minesPlaced < level ; ) {
X for (i = 0 ; i < BoardRows ; i++) {
X for (j = 0 ; j < BoardCols ; j++) {
X if ((random() % (BoardRows * BoardCols)) <cutoff
X && ! MainBoard[i][j].mined
X && minesPlaced < level
X && ! (i <= 1 && j <= 1)
X && ! (i==BoardRows-1 && j==BoardCols-1)) {
X MainBoard[i][j].mined = TRUE;
X minesPlaced++;
X }
X }
X }
X }
X PlayerSquare = &MainBoard[0][0];
X MainBoard[0][0].occupied = MainBoard[0][0].traversed = TRUE;
X GameOver = FALSE;
X
X MazeConnected();
X
X Message(MineWarningMessage());
X
X#ifndef NOSCORE
X SetHints(0);
X SetNumberMoves(0);
X SetMinesMarked(0);
X SetSafesMarked(0);
X#endif
X}
X
XBOOL
XTraverse(x, y)
Xint x;
Xint y;
X{
X int i;
X int j;
X
X if (y == BoardRows-1 && x == BoardCols-1) return TRUE;
X
X MainBoard[y][x].visited = TRUE;
X
X for (i=y-1; i <= y+1; i++) {
X if (i < 0 || i == BoardRows) continue;
X for (j=x-1; j <= x+1; j++) {
X if (j < 0 || j == BoardCols) continue;
X if (i == y && j == x) continue;
X if (MainBoard[i][j].visited) continue;
X if (MainBoard[i][j].mined) continue;
X
X if (Traverse(j, i)) return TRUE;
X }
X }
X
X return FALSE;
X}
X
Xvoid
XMazeConnected()
X{
X Impossible = !Traverse(0, 0);
X}
X
XSetCellWidget(row,col,w)
Xint row,col;
XWidget w;
X{
X MainBoard[row][col].w = w;
X}
X
X/* translate (row,col) to Square pointer */
XSquare *
XGetSquare(row,col)
Xint row,col;
X{
X return (&MainBoard[row][col]);
X}
X
X/* translate Widget to Square pointer; NULL pointer if didn't get it */
XSquare *
XGetWidgetSquare(w)
XWidget w;
X{
X int x,y;
X Square *sqp;
X
X for (y=0; y<BoardRows; y++) {
X for (x=0; x<BoardCols; x++) {
X sqp = &MainBoard[y][x];
X if (sqp->w == w) {
X return sqp;
X }
X }
X }
X return NULL;
X}
X
X/* toggle a square's marking as being probably safe or unsafe */
Xvoid
XMarkSquare(sqp,safe)
XSquare *sqp;
XBOOL safe;
X{
X if (sqp->traversed)
X return;
X
X if (safe) {
X#ifndef NOSCORE
X IncrSafesMarked(sqp->safe ? -1 : 1);
X IncrMinesMarked(sqp->unsafe ? -1 : 0);
X#endif
X sqp->safe = ! sqp->safe;
X sqp->unsafe = FALSE;
X } else {
X#ifndef NOSCORE
X IncrSafesMarked(sqp->safe ? -1 : 0);
X IncrMinesMarked(sqp->unsafe ? -1 : 1);
X#endif
X sqp->unsafe = ! sqp->unsafe;
X sqp->safe = FALSE;
X }
X DrawSquare(sqp);
X}
X
X
X/* try to move to a certain board coordinate */
Xvoid
XDoMove(sqp)
XSquare *sqp;
X{
X int row,col;
X register int y = PlayerSquare->row;
X register int x = PlayerSquare->col;
X
X row = sqp->row;
X col = sqp->col;
X if ((col == x) && (row == y)) return;
X if (MainBoard[row][col].unsafe) return;
X
X if ((abs(col - x) > 1) || (abs(row - y) > 1)) {
X int xx, yy;
X
X /* allow moving to any square which is or is adjacent to
X * a traversed square */
X for (xx = col - 1 ; xx <= col + 1 ; xx++) {
X for (yy = row - 1 ; yy <= row + 1 ; yy++) {
X if (xx >= 0 && xx < BoardCols &&
X yy >= 0 && yy < BoardRows &&
X MainBoard[yy][xx].traversed) goto ok;
X }
X }
X return;
X }
X
Xok:
X
X#ifndef NOSCORE
X IncrNumberMoves(1);
X#endif
X
X /* step off our current square */
X MainBoard[y][x].occupied = FALSE;
X DrawSquare(PlayerSquare);
X sqp = &MainBoard[row][col];
X
X /* if we stepped on a mine, blow him up */
X if (sqp->mined) {
X GameOver = TRUE;
X Message("You just exploded. ");
X DrawBoard(0);
X }
X
X /* else if this is home, render congratulations */
X else if (col == BoardCols-1 && row == BoardRows-1) {
X PlayerSquare = sqp;
X sqp->traversed = sqp->occupied = TRUE;
X GameOver = TRUE;
X Message("You honestly made it!");
X DrawBoard(0);
X }
X
X /* else move onto the new square */
X else {
X /* if player marked that square as safe, unmark */
X if (sqp->safe) {
X#ifndef NOSCORE
X IncrSafesMarked(-1);
X#endif
X sqp->safe = FALSE;
X }
X PlayerSquare = sqp;
X Message(MineWarningMessage());
X sqp->traversed = sqp->occupied = TRUE;
X DrawSquare(sqp);
X }
X}
X
XSquare *
XGetHintSquare() /* returns pointer to a square suitable for a hint; or NULL */
X{
X int i;
X int j;
X int x = PlayerSquare->col;
X int y = PlayerSquare->row;
X
X for (j = y-1; j <= y+1; j++) {
X if (j < 0 || j == BoardRows) continue;
X for (i = x-1; i <= x+1; i++) {
X if (i < 0 || i == BoardCols) continue;
X if (j == y && i == x) continue;
X
X if (MainBoard[j][i].traversed) continue;
X
X if (!MainBoard[j][i].mined) {
X
X#ifndef NOSCORE
X IncrHints(1);
X#endif
X MainBoard[j][i].safe = TRUE;
X MainBoard[j][i].unsafe = FALSE;
X
X return (GetSquare(j,i));
X }
X }
X }
X return NULL;
X}
X
X/*
X * return a pointer to the warning message
X */
Xchar *
XMineWarningMessage()
X{
X static char warning[128];
X register int x, y;
X int minesFound = 0;
X
X if (!PlayerSquare->traversed) {
X for (x = PlayerSquare->col - 1 ;
X x <= PlayerSquare->col + 1 ;
X x++) {
X for (y = PlayerSquare->row - 1 ;
X y <= PlayerSquare->row + 1 ;
X y++) {
X if (x >= 0 && x < BoardCols &&
X y >= 0 && y < BoardRows &&
X MainBoard[y][x].mined)
X minesFound++;
X }
X }
X PlayerSquare->nearby = minesFound;
X } else {
X minesFound = PlayerSquare->nearby;
X }
X
X if (minesFound == 0) {
X sprintf(warning, "No mines nearby.");
X } else if (minesFound == 1) {
X sprintf(warning, "1 mine nearby.");
X } else {
X sprintf(warning, "%d mines nearby.", minesFound);
X }
X
X return(warning);
X}
X
X/* end */
END_OF_board.c
if test 8437 -ne `wc -c <board.c`; then
echo shar: \"board.c\" unpacked with wrong size!

fi
# end of overwriting check
fi

if test -f buttons.c -a "${1}" != "-c" ; then
echo shar: Will not over-write existing file \"buttons.c\"
else
echo shar: Extracting \"buttons.c\" $3958 characters$
sed "s/^X//" >buttons.c <<'END_OF_buttons.c'
X/*
X * Copyright 1990 Globetrotter Software, Inc.
X *
X * Permission to use, copy, modify, distribute, and sell this software and its
X * documentation for any purpose is hereby granted without fee, provided that
X * the above copyright notice appear in all copies and that both that
X * copyright notice and this permission notice appear in supporting
X * documentation, and that the name of Globetrotter Software not be used
X * in advertising or publicity pertaining to distribution of the software
X * without specific, written prior permission. Globetrotter Software makes
X * no representations about the suitability of this software for any purpose.
X * It is provided "as is" without express or implied warranty.
X *
X * GLOBETROTTER SOFTWARE DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
X * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO
X * EVENT SHALL GLOBETROTTER SOFTWARE BE LIABLE FOR ANY SPECIAL, INDIRECT OR
X * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
X * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
X * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
X * OF THIS SOFTWARE.
X *
X * Author: Jim McBeath, Globetrotter Software
X * globes!ji...@oliveb.olivetti.com
X * (408)741-0489
X */
X
X/* buttons.c - command button processing
X */
X
X#include <X11/Intrinsic.h>
X#include <X11/StringDefs.h>
X#include <X11/Xaw/Form.h>
X#include <X11/Xaw/Command.h>
X#include <X11/Xaw/AsciiText.h>
X#include "mines.h"
X
X#define MBUFSIZE 6
Xchar MineCountBuf[MBUFSIZE];
XWidget TotalMineCountWidget;
X
Xvoid
XSetMineCountDisplay(n)
Xint n;
X{
X char mbuf[MBUFSIZE];
X Arg arg;
X
X bzero(mbuf,sizeof(mbuf));
X sprintf(mbuf,"%d",n);
X XtSetArg(arg,"string",mbuf);
X XtSetValues(TotalMineCountWidget,&arg,1);
X}
X
Xstatic void
XRestartGameCB(w,client_data,call_data)
XWidget w;
Xcaddr_t client_data, call_data; /* ignored */
X{
X int n;
X Arg arg;
X char *ss;
X
X XtSetArg(arg,"string",&ss);
X XtGetValues(TotalMineCountWidget,&arg,1);
X n = atoi(ss);
X InitBoard(n);
X DrawBoard(1); /* redraw the board */
X}
X
Xstatic void
XQuitCB(w,client_data,call_data)
XWidget w;
Xcaddr_t client_data, call_data; /* ignored */
X{
X exit(0); /* TBD - any saving options or anything? */
X}
X
Xstatic void
XGiveHintCB(w,client_data,call_data)
XWidget w;
Xcaddr_t client_data, call_data; /* ignored */
X{
X Square *sqp, *GetHintSquare();
X
X sqp = GetHintSquare();
X if (!sqp)
X return;
X DrawSquare(sqp);
X}
X
XWidget
XInitButtons(parent,above)
XWidget parent;
XWidget above;
X{
X int i;
X Arg args[10];
X Widget lasthwidget, minecountw;
X
X i = 0;
X XtSetArg(args[i],XtNfromVert,above);
X i++;
X lasthwidget = XtCreateManagedWidget("countlabel",
X labelWidgetClass, parent, args, i);
X
X i = 0;
X XtSetArg(args[i],XtNfromVert,above);
X i++;
X XtSetArg(args[i],XtNfromHoriz,lasthwidget);
X i++;
X XtSetArg(args[i],XtNeditType,XawtextEdit);
X i++;
X XtSetArg(args[i],XtNstring,MineCountBuf);
X i++;
X XtSetArg(args[i],XtNlength,sizeof(MineCountBuf)-1);
X i++;
X lasthwidget = TotalMineCountWidget = XtCreateManagedWidget(
X "mineinputcount",asciiTextWidgetClass, parent, args, i);
X minecountw = lasthwidget;
X
X i = 0;
X XtSetArg(args[i],XtNfromVert,above);
X i++;
X XtSetArg(args[i],XtNfromHoriz,lasthwidget);
X i++;
X lasthwidget = XtCreateManagedWidget("restart",
X commandWidgetClass, parent, args, i);
X XtAddCallback(lasthwidget,XtNcallback,RestartGameCB,(caddr_t)0);
X XtInstallAccelerators(minecountw,lasthwidget);
X
X i = 0;
X XtSetArg(args[i],XtNfromVert,above);
X i++;
X XtSetArg(args[i],XtNfromHoriz,lasthwidget);
X i++;
X lasthwidget = XtCreateManagedWidget("hint",
X commandWidgetClass, parent, args, i);
X XtAddCallback(lasthwidget,XtNcallback,GiveHintCB,(caddr_t)0);
X
X i = 0;
X XtSetArg(args[i],XtNfromVert,above);
X i++;
X XtSetArg(args[i],XtNfromHoriz,lasthwidget);
X i++;
X lasthwidget = XtCreateManagedWidget("quit",
X commandWidgetClass, parent, args, i);
X XtAddCallback(lasthwidget,XtNcallback,QuitCB,(caddr_t)0);
X
X return lasthwidget;
X}
X
X/* end */
END_OF_buttons.c
if test 3958 -ne `wc -c <buttons.c`; then
echo shar: \"buttons.c\" unpacked with wrong size!

fi
# end of overwriting check
fi

if test -f draw.c -a "${1}" != "-c" ; then
echo shar: Will not over-write existing file \"draw.c\"
else
echo shar: Extracting \"draw.c\" $7508 characters$
sed "s/^X//" >draw.c <<'END_OF_draw.c'
X/*
X * Copyright 1990 Globetrotter Software, Inc.
X *
X * Permission to use, copy, modify, distribute, and sell this software and its
X * documentation for any purpose is hereby granted without fee, provided that
X * the above copyright notice appear in all copies and that both that
X * copyright notice and this permission notice appear in supporting
X * documentation, and that the name of Globetrotter Software not be used
X * in advertising or publicity pertaining to distribution of the software
X * without specific, written prior permission. Globetrotter Software makes
X * no representations about the suitability of this software for any purpose.
X * It is provided "as is" without express or implied warranty.
X *
X * GLOBETROTTER SOFTWARE DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
X * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO
X * EVENT SHALL GLOBETROTTER SOFTWARE BE LIABLE FOR ANY SPECIAL, INDIRECT OR
X * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
X * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
X * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
X * OF THIS SOFTWARE.
X *
X * Author: Jim McBeath, Globetrotter Software
X * globes!ji...@oliveb.olivetti.com
X * (408)741-0489
X */
X
X/* draw.c - functions to draw stuff on the screen
X */
X
X#include <X11/Intrinsic.h>
X#include <X11/StringDefs.h>
X#include "mines.h"
X
X/* include all of the bitmaps */
X#include "bMine.xbm" /* bad mine */
X#include "bMineSm.xbm" /* bad mine, small version */
X#include "bSafe.xbm" /* bad safee */
X#include "bSafeSm.xbm"
X#include "hMine.xbm" /* hidden mine */
X#include "hMineSm.xbm"
X#include "mine.xbm"
X#include "mineSm.xbm"
X#include "safe.xbm"
X#include "safeSm.xbm"
X
X#include "e0.xbm" /* empty traversed square with 0 mines around */
X#include "e0Sm.xbm" /* small version of 0-mine empty */
X#include "e1.xbm" /* one mine in neighboring cells */
X#include "e1Sm.xbm"
X#include "e2.xbm"
X#include "e2Sm.xbm"
X#include "e3.xbm"
X#include "e3Sm.xbm"
X#include "e4.xbm"
X#include "e4Sm.xbm"
X#include "e5.xbm"
X#include "e5Sm.xbm"
X#include "e6.xbm"
X#include "e6Sm.xbm"
X#include "e7.xbm"
X#include "e7Sm.xbm"
X#include "e8.xbm"
X#include "e8Sm.xbm"
X
X#include "pl0.xbm" /* player square with 0 mine around it */
X#include "pl0Sm.xbm" /* small version of 0-mine player square */
X#include "pl1.xbm"
X#include "pl1Sm.xbm"
X#include "pl2.xbm"
X#include "pl2Sm.xbm"
X#include "pl3.xbm"
X#include "pl3Sm.xbm"
X#include "pl4.xbm"
X#include "pl4Sm.xbm"
X#include "pl5.xbm"
X#include "pl5Sm.xbm"
X#include "pl6.xbm"
X#include "pl6Sm.xbm"
X#include "pl7.xbm"
X#include "pl7Sm.xbm"
X#include "pl8.xbm"
X#include "pl8Sm.xbm"
X
Xextern int BoardRows, BoardCols;
Xextern BOOL GameOver;
X
Xextern Square *GetSquare();
X
X/* bitmaps and small bitmaps */
XPixmap MineSquareBM, BadMineSquareBM, HiddenMineSquareBM;
XPixmap MineSquareSBM, BadMineSquareSBM, HiddenMineSquareSBM;
XPixmap SafeSquareBM, BadSafeSquareBM;
XPixmap SafeSquareSBM, BadSafeSquareSBM;
X
XPixmap player_squaresBM[9];
XPixmap player_squaresSBM[9];
XPixmap numbered_squaresBM[9];
XPixmap numbered_squaresSBM[9];
X
XInitBitmaps(dpy,win)
XDisplay *dpy;
XWindow win;
X{
X#define BB(var,file) \
X var = XCreateBitmapFromData(dpy,win,\
X file/**/_bits,file/**/_width,file/**/_height);
X BB(MineSquareBM,mine);
X BB(MineSquareSBM,mineSmall);
X BB(BadMineSquareBM,badmine);
X BB(BadMineSquareSBM,badmineSmall);
X BB(HiddenMineSquareBM,hiddenmine);
X BB(HiddenMineSquareSBM,hiddenmineSmall);
X BB(SafeSquareBM,safe);
X BB(SafeSquareSBM,safeSmall);
X BB(BadSafeSquareBM,badsafe);
X BB(BadSafeSquareSBM,badsafeSmall);
X BB(player_squaresBM[0],plZero);
X BB(player_squaresSBM[0],plZeroSmall);
X BB(player_squaresBM[1],plOne);
X BB(player_squaresSBM[1],plOneSmall);
X BB(player_squaresBM[2],plTwo);
X BB(player_squaresSBM[2],plTwoSmall);
X BB(player_squaresBM[3],plThree);
X BB(player_squaresSBM[3],plThreeSmall);
X BB(player_squaresBM[4],plFour);
X BB(player_squaresSBM[4],plFourSmall);
X BB(player_squaresBM[5],plFive);
X BB(player_squaresSBM[5],plFiveSmall);
X BB(player_squaresBM[6],plSix);
X BB(player_squaresSBM[6],plSixSmall);
X BB(player_squaresBM[7],plSeven);
X BB(player_squaresSBM[7],plSevenSmall);
X BB(player_squaresBM[8],plEight);
X BB(player_squaresSBM[8],plEightSmall);
X BB(numbered_squaresBM[0],zero);
X BB(numbered_squaresSBM[0],zeroSmall);
X BB(numbered_squaresBM[1],one);
X BB(numbered_squaresSBM[1],oneSmall);
X BB(numbered_squaresBM[2],two);
X BB(numbered_squaresSBM[2],twoSmall);
X BB(numbered_squaresBM[3],three);
X BB(numbered_squaresSBM[3],threeSmall);
X BB(numbered_squaresBM[4],four);
X BB(numbered_squaresSBM[4],fourSmall);
X BB(numbered_squaresBM[5],five);
X BB(numbered_squaresSBM[5],fiveSmall);
X BB(numbered_squaresBM[6],six);
X BB(numbered_squaresSBM[6],sixSmall);
X BB(numbered_squaresBM[7],seven);
X BB(numbered_squaresSBM[7],sevenSmall);
X BB(numbered_squaresBM[8],eight);
X BB(numbered_squaresSBM[8],eightSmall);
X}
X
X/*
X * draw a square
X */
Xvoid
XDrawSquare(sqp)
XSquare *sqp;
X{
X Pixmap bm,sbm;
X String bmname;
X char nbuf[30];
X Widget w;
X Window win;
X Display *dpy;
X GC gc;
X int width,height,bmsize;
X int dx,dy;
X int i;
X Arg args[10];
X static int lastwidth, lastheight;
X
X if (!sqp)
X return;
X /* determine which bitmap to paint the square with */
X if (sqp->occupied) {
X bm = player_squaresBM[sqp->nearby];
X sbm = player_squaresSBM[sqp->nearby];
X sprintf(nbuf,"pl%d",sqp->nearby);
X bmname = nbuf;
X } else if (sqp->traversed) {
X bm = numbered_squaresBM[sqp->nearby];
X sbm = numbered_squaresSBM[sqp->nearby];
X sprintf(nbuf,"%d",sqp->nearby);
X bmname = nbuf;
X } else if (GameOver) {
X if (sqp->mined) {
X if (sqp->safe) {
X bm = BadSafeSquareBM;
X sbm = BadSafeSquareSBM;
X bmname = "badsafe";
X } else if (sqp->unsafe) {
X bm = MineSquareBM;
X sbm = MineSquareSBM;
X bmname = "mine";
X } else {
X bm = HiddenMineSquareBM;
X sbm = HiddenMineSquareSBM;
X bmname = "hiddenmine";
X }
X } else {
X if (sqp->unsafe) {
X bm = BadMineSquareBM;
X sbm = BadMineSquareSBM;
X bmname = "badmine";
X } else if (sqp->safe) {
X bm = SafeSquareBM;
X sbm = SafeSquareSBM;
X bmname = "safe";
X } else {
X bm = sbm = NULL;
X bmname = "white";
X }
X }
X } else if (sqp->unsafe) {
X bm = MineSquareBM;
X sbm = MineSquareSBM;
X bmname = "mine";
X } else if (sqp->safe) {
X bm = SafeSquareBM;
X sbm = SafeSquareSBM;
X bmname = "safe";
X } else {
X bm = sbm = NULL;
X bmname = "white";
X }
X
X /* paint the square */
X w = sqp->w;
X win = XtWindow(w);
X dpy = XtDisplay(w);
X gc = XDefaultGC(dpy,XDefaultScreen(dpy));
X XClearWindow(dpy,win);
X#if 0 /* doesn't work */
X i=0;
X XtSetArg(args[i],XtNwidth,&width);
X i++;
X XtSetArg(args[i],XtNheight,&height);
X i++;
X XtGetValues(w,args,i);
X#else
X/* a hack to avoid getting the size for every cell */
X if (sqp->row==0 && sqp->col==0) {
X Window root;
X int x,y,bwidth,depth;
X XGetGeometry(dpy,win,&root,&x,&y,&width,&height,&bwidth,&depth);
X lastwidth = width;
X lastheight = height;
X } else {
X width = lastwidth;
X height = lastheight;
X }
X#endif
X if (width<32 || height<32) {
X bm = sbm; /* use small bitmap */
X bmsize = 16;
X } else {
X bmsize = 32;
X }
X dx = (width-bmsize)/2;
X dy = (height-bmsize)/2;
X if (bm) {
X XCopyPlane(dpy,bm,win,gc,0,0,bmsize,bmsize,dx,dy,1);
X }
X#if 0
X XDrawImageString(dpy,win,gc,0,12,bmname,strlen(bmname));
X#endif
X}
X
Xvoid
XDrawBoard(clearflag)
Xint clearflag; /* ignored for now */
X{
X int x,y;
X Square *sqp;
X
X for (y=0; y<BoardRows; y++) {
X for (x=0; x<BoardCols; x++) {
X sqp = GetSquare(y,x);
X DrawSquare(sqp);
X }
X }
X}
X
X/* end */
END_OF_draw.c
if test 7508 -ne `wc -c <draw.c`; then
echo shar: \"draw.c\" unpacked with wrong size!

fi
# end of overwriting check
fi

if test -f info.c -a "${1}" != "-c" ; then
echo shar: Will not over-write existing file \"info.c\"
else
echo shar: Extracting \"info.c\" $3308 characters$
sed "s/^X//" >info.c <<'END_OF_info.c'
X/*
X * Copyright 1990 Globetrotter Software, Inc.
X *
X * Permission to use, copy, modify, distribute, and sell this software and its
X * documentation for any purpose is hereby granted without fee, provided that
X * the above copyright notice appear in all copies and that both that
X * copyright notice and this permission notice appear in supporting
X * documentation, and that the name of Globetrotter Software not be used
X * in advertising or publicity pertaining to distribution of the software
X * without specific, written prior permission. Globetrotter Software makes
X * no representations about the suitability of this software for any purpose.
X * It is provided "as is" without express or implied warranty.
X *
X * GLOBETROTTER SOFTWARE DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
X * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO
X * EVENT SHALL GLOBETROTTER SOFTWARE BE LIABLE FOR ANY SPECIAL, INDIRECT OR
X * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
X * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
X * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
X * OF THIS SOFTWARE.
X *
X * Author: Jim McBeath, Globetrotter Software
X * globes!ji...@oliveb.olivetti.com
X * (408)741-0489
X */
X
X/* info.c - add an info button to a form; it will pop up an info panel
X *
X * 19.Jul.90 jimmc Initial definition
X */
X
X#include <X11/Intrinsic.h>
X#include <X11/StringDefs.h>
X#include <X11/Shell.h>
X#include <X11/Xaw/Form.h>
X#include <X11/Xaw/Command.h>
X#include "mines.h"
X
Xextern char *MinesVersion;
X
Xstatic char infotext[] = "\
XCopyright 1990 Globetrotter Software, Inc.\n\
XPortions Copyright 1987 Tom Anderson.\n\
XThis software is freely redistributable\n\
X(with some restrictions).\n\
X\n\
XOriginal version written by Tom Anderson;\n\
Xmodified by Brian Dalio;\n\
Xmodified and ported to X11 by Jim McBeath.";
X
Xstatic void
XInfoCB(w,client_data,call_data)
XWidget w;
Xcaddr_t client_data, call_data; /* ignored */
X{
X Widget shell = (Widget)client_data;
X
X XtPopup(shell,XtGrabNone);
X}
X
Xstatic void
XInfoDownCB(w,client_data,call_data)
XWidget w;
Xcaddr_t client_data, call_data; /* ignored */
X{
X Widget shell = (Widget)client_data;
X
X XtPopdown(shell);
X}
X
Xvoid
XInitInfoButton(topw,parent,fromhoriz)
XWidget topw;
XWidget parent;
XWidget fromhoriz;
X{
X int i;
X Arg args[10];
X Widget infoshell, infoform, w;
X
X/* first, make the popup with the info in it */
X i = 0;
X infoshell = XtCreatePopupShell("xmines_info",
X applicationShellWidgetClass,
X topw,args,i);
X
X i = 0;
X infoform = XtCreateManagedWidget("info",formWidgetClass,
X infoshell,args,i);
X
X i = 0;
X XtSetArg(args[i],XtNlabel,MinesVersion);
X i++;
X w = XtCreateManagedWidget("version",labelWidgetClass,infoform,args,i);
X
X i = 0;
X XtSetArg(args[i],XtNlabel,infotext);
X i++;
X XtSetArg(args[i],XtNfromVert,w);
X i++;
X w = XtCreateManagedWidget("text",commandWidgetClass,infoform,args,i);
X /* put in the text */
X XtAddCallback(w,XtNcallback,InfoDownCB,(caddr_t)infoshell);
X
X/* now add a button to the parent form which will bring up the info popup */
X i = 0;
X XtSetArg(args[i],XtNfromHoriz,fromhoriz);
X i++;
X w = XtCreateManagedWidget("info",
X commandWidgetClass, parent, args, i);
X XtAddCallback(w,XtNcallback,InfoCB,(caddr_t)infoshell);
X}
X
X/* end */
END_OF_info.c
if test 3308 -ne `wc -c <info.c`; then
echo shar: \"info.c\" unpacked with wrong size!

fi
# end of overwriting check
fi

if test -f main.c -a "${1}" != "-c" ; then
echo shar: Will not over-write existing file \"main.c\"
else
echo shar: Extracting \"main.c\" $5104 characters$
sed "s/^X//" >main.c <<'END_OF_main.c'
X/*
X * Copyright 1990 Globetrotter Software, Inc.
X *
X * Permission to use, copy, modify, distribute, and sell this software and its
X * documentation for any purpose is hereby granted without fee, provided that
X * the above copyright notice appear in all copies and that both that
X * copyright notice and this permission notice appear in supporting
X * documentation, and that the name of Globetrotter Software not be used
X * in advertising or publicity pertaining to distribution of the software
X * without specific, written prior permission. Globetrotter Software makes
X * no representations about the suitability of this software for any purpose.
X * It is provided "as is" without express or implied warranty.
X *
X * GLOBETROTTER SOFTWARE DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
X * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO
X * EVENT SHALL GLOBETROTTER SOFTWARE BE LIABLE FOR ANY SPECIAL, INDIRECT OR
X * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
X * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
X * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
X * OF THIS SOFTWARE.
X *
X * Author: Jim McBeath, Globetrotter Software
X * globes!ji...@oliveb.olivetti.com
X * (408)741-0489
X */
X
X/* xmines - the minestool game for X11
X */
X
X#include <X11/Intrinsic.h>
X#include <X11/Xatom.h>
X#include <X11/StringDefs.h>
X#include <X11/Shell.h>
X#include <stdio.h>
X#include <ctype.h>
X#include "mines.h"
X#include "patchlevel.h" /* pick up the version string */
X
Xchar *Progname;
XXtAppContext appctx;
X
X/* we use the AppResources structure to collect info from the calls to
X * XtGetApplicationResources.
X */
Xtypedef struct {
X int cellsize; /* width and height of each cell in the array */
X int numrows, numcols;
X int minecount;
X} AppResources, *AppResourcesPtr;
X
X/* a place to put data into from the call to XtGetApplicationResources. */
Xstatic AppResources Adata = { 32, DEFAULT_BOARD_ROWS, DEFAULT_BOARD_COLS};
X
X/* fallback resources in case we can't find the app-defaults file */
Xstatic String fallback_resources[] = {
X "*Cell.height: 32",
X "*Cell.width: 32",
X "*ArraySize: 12",
X "*Mines: 26",
X "*cell.*.translations: #override \n\

X <Btn1Down> : MovePlayer() \n\
X <Btn2Down> : MarkMined() \n\

X <Btn3Down> : MarkSafe()",
X "*mineinputcount.accelerators: #override \n\
X <Key>R : set() notify() unset() \n\
X <Key>Return : set() notify() unset()",
X "*restart.accelerators: #override \n\
X <Key>R : set() notify() unset() \n\
X <Key>Return : set() notify() unset()",
X NULL
X};
X
X/* command line options */
Xstatic XrmOptionDescRec options[] = {
X {"-cellsize", "cellSize", XrmoptionSepArg, NULL },
X {"-rows", "rows", XrmoptionSepArg, NULL },
X {"-columns", "columns", XrmoptionSepArg, NULL },
X {"-mines", "mines", XrmoptionSepArg, NULL },
X};
X
X/* resource items that can be specified in the users resources database
X * (e.g. xmines*cellsize)
X */
Xstatic XtResource resources[] = {
X {"cellSize", "CellSize", XtRInt, sizeof(int),
X XtOffset(AppResourcesPtr,cellsize), XtRInt, (char *)0},
X {"rows", "ArraySize", XtRInt, sizeof(int),
X XtOffset(AppResourcesPtr,numrows), XtRInt, (char *)0},
X {"columns", "ArraySize", XtRInt, sizeof(int),
X XtOffset(AppResourcesPtr,numcols), XtRInt, (char *)0},
X {"mines", "Mines", XtRInt, sizeof(int),
X XtOffset(AppResourcesPtr,minecount), XtRInt, (char *)0},
X};
X
X
Xvoid usage()
X{
Xfprintf(stderr,"usage: %s\n",Progname);
Xfprintf(stderr,
X " [-cellsize]");
Xexit(1);
X}
X
Xvoid main(argc, argv)
Xint argc;
Xchar *argv[];
X{
X char host[256];
X Widget top;
X Arg arg;
X int i,n;
X Display *dpy;
X XrmDatabase rmdb;
X
X Progname = rindex(argv[0],'/');
X if (Progname) Progname++;
X else Progname=argv[0];
X
X#if 0
X/* If I call these functions instead of XtInitialize, I get error messages
X * about not having a type converter registered for String to Orientation.
X */
X XtToolkitInitialize();
X appctx = XtCreateApplicationContext();
X XtAppSetFallbackResources(appctx,fallback_resources);
X dpy = XtOpenDisplay(appctx,NULL,Progname,"XMines",
X options,XtNumber(options),&argc,argv);
X top = XtAppCreateShell(Progname,"XMines",
X applicationShellWidgetClass,dpy,NULL,0);
X if (argc != 1) usage();
X#else
X#if 0
X top = XtInitialize(Progname,"XMines",options,XtNumber(options),
X &argc,argv);
X appctx = XtWidgetToApplicationContext(top);
X XtAppSetFallbackResources(appctx,fallback_resources);
X dpy = XtDisplay(top);
X#else
X top = XtAppInitialize(&appctx,"XMines",options,XtNumber(options),
X &argc,argv,fallback_resources,NULL,0);
X dpy = XtDisplay(top);
X#endif
X#endif
X InitActions(appctx);
X
X XtGetApplicationResources(top,&Adata,resources,XtNumber(resources),
X NULL,0);
X if (Adata.cellsize==0)
X Adata.cellsize = 32;
X
X if (Adata.numrows==0)
X Adata.numrows = DEFAULT_BOARD_ROWS;
X if (Adata.numcols==0)
X Adata.numcols = DEFAULT_BOARD_COLS;
X
X AllocBoard(Adata.numrows,Adata.numcols,Adata.minecount);
X
X makeform(top,Adata.numrows,Adata.numcols,Adata.cellsize);
X XtRealizeWidget(top);
X InitBitmaps(dpy,XtWindow(top));
X InitBoard(0);
X XtAppMainLoop(appctx);
X /* NOTREACHED */
X}
X
X/* end */
END_OF_main.c
if test 5104 -ne `wc -c <main.c`; then
echo shar: \"main.c\" unpacked with wrong size!

fi
# end of overwriting check
fi

if test -f makeform.c -a "${1}" != "-c" ; then
echo shar: Will not over-write existing file \"makeform.c\"
else
echo shar: Extracting \"makeform.c\" $3274 characters$
sed "s/^X//" >makeform.c <<'END_OF_makeform.c'
X/*
X * Copyright 1990 Globetrotter Software, Inc.
X *
X * Permission to use, copy, modify, distribute, and sell this software and its
X * documentation for any purpose is hereby granted without fee, provided that
X * the above copyright notice appear in all copies and that both that
X * copyright notice and this permission notice appear in supporting
X * documentation, and that the name of Globetrotter Software not be used
X * in advertising or publicity pertaining to distribution of the software
X * without specific, written prior permission. Globetrotter Software makes
X * no representations about the suitability of this software for any purpose.
X * It is provided "as is" without express or implied warranty.
X *
X * GLOBETROTTER SOFTWARE DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
X * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO
X * EVENT SHALL GLOBETROTTER SOFTWARE BE LIABLE FOR ANY SPECIAL, INDIRECT OR
X * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
X * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
X * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
X * OF THIS SOFTWARE.
X *
X * Author: Jim McBeath, Globetrotter Software
X * globes!ji...@oliveb.olivetti.com
X * (408)741-0489
X */
X
X/* makeform.c - builds the form which displays everything
X */
X
X#include <X11/Intrinsic.h>
X#include <X11/Xatom.h>
X#include <X11/StringDefs.h>
X#include <X11/Core.h>
X#include <X11/Shell.h>
X#include <X11/Xaw/Form.h>
X#include <X11/Xaw/Label.h>
X#include <X11/Xaw/Command.h>
X#include <stdio.h>
X#include <ctype.h>
X#include "mines.h"
X
Xextern char *MinesVersion;
X
Xvoid
Xmakeform(topw,numrows,numcols,cellsize)
XWidget topw;
Xint numrows, numcols;
Xint cellsize; /* size of each cell in pixels */
X{
X Widget form, cells;
X Widget top, bottom, bar;
X Widget lasthwidget, lastvwidget, w;
X Widget InitButtons(), InitMsg();
X Arg args[10];
X int i, b;
X int x,y;
X char buf[100],buf2[100],tbuf[100];
X XtTranslations tr;
X
X i = 0;
X form = XtCreateManagedWidget("form", formWidgetClass, topw, args, i);
X
X i = 0;
X XtSetArg(args[i],XtNlabel,MinesVersion);
X i++;
X lastvwidget = XtCreateManagedWidget("title",
X labelWidgetClass, form, args, i);
X
X InitInfoButton(topw,form,lastvwidget);
X
X lastvwidget = InitButtons(form,lastvwidget);
X /* init command buttons */
X
X lastvwidget = InitMsg(form,lastvwidget);
X /* init the message area */
X
X i = 0;
X XtSetArg(args[i],XtNfromVert,lastvwidget);
X i++;
X cells = XtCreateManagedWidget("cell",formWidgetClass,form,args,i);
X lastvwidget = 0;
X
X for (y=0; y<numrows; y++) {
X lasthwidget = (Widget)0;
X for (x=0; x<numcols; x++) {
X sprintf(buf,"R%dC%d",y,x);
X i = 0;
X XtSetArg(args[i],XtNfromVert,lastvwidget);
X i++;
X XtSetArg(args[i],XtNfromHoriz,lasthwidget);
X i++;
X XtSetArg(args[i],XtNwidth,cellsize);
X i++;
X XtSetArg(args[i],XtNheight,cellsize);
X i++;
X XtSetArg(args[i],XtNinput,TRUE);
X i++;
X w = XtCreateManagedWidget(buf,widgetClass,cells,args,i);
X /* just use a core widget */
X sprintf(tbuf,"<Expose> : DrawCell(%d %d)",
X y,x);
X tr = XtParseTranslationTable(tbuf);
X XtOverrideTranslations(w,tr); /* add the expose tr */
X lasthwidget = w;
X SetCellWidget(y,x,w);
X }
X lastvwidget = w;
X }
X}
X
X/* end */
END_OF_makeform.c
if test 3274 -ne `wc -c <makeform.c`; then
echo shar: \"makeform.c\" unpacked with wrong size!

fi
# end of overwriting check
fi

if test -f msg.c -a "${1}" != "-c" ; then
echo shar: Will not over-write existing file \"msg.c\"
else
echo shar: Extracting \"msg.c\" $4388 characters$
sed "s/^X//" >msg.c <<'END_OF_msg.c'
X/*
X * Copyright 1990 Globetrotter Software, Inc.
X *
X * Permission to use, copy, modify, distribute, and sell this software and its
X * documentation for any purpose is hereby granted without fee, provided that
X * the above copyright notice appear in all copies and that both that
X * copyright notice and this permission notice appear in supporting
X * documentation, and that the name of Globetrotter Software not be used
X * in advertising or publicity pertaining to distribution of the software
X * without specific, written prior permission. Globetrotter Software makes
X * no representations about the suitability of this software for any purpose.
X * It is provided "as is" without express or implied warranty.
X *
X * GLOBETROTTER SOFTWARE DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
X * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO
X * EVENT SHALL GLOBETROTTER SOFTWARE BE LIABLE FOR ANY SPECIAL, INDIRECT OR
X * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
X * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
X * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
X * OF THIS SOFTWARE.
X *
X * Author: Jim McBeath, Globetrotter Software
X * globes!ji...@oliveb.olivetti.com
X * (408)741-0489
X */
X
X/* msg.c - deals with the message window
X */
X
X#include <X11/Intrinsic.h>
X#include <X11/StringDefs.h>
X#include <X11/Xaw/Form.h>
X#include <X11/Xaw/Label.h>
X#include "mines.h"
X
Xextern BOOL Impossible;
Xextern int Hints;
X
Xint NumberMoves;
Xint SafesMarked;
Xint MinesMarked;
Xint Hints;
X
Xstatic char *lastmessage;
Xstatic char *firstmessage="Welcome to XMines";
X
XWidget MsgWidget;
XWidget MoveCountWidget, HintCountWidget;
XWidget SafeCountWidget, MineCountWidget;
X
Xstatic Widget
XMakeCountWidget(name,parent,above,left)
Xchar *name;
XWidget parent;
XWidget above, left;
X{
X int i;
X Arg args[10];
X char namebuf[50];
X Widget lasthwidget;
X
X i = 0;
X XtSetArg(args[i],XtNfromVert,above);
X i++;
X if (left) {
X XtSetArg(args[i],XtNfromHoriz,left);
X i++;
X }
X sprintf(namebuf,"%slabel",name);
X lasthwidget = XtCreateManagedWidget(namebuf,
X labelWidgetClass, parent, args, i);
X
X i = 0;
X XtSetArg(args[i],XtNfromVert,above);
X i++;
X XtSetArg(args[i],XtNfromHoriz,lasthwidget);
X i++;
X sprintf(namebuf,"%scount",name);
X lasthwidget = XtCreateManagedWidget(namebuf,
X labelWidgetClass, parent, args, i);
X return lasthwidget;
X}
X
XWidget
XInitMsg(parent,above)
XWidget parent;
XWidget above;
X{
X int i;
X Arg args[10];
X Widget lasthwidget;
X
X lasthwidget = (Widget)0;
X
X#ifndef NOSCORE
X MoveCountWidget = lasthwidget =
X MakeCountWidget("move",parent,above,lasthwidget);
X HintCountWidget = lasthwidget =
X MakeCountWidget("hint",parent,above,lasthwidget);
X SafeCountWidget = lasthwidget =
X MakeCountWidget("safe",parent,above,lasthwidget);
X MineCountWidget = lasthwidget =
X MakeCountWidget("mine",parent,above,lasthwidget);
X above = lasthwidget;
X#endif
X
X i = 0;
X XtSetArg(args[i],XtNstring,firstmessage);
X i++;
X XtSetArg(args[i],XtNfromVert,above);
X i++;
X MsgWidget = XtCreateManagedWidget("message", labelWidgetClass,
X parent, args, i);
X if (lastmessage) {
X i=0;
X XtSetArg(args[0],XtNlabel,lastmessage);
X i++;
X XtSetValues(MsgWidget,args,1);
X }
X return MsgWidget;
X};
X
Xstatic void
XSetCountWidget(w,n)
XWidget w;
Xint n;
X{
X Arg arg;
X char buf[10];
X
X if (!w)
X return;
X sprintf(buf,"%d ",n);
X XtSetArg(arg,XtNlabel,buf);
X XtSetValues(w,&arg,1);
X}
X
X#ifndef NOSCORE
XSetNumberMoves(n)
Xint n;
X{
X NumberMoves = n;
X SetCountWidget(MoveCountWidget,n);
X}
X
XSetMinesMarked(n)
Xint n;
X{
X MinesMarked = n;
X SetCountWidget(MineCountWidget,n);
X}
X
XSetSafesMarked(n)
Xint n;
X{
X SafesMarked = n;
X SetCountWidget(SafeCountWidget,n);
X}
X
XSetHints(n)
Xint n;
X{
X Hints = n;
X SetCountWidget(HintCountWidget,n);
X}
X
XIncrNumberMoves(n)
Xint n;
X{
X if (n==0) return;
X SetNumberMoves(NumberMoves+n);
X}
X
XIncrMinesMarked(n)
Xint n;
X{
X if (n==0) return;
X SetMinesMarked(MinesMarked+n);
X}
X
XIncrSafesMarked(n)
Xint n;
X{
X if (n==0) return;
X SetSafesMarked(SafesMarked+n);
X}
X
XIncrHints(n)
Xint n;
X{
X if (n==0) return;
X SetHints(Hints+n);
X}
X#endif NOSCORE
X
Xvoid
XMessage(cp)
Xchar * cp;
X{
X Arg arg;
X static char full_message[100];
X
X sprintf(full_message, "%s %s",
X cp,
X Impossible ? "(impossible)" : "");
X
X lastmessage = full_message;
X if (MsgWidget) {
X XtSetArg(arg,XtNlabel,full_message);
X XtSetValues(MsgWidget,&arg,1);
X }
X}
X
X/* end */
END_OF_msg.c
if test 4388 -ne `wc -c <msg.c`; then
echo shar: \"msg.c\" unpacked with wrong size!

fi
# end of overwriting check
fi

echo shar: End of archive 2 $of 3$.
cp /dev/null ark2isdone

Jim McBeath

unread,

Sep 12, 1990, 4:26:05 AM9/12/90

Submitted-by: uunet!globes!ji...@uunet.UU.NET (Jim McBeath)
Posting-number: Volume 9, Issue 29
Archive-name: xmines/part03

# "End of archive 3 (of 3)."
# Contents: bMine.xbm bMineSm.xbm bSafe.xbm bSafeSm.xbm e0.xbm
# e0Sm.xbm e1.xbm e1Sm.xbm e2.xbm e2Sm.xbm e3.xbm e3Sm.xbm e4.xbm
# e4Sm.xbm e5.xbm e5Sm.xbm e6.xbm e6Sm.xbm e7.xbm e7Sm.xbm e8.xbm
# e8Sm.xbm hMine.xbm hMineSm.xbm mine.xbm mineSm.xbm pl0.xbm
# pl0Sm.xbm pl1.xbm pl1Sm.xbm pl2.xbm pl2Sm.xbm pl3.xbm pl3Sm.xbm
# pl4.xbm pl4Sm.xbm pl5.xbm pl5Sm.xbm pl6.xbm pl6Sm.xbm pl7.xbm
# pl7Sm.xbm pl8.xbm pl8Sm.xbm safe.xbm safeSm.xbm
# Wrapped by jimmc@ss on Mon Sep 10 09:43:11 1990

PATH=/bin:/usr/bin:/usr/ucb ; export PATH

if test -f bMine.xbm -a "${1}" != "-c" ; then
echo shar: Will not over-write existing file \"bMine.xbm\"
else
echo shar: Extracting \"bMine.xbm\" $741 characters$
sed "s/^X//" >bMine.xbm <<'END_OF_bMine.xbm'
X#define badmine_width 32
X#define badmine_height 32
Xstatic char badmine_bits[] = {
X 0x00,0x00,0x00,0x00,0xf8,0xff,0xff,0x1f,0xf0,0xff,0xff,0x0f,0xe2,0xff,0xff,
X 0x47,0x46,0xfe,0xff,0x63,0x0e,0xfd,0xff,0x71,0x1e,0xcf,0xff,0x78,0x3a,0xda,
X 0x7f,0x7c,0x46,0xf4,0x3f,0x7e,0x5e,0xf8,0x1f,0x7f,0x7e,0xf9,0x8f,0x7f,0x7e,
X 0xff,0xcf,0x7f,0xfa,0x38,0xf8,0x7f,0xc6,0x10,0xe0,0x7f,0xfe,0x20,0xc0,0x7f,
X 0xfe,0x21,0x80,0x7f,0xfe,0x23,0x00,0x7f,0xfe,0x1d,0x00,0x7f,0xfe,0x00,0x00,
X 0x7e,0xfe,0x00,0x00,0x7e,0xfe,0x00,0x00,0x7e,0xfe,0x00,0x00,0x7e,0xfe,0x00,
X 0x00,0x7e,0xfe,0x01,0x00,0x7f,0x3e,0x01,0x00,0x7f,0x1e,0x03,0x80,0x79,0x8e,
X 0x07,0xc0,0x71,0xc6,0x0f,0xe0,0x63,0xe2,0x3f,0xf8,0x47,0xf0,0xff,0xff,0x0f,
X 0xf8,0xff,0xff,0x1f,0x00,0x00,0x00,0x00};
END_OF_bMine.xbm
if test 741 -ne `wc -c <bMine.xbm`; then
echo shar: \"bMine.xbm\" unpacked with wrong size!

fi
# end of overwriting check
fi

if test -f bMineSm.xbm -a "${1}" != "-c" ; then
echo shar: Will not over-write existing file \"bMineSm.xbm\"
else
echo shar: Extracting \"bMineSm.xbm\" $359 characters$
sed "s/^X//" >bMineSm.xbm <<'END_OF_bMineSm.xbm'
X#define badmineSmall_width 16
X#define badmineSmall_height 16
X#define badmineSmall_x_hot -1
X#define badmineSmall_y_hot -1
Xstatic char badmineSmall_bits[] = {
X 0x00, 0x00, 0x7e, 0x7f, 0xb2, 0x5f, 0xf6, 0x6d, 0xce, 0x76, 0xd2, 0x7b,
X 0xbe, 0x7b, 0x36, 0x7c, 0x3a, 0x78, 0x1e, 0x70, 0x1e, 0x70, 0x0e, 0x70,
X 0x36, 0x68, 0x7a, 0x5c, 0xfe, 0x7f, 0x00, 0x00};
END_OF_bMineSm.xbm
if test 359 -ne `wc -c <bMineSm.xbm`; then
echo shar: \"bMineSm.xbm\" unpacked with wrong size!

fi
# end of overwriting check
fi

if test -f bSafe.xbm -a "${1}" != "-c" ; then
echo shar: Will not over-write existing file \"bSafe.xbm\"
else
echo shar: Extracting \"bSafe.xbm\" $741 characters$
sed "s/^X//" >bSafe.xbm <<'END_OF_bSafe.xbm'
X#define badsafe_width 32
X#define badsafe_height 32
Xstatic char badsafe_bits[] = {
X 0x00,0x00,0x00,0x00,0xf8,0xff,0xff,0x1f,0xf0,0xff,0xff,0x0f,0xe2,0xff,0xff,
X 0x47,0xc6,0xff,0xff,0x63,0x8e,0xff,0xff,0x71,0x1e,0xff,0xff,0x78,0x3e,0xfe,
X 0x7f,0x7c,0x7e,0xfc,0x3f,0x7e,0xfe,0xf8,0x1f,0x7f,0xfe,0xf1,0x8f,0x7f,0xfe,
X 0xf3,0xcd,0x7f,0xfe,0xff,0xfd,0x7f,0xfe,0xc7,0xed,0x7f,0xfe,0xbb,0xf5,0x7f,
X 0xfe,0xbb,0xf9,0x7f,0xfe,0xbb,0xf9,0x7f,0xfe,0xbb,0xf5,0x7f,0xfe,0xbb,0xed,
X 0x7f,0xfe,0xc7,0xdd,0x7f,0xfe,0xff,0xff,0x7f,0xfe,0xf9,0x9f,0x7f,0xfe,0xf8,
X 0x1f,0x7f,0x7e,0xfc,0x3f,0x7e,0x3e,0xfe,0x7f,0x7c,0x1e,0xff,0xff,0x78,0x8e,
X 0xff,0xff,0x71,0xc6,0xff,0xff,0x63,0xe2,0xff,0xff,0x47,0xf0,0xff,0xff,0x0f,
X 0xf8,0xff,0xff,0x1f,0x00,0x00,0x00,0x00};
END_OF_bSafe.xbm
if test 741 -ne `wc -c <bSafe.xbm`; then
echo shar: \"bSafe.xbm\" unpacked with wrong size!

fi
# end of overwriting check
fi

if test -f bSafeSm.xbm -a "${1}" != "-c" ; then
echo shar: Will not over-write existing file \"bSafeSm.xbm\"
else
echo shar: Extracting \"bSafeSm.xbm\" $359 characters$
sed "s/^X//" >bSafeSm.xbm <<'END_OF_bSafeSm.xbm'
X#define badsafeSmall_width 16
X#define badsafeSmall_height 16
X#define badsafeSmall_x_hot -1
X#define badsafeSmall_y_hot -1
Xstatic char badsafeSmall_bits[] = {
X 0x00, 0x00, 0xfe, 0x7f, 0xfa, 0x5f, 0xf6, 0x6f, 0xee, 0x47, 0xde, 0x43,
X 0xbe, 0x41, 0x7e, 0x70, 0x7e, 0x79, 0xa6, 0x7c, 0x4e, 0x7a, 0x1e, 0x77,
X 0xb6, 0x6f, 0xba, 0x5f, 0xfe, 0x7f, 0x00, 0x00};
END_OF_bSafeSm.xbm
if test 359 -ne `wc -c <bSafeSm.xbm`; then
echo shar: \"bSafeSm.xbm\" unpacked with wrong size!

fi
# end of overwriting check
fi

if test -f e0.xbm -a "${1}" != "-c" ; then
echo shar: Will not over-write existing file \"e0.xbm\"
else
echo shar: Extracting \"e0.xbm\" $732 characters$
sed "s/^X//" >e0.xbm <<'END_OF_e0.xbm'
X#define zero_width 32
X#define zero_height 32
Xstatic char zero_bits[] = {
X 0xff,0xff,0xff,0xff,0x01,0x00,0x00,0x80,0x55,0x55,0x55,0x95,0xa9,0xaa,0xaa,
X 0xaa,0x55,0x55,0x55,0x95,0xa9,0xaa,0xaa,0xaa,0x55,0x55,0x55,0x95,0xa9,0xaa,
X 0xaa,0xaa,0x55,0x55,0x55,0x95,0xa9,0xaa,0xaa,0xaa,0x55,0x01,0x40,0x95,0xa9,
X 0x82,0x83,0xaa,0x55,0x41,0x44,0x95,0xa9,0x42,0x84,0xaa,0x55,0x41,0x46,0x95,
X 0xa9,0x42,0x85,0xaa,0x55,0xc1,0x44,0x95,0xa9,0x42,0x84,0xaa,0x55,0x41,0x44,
X 0x95,0xa9,0x82,0x83,0xaa,0x55,0x01,0x40,0x95,0xa9,0x02,0x80,0xaa,0x55,0x55,
X 0x55,0x95,0xa9,0xaa,0xaa,0xaa,0x55,0x55,0x55,0x95,0xa9,0xaa,0xaa,0xaa,0x55,
X 0x55,0x55,0x95,0xa9,0xaa,0xaa,0xaa,0x55,0x55,0x55,0x95,0xa9,0xaa,0xaa,0xaa,
X 0x01,0x00,0x00,0x80,0xff,0xff,0xff,0xff};
END_OF_e0.xbm
if test 732 -ne `wc -c <e0.xbm`; then
echo shar: \"e0.xbm\" unpacked with wrong size!

fi
# end of overwriting check
fi

if test -f e0Sm.xbm -a "${1}" != "-c" ; then
echo shar: Will not over-write existing file \"e0Sm.xbm\"
else
echo shar: Extracting \"e0Sm.xbm\" $344 characters$
sed "s/^X//" >e0Sm.xbm <<'END_OF_e0Sm.xbm'
X#define zeroSmall_width 16
X#define zeroSmall_height 16
X#define zeroSmall_x_hot -1
X#define zeroSmall_y_hot -1
Xstatic char zeroSmall_bits[] = {
X 0xff, 0xff, 0x01, 0x80, 0x55, 0x95, 0xa9, 0xaa, 0x05, 0x90, 0x89, 0xa1,
X 0x45, 0x92, 0x49, 0xa2, 0x45, 0x92, 0x49, 0xa2, 0x85, 0x91, 0x09, 0xa0,
X 0x55, 0x95, 0xa9, 0xaa, 0x01, 0x80, 0xff, 0xff};
END_OF_e0Sm.xbm
if test 344 -ne `wc -c <e0Sm.xbm`; then
echo shar: \"e0Sm.xbm\" unpacked with wrong size!

fi
# end of overwriting check
fi

if test -f e1.xbm -a "${1}" != "-c" ; then
echo shar: Will not over-write existing file \"e1.xbm\"
else
echo shar: Extracting \"e1.xbm\" $729 characters$
sed "s/^X//" >e1.xbm <<'END_OF_e1.xbm'
X#define one_width 32
X#define one_height 32
Xstatic char one_bits[] = {
X 0xff,0xff,0xff,0xff,0x01,0x00,0x00,0x80,0x55,0x55,0x55,0x95,0xa9,0xaa,0xaa,
X 0xaa,0x55,0x55,0x55,0x95,0xa9,0xaa,0xaa,0xaa,0x55,0x55,0x55,0x95,0xa9,0xaa,
X 0xaa,0xaa,0x55,0x55,0x55,0x95,0xa9,0xaa,0xaa,0xaa,0x55,0x01,0x40,0x95,0xa9,
X 0x82,0xa0,0xaa,0x55,0xc1,0x40,0x95,0xa9,0xa2,0xa0,0xaa,0x55,0x81,0x40,0x95,
X 0xa9,0x82,0xa0,0xaa,0x55,0x81,0x40,0x95,0xa9,0x82,0xa0,0xaa,0x55,0x81,0x40,
X 0x95,0xa9,0xe2,0xa3,0xaa,0x55,0x01,0x40,0x95,0xa9,0xaa,0xaa,0xaa,0x55,0x55,
X 0x55,0x95,0xa9,0xaa,0xaa,0xaa,0x55,0x55,0x55,0x95,0xa9,0xaa,0xaa,0xaa,0x55,
X 0x55,0x55,0x95,0xa9,0xaa,0xaa,0xaa,0x55,0x55,0x55,0x95,0xa9,0xaa,0xaa,0xaa,
X 0x01,0x00,0x00,0x80,0xff,0xff,0xff,0xff};
END_OF_e1.xbm
if test 729 -ne `wc -c <e1.xbm`; then
echo shar: \"e1.xbm\" unpacked with wrong size!

fi
# end of overwriting check
fi

if test -f e1Sm.xbm -a "${1}" != "-c" ; then
echo shar: Will not over-write existing file \"e1Sm.xbm\"
else
echo shar: Extracting \"e1Sm.xbm\" $339 characters$
sed "s/^X//" >e1Sm.xbm <<'END_OF_e1Sm.xbm'
X#define oneSmall_width 16
X#define oneSmall_height 16
X#define oneSmall_x_hot -1
X#define oneSmall_y_hot -1
Xstatic char oneSmall_bits[] = {
X 0xff, 0xff, 0x01, 0x80, 0x55, 0x95, 0xa9, 0xaa, 0x05, 0x90, 0x09, 0xa1,
X 0x05, 0x91, 0x09, 0xa1, 0x05, 0x91, 0x09, 0xa1, 0x05, 0x91, 0x09, 0xa0,
X 0x55, 0x95, 0xa9, 0xaa, 0x01, 0x80, 0xff, 0xff};
END_OF_e1Sm.xbm
if test 339 -ne `wc -c <e1Sm.xbm`; then
echo shar: \"e1Sm.xbm\" unpacked with wrong size!

fi
# end of overwriting check
fi

if test -f e2.xbm -a "${1}" != "-c" ; then
echo shar: Will not over-write existing file \"e2.xbm\"
else
echo shar: Extracting \"e2.xbm\" $729 characters$
sed "s/^X//" >e2.xbm <<'END_OF_e2.xbm'
X#define two_width 32
X#define two_height 32
Xstatic char two_bits[] = {
X 0xff,0xff,0xff,0xff,0x01,0x00,0x00,0x80,0x55,0x55,0x55,0x95,0xa9,0xaa,0xaa,
X 0xaa,0x55,0x55,0x55,0x95,0xa9,0xaa,0xaa,0xaa,0x55,0x55,0x55,0x95,0xa9,0xaa,
X 0xaa,0xaa,0x55,0x55,0x55,0x95,0xa9,0xaa,0xaa,0xaa,0x55,0x01,0x40,0x95,0xa9,
X 0xc2,0xa1,0xaa,0x55,0x21,0x42,0x95,0xa9,0x02,0xa2,0xaa,0x55,0x01,0x42,0x95,
X 0xa9,0x02,0xa1,0xaa,0x55,0x81,0x40,0x95,0xa9,0x42,0xa0,0xaa,0x55,0x21,0x40,
X 0x95,0xa9,0xe2,0xa3,0xaa,0x55,0x01,0x40,0x95,0xa9,0xaa,0xaa,0xaa,0x55,0x55,
X 0x55,0x95,0xa9,0xaa,0xaa,0xaa,0x55,0x55,0x55,0x95,0xa9,0xaa,0xaa,0xaa,0x55,
X 0x55,0x55,0x95,0xa9,0xaa,0xaa,0xaa,0x55,0x55,0x55,0x95,0xa9,0xaa,0xaa,0xaa,
X 0x01,0x00,0x00,0x80,0xff,0xff,0xff,0xff};
END_OF_e2.xbm
if test 729 -ne `wc -c <e2.xbm`; then
echo shar: \"e2.xbm\" unpacked with wrong size!

fi
# end of overwriting check
fi

if test -f e2Sm.xbm -a "${1}" != "-c" ; then
echo shar: Will not over-write existing file \"e2Sm.xbm\"
else
echo shar: Extracting \"e2Sm.xbm\" $339 characters$
sed "s/^X//" >e2Sm.xbm <<'END_OF_e2Sm.xbm'
X#define twoSmall_width 16
X#define twoSmall_height 16
X#define twoSmall_x_hot -1
X#define twoSmall_y_hot -1
Xstatic char twoSmall_bits[] = {
X 0xff, 0xff, 0x01, 0x80, 0x55, 0x95, 0xa9, 0xaa, 0x05, 0x90, 0x89, 0xa1,
X 0x45, 0x92, 0x09, 0xa1, 0x85, 0x90, 0x49, 0xa0, 0xc5, 0x93, 0x09, 0xa0,
X 0x55, 0x95, 0xa9, 0xaa, 0x01, 0x80, 0xff, 0xff};
END_OF_e2Sm.xbm
if test 339 -ne `wc -c <e2Sm.xbm`; then
echo shar: \"e2Sm.xbm\" unpacked with wrong size!

fi
# end of overwriting check
fi

if test -f e3.xbm -a "${1}" != "-c" ; then
echo shar: Will not over-write existing file \"e3.xbm\"
else
echo shar: Extracting \"e3.xbm\" $735 characters$
sed "s/^X//" >e3.xbm <<'END_OF_e3.xbm'
X#define three_width 32
X#define three_height 32
Xstatic char three_bits[] = {
X 0xff,0xff,0xff,0xff,0x01,0x00,0x00,0x80,0x55,0x55,0x55,0x95,0xa9,0xaa,0xaa,
X 0xaa,0x55,0x55,0x55,0x95,0xa9,0xaa,0xaa,0xaa,0x55,0x55,0x55,0x95,0xa9,0xaa,
X 0xaa,0xaa,0x55,0x55,0x55,0x95,0xa9,0xaa,0xaa,0xaa,0x55,0x01,0x40,0x95,0xa9,
X 0xc2,0xa1,0xaa,0x55,0x21,0x42,0x95,0xa9,0x02,0xa2,0xaa,0x55,0x01,0x42,0x95,
X 0xa9,0x82,0xa1,0xaa,0x55,0x01,0x42,0x95,0xa9,0x02,0xa2,0xaa,0x55,0x21,0x42,
X 0x95,0xa9,0xc2,0xa1,0xaa,0x55,0x01,0x40,0x95,0xa9,0xaa,0xaa,0xaa,0x55,0x55,
X 0x55,0x95,0xa9,0xaa,0xaa,0xaa,0x55,0x55,0x55,0x95,0xa9,0xaa,0xaa,0xaa,0x55,
X 0x55,0x55,0x95,0xa9,0xaa,0xaa,0xaa,0x55,0x55,0x55,0x95,0xa9,0xaa,0xaa,0xaa,
X 0x01,0x00,0x00,0x80,0xff,0xff,0xff,0xff};
END_OF_e3.xbm
if test 735 -ne `wc -c <e3.xbm`; then
echo shar: \"e3.xbm\" unpacked with wrong size!

fi
# end of overwriting check
fi

if test -f e3Sm.xbm -a "${1}" != "-c" ; then
echo shar: Will not over-write existing file \"e3Sm.xbm\"
else
echo shar: Extracting \"e3Sm.xbm\" $349 characters$
sed "s/^X//" >e3Sm.xbm <<'END_OF_e3Sm.xbm'
X#define threeSmall_width 16
X#define threeSmall_height 16
X#define threeSmall_x_hot -1
X#define threeSmall_y_hot -1
Xstatic char threeSmall_bits[] = {
X 0xff, 0xff, 0x01, 0x80, 0x55, 0x95, 0xa9, 0xaa, 0x05, 0x90, 0xc9, 0xa3,
X 0x05, 0x92, 0xc9, 0xa3, 0x05, 0x92, 0x09, 0xa2, 0xc5, 0x93, 0x09, 0xa0,
X 0x55, 0x95, 0xa9, 0xaa, 0x01, 0x80, 0xff, 0xff};
END_OF_e3Sm.xbm
if test 349 -ne `wc -c <e3Sm.xbm`; then
echo shar: \"e3Sm.xbm\" unpacked with wrong size!

fi
# end of overwriting check
fi

if test -f e4.xbm -a "${1}" != "-c" ; then
echo shar: Will not over-write existing file \"e4.xbm\"
else
echo shar: Extracting \"e4.xbm\" $732 characters$
sed "s/^X//" >e4.xbm <<'END_OF_e4.xbm'
X#define four_width 32
X#define four_height 32
Xstatic char four_bits[] = {
X 0xff,0xff,0xff,0xff,0x01,0x00,0x00,0x80,0x55,0x55,0x55,0x95,0xa9,0xaa,0xaa,
X 0xaa,0x55,0x55,0x55,0x95,0xa9,0xaa,0xaa,0xaa,0x55,0x55,0x55,0x95,0xa9,0xaa,
X 0xaa,0xaa,0x55,0x55,0x55,0x95,0xa9,0xaa,0xaa,0xaa,0x55,0x01,0x40,0x95,0xa9,
X 0x02,0x82,0xaa,0x55,0x01,0x43,0x95,0xa9,0x82,0x82,0xaa,0x55,0x41,0x42,0x95,
X 0xa9,0x22,0x82,0xaa,0x55,0x21,0x42,0x95,0xa9,0xe2,0x87,0xaa,0x55,0x01,0x42,
X 0x95,0xa9,0x02,0x82,0xaa,0x55,0x01,0x40,0x95,0xa9,0xaa,0xaa,0xaa,0x55,0x55,
X 0x55,0x95,0xa9,0xaa,0xaa,0xaa,0x55,0x55,0x55,0x95,0xa9,0xaa,0xaa,0xaa,0x55,
X 0x55,0x55,0x95,0xa9,0xaa,0xaa,0xaa,0x55,0x55,0x55,0x95,0xa9,0xaa,0xaa,0xaa,
X 0x01,0x00,0x00,0x80,0xff,0xff,0xff,0xff};
END_OF_e4.xbm
if test 732 -ne `wc -c <e4.xbm`; then
echo shar: \"e4.xbm\" unpacked with wrong size!

fi
# end of overwriting check
fi

if test -f e4Sm.xbm -a "${1}" != "-c" ; then
echo shar: Will not over-write existing file \"e4Sm.xbm\"
else
echo shar: Extracting \"e4Sm.xbm\" $344 characters$
sed "s/^X//" >e4Sm.xbm <<'END_OF_e4Sm.xbm'
X#define fourSmall_width 16
X#define fourSmall_height 16
X#define fourSmall_x_hot -1
X#define fourSmall_y_hot -1
Xstatic char fourSmall_bits[] = {
X 0xff, 0xff, 0x01, 0x80, 0x55, 0x95, 0xa9, 0xaa, 0x05, 0x90, 0x49, 0xa2,
X 0x45, 0x92, 0x49, 0xa2, 0xc5, 0x93, 0x09, 0xa2, 0x05, 0x92, 0x09, 0xa0,
X 0x55, 0x95, 0xa9, 0xaa, 0x01, 0x80, 0xff, 0xff};
END_OF_e4Sm.xbm
if test 344 -ne `wc -c <e4Sm.xbm`; then
echo shar: \"e4Sm.xbm\" unpacked with wrong size!

fi
# end of overwriting check
fi

if test -f e5.xbm -a "${1}" != "-c" ; then
echo shar: Will not over-write existing file \"e5.xbm\"
else
echo shar: Extracting \"e5.xbm\" $732 characters$
sed "s/^X//" >e5.xbm <<'END_OF_e5.xbm'
X#define five_width 32
X#define five_height 32
Xstatic char five_bits[] = {
X 0xff,0xff,0xff,0xff,0x01,0x00,0x00,0x80,0x55,0x55,0x55,0x95,0xa9,0xaa,0xaa,
X 0xaa,0x55,0x55,0x55,0x95,0xa9,0xaa,0xaa,0xaa,0x55,0x55,0x55,0x95,0xa9,0xaa,
X 0xaa,0xaa,0x55,0x55,0x55,0x95,0xa9,0xaa,0xaa,0xaa,0x55,0x01,0x40,0x95,0xa9,
X 0xe2,0xa3,0xaa,0x55,0x21,0x40,0x95,0xa9,0x22,0xa0,0xaa,0x55,0xe1,0x41,0x95,
X 0xa9,0x02,0xa2,0xaa,0x55,0x01,0x42,0x95,0xa9,0x22,0xa2,0xaa,0x55,0x21,0x42,
X 0x95,0xa9,0xc2,0xa1,0xaa,0x55,0x01,0x40,0x95,0xa9,0xaa,0xaa,0xaa,0x55,0x55,
X 0x55,0x95,0xa9,0xaa,0xaa,0xaa,0x55,0x55,0x55,0x95,0xa9,0xaa,0xaa,0xaa,0x55,
X 0x55,0x55,0x95,0xa9,0xaa,0xaa,0xaa,0x55,0x55,0x55,0x95,0xa9,0xaa,0xaa,0xaa,
X 0x01,0x00,0x00,0x80,0xff,0xff,0xff,0xff};
END_OF_e5.xbm
if test 732 -ne `wc -c <e5.xbm`; then
echo shar: \"e5.xbm\" unpacked with wrong size!

fi
# end of overwriting check
fi

if test -f e5Sm.xbm -a "${1}" != "-c" ; then
echo shar: Will not over-write existing file \"e5Sm.xbm\"
else
echo shar: Extracting \"e5Sm.xbm\" $344 characters$
sed "s/^X//" >e5Sm.xbm <<'END_OF_e5Sm.xbm'
X#define fiveSmall_width 16
X#define fiveSmall_height 16
X#define fiveSmall_x_hot -1
X#define fiveSmall_y_hot -1
Xstatic char fiveSmall_bits[] = {
X 0xff, 0xff, 0x01, 0x80, 0x55, 0x95, 0xa9, 0xaa, 0x05, 0x90, 0xc9, 0xa3,
X 0x45, 0x90, 0xc9, 0xa1, 0x05, 0x92, 0x09, 0xa2, 0xc5, 0x91, 0x09, 0xa0,
X 0x55, 0x95, 0xa9, 0xaa, 0x01, 0x80, 0xff, 0xff};
END_OF_e5Sm.xbm
if test 344 -ne `wc -c <e5Sm.xbm`; then
echo shar: \"e5Sm.xbm\" unpacked with wrong size!

fi
# end of overwriting check
fi

if test -f e6.xbm -a "${1}" != "-c" ; then
echo shar: Will not over-write existing file \"e6.xbm\"
else
echo shar: Extracting \"e6.xbm\" $729 characters$
sed "s/^X//" >e6.xbm <<'END_OF_e6.xbm'
X#define six_width 32
X#define six_height 32
Xstatic char six_bits[] = {
X 0xff,0xff,0xff,0xff,0x01,0x00,0x00,0x80,0x55,0x55,0x55,0x95,0xa9,0xaa,0xaa,
X 0xaa,0x55,0x55,0x55,0x95,0xa9,0xaa,0xaa,0xaa,0x55,0x55,0x55,0x95,0xa9,0xaa,
X 0xaa,0xaa,0x55,0x55,0x55,0x95,0xa9,0xaa,0xaa,0xaa,0x55,0x01,0x40,0x95,0xa9,
X 0xc2,0xa1,0xaa,0x55,0x21,0x42,0x95,0xa9,0x22,0xa0,0xaa,0x55,0x21,0x40,0x95,
X 0xa9,0xe2,0xa1,0xaa,0x55,0x21,0x42,0x95,0xa9,0x22,0xa2,0xaa,0x55,0x21,0x42,
X 0x95,0xa9,0xc2,0xa1,0xaa,0x55,0x01,0x40,0x95,0xa9,0xaa,0xaa,0xaa,0x55,0x55,
X 0x55,0x95,0xa9,0xaa,0xaa,0xaa,0x55,0x55,0x55,0x95,0xa9,0xaa,0xaa,0xaa,0x55,
X 0x55,0x55,0x95,0xa9,0xaa,0xaa,0xaa,0x55,0x55,0x55,0x95,0xa9,0xaa,0xaa,0xaa,
X 0x01,0x00,0x00,0x80,0xff,0xff,0xff,0xff};
END_OF_e6.xbm
if test 729 -ne `wc -c <e6.xbm`; then
echo shar: \"e6.xbm\" unpacked with wrong size!

fi
# end of overwriting check
fi

if test -f e6Sm.xbm -a "${1}" != "-c" ; then
echo shar: Will not over-write existing file \"e6Sm.xbm\"
else
echo shar: Extracting \"e6Sm.xbm\" $339 characters$
sed "s/^X//" >e6Sm.xbm <<'END_OF_e6Sm.xbm'
X#define sixSmall_width 16
X#define sixSmall_height 16
X#define sixSmall_x_hot -1
X#define sixSmall_y_hot -1
Xstatic char sixSmall_bits[] = {
X 0xff, 0xff, 0x01, 0x80, 0x55, 0x95, 0xa9, 0xaa, 0x05, 0x90, 0x49, 0xa0,
X 0x45, 0x90, 0x49, 0xa0, 0xc5, 0x93, 0x49, 0xa2, 0xc5, 0x93, 0x09, 0xa0,
X 0x55, 0x95, 0xa9, 0xaa, 0x01, 0x80, 0xff, 0xff};
END_OF_e6Sm.xbm
if test 339 -ne `wc -c <e6Sm.xbm`; then
echo shar: \"e6Sm.xbm\" unpacked with wrong size!

fi
# end of overwriting check
fi

if test -f e7.xbm -a "${1}" != "-c" ; then
echo shar: Will not over-write existing file \"e7.xbm\"
else
echo shar: Extracting \"e7.xbm\" $735 characters$
sed "s/^X//" >e7.xbm <<'END_OF_e7.xbm'
X#define seven_width 32
X#define seven_height 32
Xstatic char seven_bits[] = {
X 0xff,0xff,0xff,0xff,0x01,0x00,0x00,0x80,0x55,0x55,0x55,0x95,0xa9,0xaa,0xaa,
X 0xaa,0x55,0x55,0x55,0x95,0xa9,0xaa,0xaa,0xaa,0x55,0x55,0x55,0x95,0xa9,0xaa,
X 0xaa,0xaa,0x55,0x55,0x55,0x95,0xa9,0xaa,0xaa,0xaa,0x55,0x01,0x40,0x95,0xa9,
X 0xe2,0xa3,0xaa,0x55,0x21,0x42,0x95,0xa9,0x02,0xa2,0xaa,0x55,0x01,0x41,0x95,
X 0xa9,0x02,0xa1,0xaa,0x55,0x01,0x41,0x95,0xa9,0x82,0xa0,0xaa,0x55,0x81,0x40,
X 0x95,0xa9,0x82,0xa0,0xaa,0x55,0x01,0x40,0x95,0xa9,0xaa,0xaa,0xaa,0x55,0x55,
X 0x55,0x95,0xa9,0xaa,0xaa,0xaa,0x55,0x55,0x55,0x95,0xa9,0xaa,0xaa,0xaa,0x55,
X 0x55,0x55,0x95,0xa9,0xaa,0xaa,0xaa,0x55,0x55,0x55,0x95,0xa9,0xaa,0xaa,0xaa,
X 0x01,0x00,0x00,0x80,0xff,0xff,0xff,0xff};
END_OF_e7.xbm
if test 735 -ne `wc -c <e7.xbm`; then
echo shar: \"e7.xbm\" unpacked with wrong size!

fi
# end of overwriting check
fi

if test -f e7Sm.xbm -a "${1}" != "-c" ; then
echo shar: Will not over-write existing file \"e7Sm.xbm\"
else
echo shar: Extracting \"e7Sm.xbm\" $349 characters$
sed "s/^X//" >e7Sm.xbm <<'END_OF_e7Sm.xbm'
X#define sevenSmall_width 16
X#define sevenSmall_height 16
X#define sevenSmall_x_hot -1
X#define sevenSmall_y_hot -1
Xstatic char sevenSmall_bits[] = {
X 0xff, 0xff, 0x01, 0x80, 0x55, 0x95, 0xa9, 0xaa, 0x05, 0x90, 0xc9, 0xa3,
X 0x05, 0x92, 0x09, 0xa1, 0x05, 0x91, 0x89, 0xa0, 0x85, 0x90, 0x09, 0xa0,
X 0x55, 0x95, 0xa9, 0xaa, 0x01, 0x80, 0xff, 0xff};
END_OF_e7Sm.xbm
if test 349 -ne `wc -c <e7Sm.xbm`; then
echo shar: \"e7Sm.xbm\" unpacked with wrong size!

fi
# end of overwriting check
fi

if test -f e8.xbm -a "${1}" != "-c" ; then
echo shar: Will not over-write existing file \"e8.xbm\"
else
echo shar: Extracting \"e8.xbm\" $735 characters$
sed "s/^X//" >e8.xbm <<'END_OF_e8.xbm'
X#define eight_width 32
X#define eight_height 32
Xstatic char eight_bits[] = {
X 0xff,0xff,0xff,0xff,0x01,0x00,0x00,0x80,0x55,0x55,0x55,0x95,0xa9,0xaa,0xaa,
X 0xaa,0x55,0x55,0x55,0x95,0xa9,0xaa,0xaa,0xaa,0x55,0x55,0x55,0x95,0xa9,0xaa,
X 0xaa,0xaa,0x55,0x55,0x55,0x95,0xa9,0xaa,0xaa,0xaa,0x55,0x01,0x40,0x95,0xa9,
X 0xc2,0xa1,0xaa,0x55,0x21,0x42,0x95,0xa9,0x22,0xa2,0xaa,0x55,0x21,0x42,0x95,
X 0xa9,0xc2,0xa1,0xaa,0x55,0x21,0x42,0x95,0xa9,0x22,0xa2,0xaa,0x55,0x21,0x42,
X 0x95,0xa9,0xc2,0xa1,0xaa,0x55,0x01,0x40,0x95,0xa9,0xaa,0xaa,0xaa,0x55,0x55,
X 0x55,0x95,0xa9,0xaa,0xaa,0xaa,0x55,0x55,0x55,0x95,0xa9,0xaa,0xaa,0xaa,0x55,
X 0x55,0x55,0x95,0xa9,0xaa,0xaa,0xaa,0x55,0x55,0x55,0x95,0xa9,0xaa,0xaa,0xaa,
X 0x01,0x00,0x00,0x80,0xff,0xff,0xff,0xff};
END_OF_e8.xbm
if test 735 -ne `wc -c <e8.xbm`; then
echo shar: \"e8.xbm\" unpacked with wrong size!

fi
# end of overwriting check
fi

if test -f e8Sm.xbm -a "${1}" != "-c" ; then
echo shar: Will not over-write existing file \"e8Sm.xbm\"
else
echo shar: Extracting \"e8Sm.xbm\" $349 characters$
sed "s/^X//" >e8Sm.xbm <<'END_OF_e8Sm.xbm'
X#define eightSmall_width 16
X#define eightSmall_height 16
X#define eightSmall_x_hot -1
X#define eightSmall_y_hot -1
Xstatic char eightSmall_bits[] = {
X 0xff, 0xff, 0x01, 0x80, 0x55, 0x95, 0xa9, 0xaa, 0x05, 0x90, 0x89, 0xa1,
X 0x45, 0x92, 0x89, 0xa1, 0x45, 0x92, 0x49, 0xa2, 0x85, 0x91, 0x09, 0xa0,
X 0x55, 0x95, 0xa9, 0xaa, 0x01, 0x80, 0xff, 0xff};
END_OF_e8Sm.xbm
if test 349 -ne `wc -c <e8Sm.xbm`; then
echo shar: \"e8Sm.xbm\" unpacked with wrong size!

fi
# end of overwriting check
fi

if test -f hMine.xbm -a "${1}" != "-c" ; then
echo shar: Will not over-write existing file \"hMine.xbm\"
else
echo shar: Extracting \"hMine.xbm\" $750 characters$
sed "s/^X//" >hMine.xbm <<'END_OF_hMine.xbm'
X#define hiddenmine_width 32
X#define hiddenmine_height 32
Xstatic char hiddenmine_bits[] = {
X 0xff,0xff,0xff,0xff,0x01,0x00,0x00,0x80,0x01,0x00,0x00,0x80,0x01,0x00,0x00,
X 0x80,0x81,0x01,0x00,0x80,0xa1,0x02,0x00,0x80,0x21,0x30,0x00,0x80,0x05,0x24,
X 0x00,0x80,0x39,0x09,0x00,0x80,0xa1,0x00,0x00,0x80,0x81,0x00,0x00,0x80,0x81,
X 0x00,0x00,0x80,0x05,0xc7,0x07,0x80,0x39,0xef,0x1f,0x80,0x01,0xdf,0x3f,0x80,
X 0x01,0xde,0x7f,0x80,0x01,0xdc,0xff,0x80,0x01,0x62,0xfc,0x80,0x01,0x3f,0xf8,
X 0x81,0x01,0x1f,0xf0,0x81,0x01,0x0f,0xe0,0x81,0x01,0x0f,0xe0,0x81,0x01,0x0f,
X 0xe0,0x81,0x01,0x1e,0xf0,0x80,0x01,0x3e,0xf8,0x80,0x01,0x7c,0x7c,0x80,0x01,
X 0xf8,0x3f,0x80,0x01,0xf0,0x1f,0x80,0x01,0xc0,0x07,0x80,0x01,0x00,0x00,0x80,
X 0x01,0x00,0x00,0x80,0xff,0xff,0xff,0xff};
END_OF_hMine.xbm
if test 750 -ne `wc -c <hMine.xbm`; then
echo shar: \"hMine.xbm\" unpacked with wrong size!

fi
# end of overwriting check
fi

if test -f hMineSm.xbm -a "${1}" != "-c" ; then
echo shar: Will not over-write existing file \"hMineSm.xbm\"
else
echo shar: Extracting \"hMineSm.xbm\" $273 characters$
sed "s/^X//" >hMineSm.xbm <<'END_OF_hMineSm.xbm'
X#define hiddenmineSmall_width 16
X#define hiddenmineSmall_height 16
Xstatic char hiddenmineSmall_bits[] = {
X 0xff,0xff,0x81,0x80,0x49,0x80,0x01,0x82,0x21,0x81,0x2d,0x80,0x41,0x80,0xc9,
X 0x83,0xc5,0x87,0xe1,0x8e,0x61,0x8c,0xe1,0x8e,0xc1,0x87,0x81,0x83,0x01,0x80,
X 0xff,0xff};
END_OF_hMineSm.xbm
if test 273 -ne `wc -c <hMineSm.xbm`; then
echo shar: \"hMineSm.xbm\" unpacked with wrong size!

fi
# end of overwriting check
fi

if test -f mine.xbm -a "${1}" != "-c" ; then
echo shar: Will not over-write existing file \"mine.xbm\"
else
echo shar: Extracting \"mine.xbm\" $732 characters$
sed "s/^X//" >mine.xbm <<'END_OF_mine.xbm'
X#define mine_width 32
X#define mine_height 32
Xstatic char mine_bits[] = {
X 0xff,0xff,0xff,0xff,0x01,0x00,0x00,0x80,0x01,0x00,0x00,0x80,0x01,0x00,0x00,
X 0x80,0x81,0x01,0x00,0x80,0xa1,0x02,0x00,0x80,0x21,0x30,0x00,0x80,0x05,0x24,
X 0x00,0x80,0x39,0x09,0x00,0x80,0xa1,0x00,0x00,0x80,0x81,0x00,0x00,0x80,0x81,
X 0x00,0x00,0x80,0x05,0xc7,0x07,0x80,0x39,0xef,0x1f,0x80,0x01,0xdf,0x3f,0x80,
X 0x01,0xde,0x7f,0x80,0x01,0xdc,0xff,0x80,0x01,0xe2,0xff,0x80,0x01,0xff,0xff,
X 0x81,0x01,0xff,0xff,0x81,0x01,0xff,0xff,0x81,0x01,0xff,0xff,0x81,0x01,0xff,
X 0xff,0x81,0x01,0xfe,0xff,0x80,0x01,0xfe,0xff,0x80,0x01,0xfc,0x7f,0x80,0x01,
X 0xf8,0x3f,0x80,0x01,0xf0,0x1f,0x80,0x01,0xc0,0x07,0x80,0x01,0x00,0x00,0x80,
X 0x01,0x00,0x00,0x80,0xff,0xff,0xff,0xff};
END_OF_mine.xbm
if test 732 -ne `wc -c <mine.xbm`; then
echo shar: \"mine.xbm\" unpacked with wrong size!

fi
# end of overwriting check
fi

if test -f mineSm.xbm -a "${1}" != "-c" ; then
echo shar: Will not over-write existing file \"mineSm.xbm\"
else
echo shar: Extracting \"mineSm.xbm\" $255 characters$
sed "s/^X//" >mineSm.xbm <<'END_OF_mineSm.xbm'
X#define mineSmall_width 16
X#define mineSmall_height 16
Xstatic char mineSmall_bits[] = {
X 0xff,0xff,0x81,0x80,0x49,0x80,0x01,0x82,0x21,0x81,0x2d,0x80,0x41,0x80,0xc9,
X 0x83,0xc5,0x87,0xe1,0x8f,0xe1,0x8f,0xe1,0x8f,0xc1,0x87,0x81,0x83,0x01,0x80,
X 0xff,0xff};
END_OF_mineSm.xbm
if test 255 -ne `wc -c <mineSm.xbm`; then
echo shar: \"mineSm.xbm\" unpacked with wrong size!

fi
# end of overwriting check
fi

if test -f pl0.xbm -a "${1}" != "-c" ; then
echo shar: Will not over-write existing file \"pl0.xbm\"
else
echo shar: Extracting \"pl0.xbm\" $738 characters$
sed "s/^X//" >pl0.xbm <<'END_OF_pl0.xbm'
X#define plZero_width 32
X#define plZero_height 32
Xstatic char plZero_bits[] = {
X 0xff,0xff,0xff,0xff,0x01,0x00,0x00,0x80,0x01,0x00,0x00,0x80,0x01,0x00,0x00,
X 0x80,0x01,0x00,0x00,0x80,0x01,0x00,0x00,0x80,0x01,0x00,0x00,0x80,0x01,0x0e,
X 0x00,0x80,0x01,0x11,0x00,0x80,0x01,0x11,0x00,0x80,0x01,0x11,0x00,0x80,0x01,
X 0x0e,0x00,0x80,0x01,0x04,0x00,0x80,0x01,0x04,0x00,0x80,0x01,0x04,0x00,0x80,
X 0x81,0x3f,0x00,0x80,0x01,0x04,0x00,0x80,0x01,0x04,0xe0,0x80,0x01,0x04,0x10,
X 0x81,0x01,0x04,0x10,0x81,0x01,0x04,0x90,0x81,0x01,0x04,0x50,0x81,0x01,0x04,
X 0x30,0x81,0x01,0x0a,0x10,0x81,0x01,0x11,0x10,0x81,0x01,0x11,0xe0,0x80,0x81,
X 0x20,0x00,0x80,0x41,0x40,0x00,0x80,0x01,0x00,0x00,0x80,0x01,0x00,0x00,0x80,
X 0x01,0x00,0x00,0x80,0xff,0xff,0xff,0xff};
END_OF_pl0.xbm
if test 738 -ne `wc -c <pl0.xbm`; then
echo shar: \"pl0.xbm\" unpacked with wrong size!

fi
# end of overwriting check
fi

if test -f pl0Sm.xbm -a "${1}" != "-c" ; then
echo shar: Will not over-write existing file \"pl0Sm.xbm\"
else
echo shar: Extracting \"pl0Sm.xbm\" $261 characters$
sed "s/^X//" >pl0Sm.xbm <<'END_OF_pl0Sm.xbm'
X#define plZeroSmall_width 16
X#define plZeroSmall_height 16
Xstatic char plZeroSmall_bits[] = {
X 0xff,0xff,0x01,0x80,0x21,0x80,0x71,0x80,0x71,0x80,0x21,0x80,0x21,0x80,0xf9,
X 0x98,0x25,0xa5,0x21,0xa4,0x71,0xa4,0x71,0xa4,0x89,0x98,0x89,0x80,0x01,0x80,
X 0xff,0xff};
END_OF_pl0Sm.xbm
if test 261 -ne `wc -c <pl0Sm.xbm`; then
echo shar: \"pl0Sm.xbm\" unpacked with wrong size!

fi
# end of overwriting check
fi

if test -f pl1.xbm -a "${1}" != "-c" ; then
echo shar: Will not over-write existing file \"pl1.xbm\"
else
echo shar: Extracting \"pl1.xbm\" $735 characters$
sed "s/^X//" >pl1.xbm <<'END_OF_pl1.xbm'
X#define plOne_width 32
X#define plOne_height 32
Xstatic char plOne_bits[] = {
X 0xff,0xff,0xff,0xff,0x01,0x00,0x00,0x80,0x01,0x00,0x00,0x80,0x01,0x00,0x00,
X 0x80,0x01,0x00,0x00,0x80,0x01,0x00,0x00,0x80,0x01,0x00,0x00,0x80,0x01,0x0e,
X 0x00,0x80,0x01,0x11,0x00,0x80,0x01,0x11,0x00,0x80,0x01,0x11,0x00,0x80,0x01,
X 0x0e,0x00,0x80,0x01,0x04,0x00,0x80,0x01,0x04,0x00,0x80,0x01,0x04,0x00,0x80,
X 0x81,0x3f,0x00,0x80,0x01,0x04,0x00,0x80,0x01,0x04,0x00,0x80,0x01,0x04,0x40,
X 0x80,0x01,0x04,0x60,0x80,0x01,0x04,0x50,0x80,0x01,0x04,0x40,0x80,0x01,0x04,
X 0x40,0x80,0x01,0x0a,0x40,0x80,0x01,0x11,0x40,0x80,0x01,0x11,0x40,0x80,0x81,
X 0x20,0xf0,0x81,0x41,0x40,0x00,0x80,0x01,0x00,0x00,0x80,0x01,0x00,0x00,0x80,
X 0x01,0x00,0x00,0x80,0xff,0xff,0xff,0xff};
END_OF_pl1.xbm
if test 735 -ne `wc -c <pl1.xbm`; then
echo shar: \"pl1.xbm\" unpacked with wrong size!

fi
# end of overwriting check
fi

if test -f pl1Sm.xbm -a "${1}" != "-c" ; then
echo shar: Will not over-write existing file \"pl1Sm.xbm\"
else
echo shar: Extracting \"pl1Sm.xbm\" $258 characters$
sed "s/^X//" >pl1Sm.xbm <<'END_OF_pl1Sm.xbm'
X#define plOneSmall_width 16
X#define plOneSmall_height 16
Xstatic char plOneSmall_bits[] = {
X 0xff,0xff,0x01,0x80,0x21,0x80,0x71,0x80,0x71,0x80,0x21,0x80,0x21,0x80,0xf9,
X 0x90,0x25,0x91,0x21,0x90,0x71,0x90,0x71,0x90,0x89,0x90,0x89,0x80,0x01,0x80,
X 0xff,0xff};
END_OF_pl1Sm.xbm
if test 258 -ne `wc -c <pl1Sm.xbm`; then
echo shar: \"pl1Sm.xbm\" unpacked with wrong size!

fi
# end of overwriting check
fi

if test -f pl2.xbm -a "${1}" != "-c" ; then
echo shar: Will not over-write existing file \"pl2.xbm\"
else
echo shar: Extracting \"pl2.xbm\" $735 characters$
sed "s/^X//" >pl2.xbm <<'END_OF_pl2.xbm'
X#define plTwo_width 32
X#define plTwo_height 32
Xstatic char plTwo_bits[] = {
X 0xff,0xff,0xff,0xff,0x01,0x00,0x00,0x80,0x01,0x00,0x00,0x80,0x01,0x00,0x00,
X 0x80,0x01,0x00,0x00,0x80,0x01,0x00,0x00,0x80,0x01,0x00,0x00,0x80,0x01,0x0e,
X 0x00,0x80,0x01,0x11,0x00,0x80,0x01,0x11,0x00,0x80,0x01,0x11,0x00,0x80,0x01,
X 0x0e,0x00,0x80,0x01,0x04,0x00,0x80,0x01,0x04,0x00,0x80,0x01,0x04,0x00,0x80,
X 0x81,0x3f,0x00,0x80,0x01,0x04,0x00,0x80,0x01,0x04,0x00,0x80,0x01,0x04,0xe0,
X 0x80,0x01,0x04,0x10,0x81,0x01,0x04,0x00,0x81,0x01,0x04,0x00,0x81,0x01,0x04,
X 0x80,0x80,0x01,0x0a,0x40,0x80,0x01,0x11,0x20,0x80,0x01,0x11,0x10,0x80,0x81,
X 0x20,0xf0,0x81,0x41,0x40,0x00,0x80,0x01,0x00,0x00,0x80,0x01,0x00,0x00,0x80,
X 0x01,0x00,0x00,0x80,0xff,0xff,0xff,0xff};
END_OF_pl2.xbm
if test 735 -ne `wc -c <pl2.xbm`; then
echo shar: \"pl2.xbm\" unpacked with wrong size!

fi
# end of overwriting check
fi

if test -f pl2Sm.xbm -a "${1}" != "-c" ; then
echo shar: Will not over-write existing file \"pl2Sm.xbm\"
else
echo shar: Extracting \"pl2Sm.xbm\" $258 characters$
sed "s/^X//" >pl2Sm.xbm <<'END_OF_pl2Sm.xbm'
X#define plTwoSmall_width 16
X#define plTwoSmall_height 16
Xstatic char plTwoSmall_bits[] = {
X 0xff,0xff,0x01,0x80,0x21,0x80,0x71,0x80,0x71,0x80,0x21,0x80,0x21,0x80,0xf9,
X 0x98,0x25,0xa5,0x21,0x90,0x71,0x88,0x71,0x84,0x89,0xbc,0x89,0x80,0x01,0x80,
X 0xff,0xff};
END_OF_pl2Sm.xbm
if test 258 -ne `wc -c <pl2Sm.xbm`; then
echo shar: \"pl2Sm.xbm\" unpacked with wrong size!

fi
# end of overwriting check
fi

if test -f pl3.xbm -a "${1}" != "-c" ; then
echo shar: Will not over-write existing file \"pl3.xbm\"
else
echo shar: Extracting \"pl3.xbm\" $741 characters$
sed "s/^X//" >pl3.xbm <<'END_OF_pl3.xbm'
X#define plThree_width 32
X#define plThree_height 32
Xstatic char plThree_bits[] = {
X 0xff,0xff,0xff,0xff,0x01,0x00,0x00,0x80,0x01,0x00,0x00,0x80,0x01,0x00,0x00,
X 0x80,0x01,0x00,0x00,0x80,0x01,0x00,0x00,0x80,0x01,0x00,0x00,0x80,0x01,0x0e,
X 0x00,0x80,0x01,0x11,0x00,0x80,0x01,0x11,0x00,0x80,0x01,0x11,0x00,0x80,0x01,
X 0x0e,0x00,0x80,0x01,0x04,0x00,0x80,0x01,0x04,0x00,0x80,0x01,0x04,0x00,0x80,
X 0x81,0x3f,0x00,0x80,0x01,0x04,0x00,0x80,0x01,0x04,0x00,0x80,0x01,0x04,0xe0,
X 0x80,0x01,0x04,0x10,0x81,0x01,0x04,0x00,0x81,0x01,0x04,0x00,0x81,0x01,0x04,
X 0xc0,0x80,0x01,0x0a,0x00,0x81,0x01,0x11,0x00,0x81,0x01,0x11,0x10,0x81,0x81,
X 0x20,0xe0,0x80,0x41,0x40,0x00,0x80,0x01,0x00,0x00,0x80,0x01,0x00,0x00,0x80,
X 0x01,0x00,0x00,0x80,0xff,0xff,0xff,0xff};
END_OF_pl3.xbm
if test 741 -ne `wc -c <pl3.xbm`; then
echo shar: \"pl3.xbm\" unpacked with wrong size!

fi
# end of overwriting check
fi

if test -f pl3Sm.xbm -a "${1}" != "-c" ; then
echo shar: Will not over-write existing file \"pl3Sm.xbm\"
else
echo shar: Extracting \"pl3Sm.xbm\" $264 characters$
sed "s/^X//" >pl3Sm.xbm <<'END_OF_pl3Sm.xbm'
X#define plThreeSmall_width 16
X#define plThreeSmall_height 16
Xstatic char plThreeSmall_bits[] = {
X 0xff,0xff,0x01,0x80,0x21,0x80,0x71,0x80,0x71,0x80,0x21,0x80,0x21,0x80,0xf9,
X 0xbc,0x25,0xa1,0x21,0xbc,0x71,0xa0,0x71,0xa0,0x89,0xbc,0x89,0x80,0x01,0x80,
X 0xff,0xff};
END_OF_pl3Sm.xbm
if test 264 -ne `wc -c <pl3Sm.xbm`; then
echo shar: \"pl3Sm.xbm\" unpacked with wrong size!

fi
# end of overwriting check
fi

if test -f pl4.xbm -a "${1}" != "-c" ; then
echo shar: Will not over-write existing file \"pl4.xbm\"
else
echo shar: Extracting \"pl4.xbm\" $738 characters$
sed "s/^X//" >pl4.xbm <<'END_OF_pl4.xbm'
X#define plFour_width 32
X#define plFour_height 32
Xstatic char plFour_bits[] = {
X 0xff,0xff,0xff,0xff,0x01,0x00,0x00,0x80,0x01,0x00,0x00,0x80,0x01,0x00,0x00,
X 0x80,0x01,0x00,0x00,0x80,0x01,0x00,0x00,0x80,0x01,0x00,0x00,0x80,0x01,0x0e,
X 0x00,0x80,0x01,0x11,0x00,0x80,0x01,0x11,0x00,0x80,0x01,0x11,0x00,0x80,0x01,
X 0x0e,0x00,0x80,0x01,0x04,0x00,0x80,0x01,0x04,0x00,0x80,0x01,0x04,0x00,0x80,
X 0x81,0x3f,0x00,0x80,0x01,0x04,0x00,0x80,0x01,0x04,0x00,0x80,0x01,0x04,0x80,
X 0x80,0x01,0x04,0xc0,0x80,0x01,0x04,0xa0,0x80,0x01,0x04,0x90,0x80,0x01,0x04,
X 0x88,0x80,0x01,0x0a,0x88,0x80,0x01,0x11,0xf8,0x81,0x01,0x11,0x80,0x80,0x81,
X 0x20,0x80,0x80,0x41,0x40,0x00,0x80,0x01,0x00,0x00,0x80,0x01,0x00,0x00,0x80,
X 0x01,0x00,0x00,0x80,0xff,0xff,0xff,0xff};
END_OF_pl4.xbm
if test 738 -ne `wc -c <pl4.xbm`; then
echo shar: \"pl4.xbm\" unpacked with wrong size!

fi
# end of overwriting check
fi

if test -f pl4Sm.xbm -a "${1}" != "-c" ; then
echo shar: Will not over-write existing file \"pl4Sm.xbm\"
else
echo shar: Extracting \"pl4Sm.xbm\" $261 characters$
sed "s/^X//" >pl4Sm.xbm <<'END_OF_pl4Sm.xbm'
X#define plFourSmall_width 16
X#define plFourSmall_height 16
Xstatic char plFourSmall_bits[] = {
X 0xff,0xff,0x01,0x80,0x21,0x80,0x71,0x80,0x71,0x80,0x21,0x80,0x21,0x80,0xf9,
X 0xa4,0x25,0xa5,0x21,0xa4,0x71,0xbc,0x71,0xa0,0x89,0xa0,0x89,0x80,0x01,0x80,
X 0xff,0xff};
END_OF_pl4Sm.xbm
if test 261 -ne `wc -c <pl4Sm.xbm`; then
echo shar: \"pl4Sm.xbm\" unpacked with wrong size!

fi
# end of overwriting check
fi

if test -f pl5.xbm -a "${1}" != "-c" ; then
echo shar: Will not over-write existing file \"pl5.xbm\"
else
echo shar: Extracting \"pl5.xbm\" $738 characters$
sed "s/^X//" >pl5.xbm <<'END_OF_pl5.xbm'
X#define plFive_width 32
X#define plFive_height 32
Xstatic char plFive_bits[] = {
X 0xff,0xff,0xff,0xff,0x01,0x00,0x00,0x80,0x01,0x00,0x00,0x80,0x01,0x00,0x00,
X 0x80,0x01,0x00,0x00,0x80,0x01,0x00,0x00,0x80,0x01,0x00,0x00,0x80,0x01,0x0e,
X 0x00,0x80,0x01,0x11,0x00,0x80,0x01,0x11,0x00,0x80,0x01,0x11,0x00,0x80,0x01,
X 0x0e,0x00,0x80,0x01,0x04,0x00,0x80,0x01,0x04,0x00,0x80,0x01,0x04,0x00,0x80,
X 0x81,0x3f,0x00,0x80,0x01,0x04,0x00,0x80,0x01,0x04,0x00,0x80,0x01,0x04,0xf0,
X 0x81,0x01,0x04,0x10,0x80,0x01,0x04,0x10,0x80,0x01,0x04,0xf0,0x80,0x01,0x04,
X 0x00,0x81,0x01,0x0a,0x00,0x81,0x01,0x11,0x10,0x81,0x01,0x11,0x10,0x81,0x81,
X 0x20,0xe0,0x80,0x41,0x40,0x00,0x80,0x01,0x00,0x00,0x80,0x01,0x00,0x00,0x80,
X 0x01,0x00,0x00,0x80,0xff,0xff,0xff,0xff};
END_OF_pl5.xbm
if test 738 -ne `wc -c <pl5.xbm`; then
echo shar: \"pl5.xbm\" unpacked with wrong size!

fi
# end of overwriting check
fi

if test -f pl5Sm.xbm -a "${1}" != "-c" ; then
echo shar: Will not over-write existing file \"pl5Sm.xbm\"
else
echo shar: Extracting \"pl5Sm.xbm\" $261 characters$
sed "s/^X//" >pl5Sm.xbm <<'END_OF_pl5Sm.xbm'
X#define plFiveSmall_width 16
X#define plFiveSmall_height 16
Xstatic char plFiveSmall_bits[] = {
X 0xff,0xff,0x01,0x80,0x21,0x80,0x71,0x80,0x71,0x80,0x21,0x80,0x21,0x80,0xf9,
X 0xbc,0x25,0x85,0x21,0x9c,0x71,0xa0,0x71,0xa0,0x89,0x9c,0x89,0x80,0x01,0x80,
X 0xff,0xff};
END_OF_pl5Sm.xbm
if test 261 -ne `wc -c <pl5Sm.xbm`; then
echo shar: \"pl5Sm.xbm\" unpacked with wrong size!

fi
# end of overwriting check
fi

if test -f pl6.xbm -a "${1}" != "-c" ; then
echo shar: Will not over-write existing file \"pl6.xbm\"
else
echo shar: Extracting \"pl6.xbm\" $735 characters$
sed "s/^X//" >pl6.xbm <<'END_OF_pl6.xbm'
X#define plSix_width 32
X#define plSix_height 32
Xstatic char plSix_bits[] = {
X 0xff,0xff,0xff,0xff,0x01,0x00,0x00,0x80,0x01,0x00,0x00,0x80,0x01,0x00,0x00,
X 0x80,0x01,0x00,0x00,0x80,0x01,0x00,0x00,0x80,0x01,0x00,0x00,0x80,0x01,0x0e,
X 0x00,0x80,0x01,0x11,0x00,0x80,0x01,0x11,0x00,0x80,0x01,0x11,0x00,0x80,0x01,
X 0x0e,0x00,0x80,0x01,0x04,0x00,0x80,0x01,0x04,0x00,0x80,0x01,0x04,0x00,0x80,
X 0x81,0x3f,0x00,0x80,0x01,0x04,0x00,0x80,0x01,0x04,0x00,0x80,0x01,0x04,0xe0,
X 0x80,0x01,0x04,0x10,0x81,0x01,0x04,0x10,0x80,0x01,0x04,0x10,0x80,0x01,0x04,
X 0xf0,0x80,0x01,0x0a,0x10,0x81,0x01,0x11,0x10,0x81,0x01,0x11,0x10,0x81,0x81,
X 0x20,0xe0,0x80,0x41,0x40,0x00,0x80,0x01,0x00,0x00,0x80,0x01,0x00,0x00,0x80,
X 0x01,0x00,0x00,0x80,0xff,0xff,0xff,0xff};
END_OF_pl6.xbm
if test 735 -ne `wc -c <pl6.xbm`; then
echo shar: \"pl6.xbm\" unpacked with wrong size!

fi
# end of overwriting check
fi

if test -f pl6Sm.xbm -a "${1}" != "-c" ; then
echo shar: Will not over-write existing file \"pl6Sm.xbm\"
else
echo shar: Extracting \"pl6Sm.xbm\" $258 characters$
sed "s/^X//" >pl6Sm.xbm <<'END_OF_pl6Sm.xbm'
X#define plSixSmall_width 16
X#define plSixSmall_height 16
Xstatic char plSixSmall_bits[] = {
X 0xff,0xff,0x01,0x80,0x21,0x80,0x71,0x80,0x71,0x80,0x21,0x80,0x21,0x80,0xf9,
X 0x84,0x25,0x85,0x21,0x84,0x71,0xbc,0x71,0xa4,0x89,0xbc,0x89,0x80,0x01,0x80,
X 0xff,0xff};
END_OF_pl6Sm.xbm
if test 258 -ne `wc -c <pl6Sm.xbm`; then
echo shar: \"pl6Sm.xbm\" unpacked with wrong size!

fi
# end of overwriting check
fi

if test -f pl7.xbm -a "${1}" != "-c" ; then
echo shar: Will not over-write existing file \"pl7.xbm\"
else
echo shar: Extracting \"pl7.xbm\" $741 characters$
sed "s/^X//" >pl7.xbm <<'END_OF_pl7.xbm'
X#define plSeven_width 32
X#define plSeven_height 32
Xstatic char plSeven_bits[] = {
X 0xff,0xff,0xff,0xff,0x01,0x00,0x00,0x80,0x01,0x00,0x00,0x80,0x01,0x00,0x00,
X 0x80,0x01,0x00,0x00,0x80,0x01,0x00,0x00,0x80,0x01,0x00,0x00,0x80,0x01,0x0e,
X 0x00,0x80,0x01,0x11,0x00,0x80,0x01,0x11,0x00,0x80,0x01,0x11,0x00,0x80,0x01,
X 0x0e,0x00,0x80,0x01,0x04,0x00,0x80,0x01,0x04,0x00,0x80,0x01,0x04,0x00,0x80,
X 0x81,0x3f,0x00,0x80,0x01,0x04,0x00,0x80,0x01,0x04,0x00,0x80,0x01,0x04,0xf0,
X 0x81,0x01,0x04,0x10,0x81,0x01,0x04,0x00,0x81,0x01,0x04,0x80,0x80,0x01,0x04,
X 0x80,0x80,0x01,0x0a,0x80,0x80,0x01,0x11,0x40,0x80,0x01,0x11,0x40,0x80,0x81,
X 0x20,0x40,0x80,0x41,0x40,0x00,0x80,0x01,0x00,0x00,0x80,0x01,0x00,0x00,0x80,
X 0x01,0x00,0x00,0x80,0xff,0xff,0xff,0xff};
END_OF_pl7.xbm
if test 741 -ne `wc -c <pl7.xbm`; then
echo shar: \"pl7.xbm\" unpacked with wrong size!

fi
# end of overwriting check
fi

if test -f pl7Sm.xbm -a "${1}" != "-c" ; then
echo shar: Will not over-write existing file \"pl7Sm.xbm\"
else
echo shar: Extracting \"pl7Sm.xbm\" $264 characters$
sed "s/^X//" >pl7Sm.xbm <<'END_OF_pl7Sm.xbm'
X#define plSevenSmall_width 16
X#define plSevenSmall_height 16
Xstatic char plSevenSmall_bits[] = {
X 0xff,0xff,0x01,0x80,0x21,0x80,0x71,0x80,0x71,0x80,0x21,0x80,0x21,0x80,0xf9,
X 0xbc,0x25,0xa1,0x21,0x90,0x71,0x90,0x71,0x88,0x89,0x88,0x89,0x80,0x01,0x80,
X 0xff,0xff};
END_OF_pl7Sm.xbm
if test 264 -ne `wc -c <pl7Sm.xbm`; then
echo shar: \"pl7Sm.xbm\" unpacked with wrong size!

fi
# end of overwriting check
fi

if test -f pl8.xbm -a "${1}" != "-c" ; then
echo shar: Will not over-write existing file \"pl8.xbm\"
else
echo shar: Extracting \"pl8.xbm\" $741 characters$
sed "s/^X//" >pl8.xbm <<'END_OF_pl8.xbm'
X#define plEight_width 32
X#define plEight_height 32
Xstatic char plEight_bits[] = {
X 0xff,0xff,0xff,0xff,0x01,0x00,0x00,0x80,0x01,0x00,0x00,0x80,0x01,0x00,0x00,
X 0x80,0x01,0x00,0x00,0x80,0x01,0x00,0x00,0x80,0x01,0x00,0x00,0x80,0x01,0x0e,
X 0x00,0x80,0x01,0x11,0x00,0x80,0x01,0x11,0x00,0x80,0x01,0x11,0x00,0x80,0x01,
X 0x0e,0x00,0x80,0x01,0x04,0x00,0x80,0x01,0x04,0x00,0x80,0x01,0x04,0x00,0x80,
X 0x81,0x3f,0x00,0x80,0x01,0x04,0x00,0x80,0x01,0x04,0x00,0x80,0x01,0x04,0xe0,
X 0x80,0x01,0x04,0x10,0x81,0x01,0x04,0x10,0x81,0x01,0x04,0x10,0x81,0x01,0x04,
X 0xe0,0x80,0x01,0x0a,0x10,0x81,0x01,0x11,0x10,0x81,0x01,0x11,0x10,0x81,0x81,
X 0x20,0xe0,0x80,0x41,0x40,0x00,0x80,0x01,0x00,0x00,0x80,0x01,0x00,0x00,0x80,
X 0x01,0x00,0x00,0x80,0xff,0xff,0xff,0xff};
END_OF_pl8.xbm
if test 741 -ne `wc -c <pl8.xbm`; then
echo shar: \"pl8.xbm\" unpacked with wrong size!

fi
# end of overwriting check
fi

if test -f pl8Sm.xbm -a "${1}" != "-c" ; then
echo shar: Will not over-write existing file \"pl8Sm.xbm\"
else
echo shar: Extracting \"pl8Sm.xbm\" $264 characters$
sed "s/^X//" >pl8Sm.xbm <<'END_OF_pl8Sm.xbm'
X#define plEightSmall_width 16
X#define plEightSmall_height 16
Xstatic char plEightSmall_bits[] = {
X 0xff,0xff,0x01,0x80,0x21,0x80,0x71,0x80,0x71,0x80,0x21,0x80,0x21,0x80,0xf9,
X 0x98,0x25,0xa5,0x21,0x98,0x71,0xa4,0x71,0xa4,0x89,0x98,0x89,0x80,0x01,0x80,
X 0xff,0xff};
END_OF_pl8Sm.xbm
if test 264 -ne `wc -c <pl8Sm.xbm`; then
echo shar: \"pl8Sm.xbm\" unpacked with wrong size!

fi
# end of overwriting check
fi

if test -f safe.xbm -a "${1}" != "-c" ; then
echo shar: Will not over-write existing file \"safe.xbm\"
else
echo shar: Extracting \"safe.xbm\" $732 characters$
sed "s/^X//" >safe.xbm <<'END_OF_safe.xbm'
X#define safe_width 32
X#define safe_height 32
Xstatic char safe_bits[] = {
X 0xff,0xff,0xff,0xff,0x01,0x00,0x00,0x80,0x01,0x00,0x00,0x80,0x01,0x00,0x00,
X 0x80,0x01,0x00,0x00,0x80,0x01,0x00,0x00,0x80,0x01,0x00,0x00,0x80,0x01,0x00,
X 0x00,0x80,0x01,0x00,0x00,0x80,0x01,0x00,0x00,0x80,0x01,0x00,0x00,0x80,0x01,
X 0x00,0x02,0x80,0x01,0x00,0x02,0x80,0x01,0x38,0x12,0x80,0x01,0x44,0x0a,0x80,
X 0x01,0x44,0x06,0x80,0x01,0x44,0x06,0x80,0x01,0x44,0x0a,0x80,0x01,0x44,0x12,
X 0x80,0x01,0x38,0x22,0x80,0x01,0x00,0x00,0x80,0x01,0x00,0x00,0x80,0x01,0x00,
X 0x00,0x80,0x01,0x00,0x00,0x80,0x01,0x00,0x00,0x80,0x01,0x00,0x00,0x80,0x01,
X 0x00,0x00,0x80,0x01,0x00,0x00,0x80,0x01,0x00,0x00,0x80,0x01,0x00,0x00,0x80,
X 0x01,0x00,0x00,0x80,0xff,0xff,0xff,0xff};
END_OF_safe.xbm
if test 732 -ne `wc -c <safe.xbm`; then
echo shar: \"safe.xbm\" unpacked with wrong size!

fi
# end of overwriting check
fi

if test -f safeSm.xbm -a "${1}" != "-c" ; then
echo shar: Will not over-write existing file \"safeSm.xbm\"
else
echo shar: Extracting \"safeSm.xbm\" $255 characters$
sed "s/^X//" >safeSm.xbm <<'END_OF_safeSm.xbm'
X#define safeSmall_width 16
X#define safeSmall_height 16
Xstatic char safeSmall_bits[] = {
X 0xff,0xff,0x01,0x80,0x01,0x80,0x01,0x80,0x01,0xb0,0x01,0xb8,0x01,0xbc,0x01,
X 0x8e,0x01,0x86,0x19,0x83,0xb1,0x81,0xe1,0x80,0x41,0x80,0x41,0x80,0x01,0x80,
X 0xff,0xff};
END_OF_safeSm.xbm
if test 255 -ne `wc -c <safeSm.xbm`; then
echo shar: \"safeSm.xbm\" unpacked with wrong size!

fi
# end of overwriting check
fi

echo shar: End of archive 3 $of 3$.
cp /dev/null ark3isdone

0 new messages