### xgrav-1.01 README file

    XGrav by DWF, dave@case50.ncsl.nist.gov
    Version 1.0.1, 1/20/95

    This program is a hack of XSwarm 2.3 by Jeff Butterworth.  I know nothing
    about X programming, so I modified a program that was pretty close to what I
    wanted.

    Instead of a swarm of bees, this program now shows the gravitational
    interaction between a number of "stars."  The trails are left on purpose
    since I think it's more interesting that way.

    Insofar as I have any claim to this program (and I haven't much since it's
    a hack of somebody else's) the GNU General Public License would apply.  My
    contributions here are free, but they come with absolutely no warranty and
    nobody can get a patent on them.

    Command Line Options
    --------------------

             -h|q|?            display this message
             -r                use root window
             -g geometry       window geometry
             -d host:display   X server to connect to
             -t timeout        screen saved after 'timeout' seconds
             -D delay          non-blocking delay between updates (milliseconds)
             -b stars          number of stars
             -c star_clr       star color
             -C bg_color       background color

             Press d in the window to add a gravity well.
             Press e in the window to erase trails.
             Press q in the window to quit.

    Helpful Hints
    -------------

    1.  The default delay is 0.  Setting a nonzero delay slows it down a lot.
        To slow it down a little, add stars.

    2.  You get nine stars by default.  The area over which the stars are
        distributed when you start up gets bigger the more stars you ask for.
        Too many stars too close together results in everything falling into
        a black hole, which is not so entertaining.  The default window size
        is always 512x512, so you might want to specify a bigger window if you
        have a lot of stars.

    3.  In screensaver or root window mode, the program automatically starts
        over every 2 minutes; otherwise it runs until you stop it.  The
        keypress commands (d, e, q) only work in normal window mode.

    4.  The d command adds a stationary gravity well.  Since its position is
        fixed it is easier to see elliptical orbits when they happen.  The d
        is for destroy, since most of the stars won't orbit but will fall
        right in.  Press d several times in a row to see some interesting
        trajectories.

    5.  The e command is for erasing the old trails in case the screen gets
        cluttered and you can't see what is happening.

    Known Bugs
    ----------

    The pointer interferes with the screensaver.

    Big enough collapsars will become stationary like gravity wells.

    Collisions sometimes don't look right.

    Root window mode may not work on SGIs.

    History
    -------

    Updated README 1/20/95.

    Version 1.0 patch 1, 1/17/95.  Don't include getopt.h on Suns -- it ain't
    there.  Show patchlevel in title bar.  Reduced the amount of energy absorbed
    in a collision from 50% to 25%.  Removed gcc-specific -Wall from Imakefile.

    Version 1.0, 1/15/95.  This is actually the fifth time I have implemented an
    n-body program.  The first implementation was in BASIC on a VIC-20.  It didn't
    work very well.  I thought there was something I was missing in the algorithm.
    In retrospect, the algorithm was correct; what I did wrong was set the
    gravitational constant too high because I wanted to be able to see things
    moving on the screen.  The VIC-20 could not do enough iterations per second to
    get acceptable accuracy in real time.  The smaller the gravitational constant,
    the greater the accuracy but the slower the motion.

    The second implementation was a parallel version in Occam on a Transputer
    hypercube.  That one was a project for a parallel programming class.  It worked
    pretty well, but it was a short victory since it was about the least portable
    code I've ever written.  This led immediately to the third implementation,
    which was a rewrite of the VIC-20 BASIC on a Commodore 128 to behave more like
    the Occam version.  It worked, but it was too slow.

    The fourth implementation happened when I got my 386, under Turbo C++.  None of
    Borland's spiffy graphics drivers did what I needed, so I just POKEd the pixels
    into display memory like I did on the Commodore.  I later changed that program
    slightly to compile under GCC (DJGPP).  The syntax was different, but I was
    still using direct graphics.

    Now I have finally gotten stupid enough to blow a weekend getting it to run
    under X.  This is the fifth implementation.  The sixth one will probably be in
    3-D.