v18i004: planet - planet generation simulator, Part04/04

Dave Allen allen at viewlogic.com
Mon Apr 8 10:25:00 AEST 1991


Submitted-by: Dave Allen <allen at viewlogic.com>
Posting-number: Volume 18, Issue 4
Archive-name: planet/part04
Supersedes: tec: Volume 10, Issue 77-78

#! /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", e.g..  If this archive is complete, you
# will see the following message at the end:
#		"End of archive 4 (of 4)."
# Contents:  src/const.h src/tec.h src/unix.c src/x.c src/tec1.c
#   src/tec2.c src/tec3.c src/globe.c
# Wrapped by allen at baja on Sat Mar 23 16:18:38 1991
PATH=/bin:/usr/bin:/usr/ucb ; export PATH
if test -f src/const.h -a "${1}" != "-c" ; then 
  echo shar: Will not over-write existing file \"src/const.h\"
else
echo shar: Extracting \"src/const.h\" \(467 characters\)
sed "s/^X//" >src/const.h <<'END_OF_src/const.h'
X#define MAXX 100
X#define MAXY 100
X#define PRINTMODE_NONE  0
X#define PRINTMODE_LONG  1
X#define PRINTMODE_SCALE 2
X#define PRINTMODE_SHORT 3
X#define PRINTMODE_GREY  4
X#define PRINTMODE_CLIM  5
X#define DRAW_GREY  1
X#define DRAW_LAND  2
X#define DRAW_CLIM  3
X#define DRAW_TEC   4
X#define LINE_DIAG  1
X#define LINE_CORN  2
X#define LINE_NONE  3
X
X#define ABS(xx) ((xx < 0) ? -xx: xx)
X#define CMP(x) !strcmp (s, x)
X
Xextern double cos(), sin(), sqrt(), atof(), asin(), atan2();
END_OF_src/const.h
if test 467 -ne `wc -c <src/const.h`; then
    echo shar: \"src/const.h\" unpacked with wrong size!
fi
# end of overwriting check
fi
if test -f src/tec.h -a "${1}" != "-c" ; then 
  echo shar: Will not over-write existing file \"src/tec.h\"
else
echo shar: Extracting \"src/tec.h\" \(531 characters\)
sed "s/^X//" >src/tec.h <<'END_OF_src/tec.h'
X#define MAXSPLINTER 10
X#define MAXFRAG 100
X#define MAXPLATE 40
X#define MAXCHANGE 10
X#define REALSCALE 100
X
Xstruct plate { int dx, dy, odx, ody, rx, ry, age, area, id, next; };
X
Xextern int XSIZE,	YSIZE,		MAXSTEP;
Xextern int MAXLIFE,	MAXBUMP,	BUMPTOL;
Xextern int DRAWEVERY,	HYDROPCT,	PRINTMODE;
Xextern int ZINIT,	ZSUBSUME,	ZCOAST;
Xextern int ZSHELF,	ZMOUNTAIN,	ZERODE;
Xextern int RIFTPCT,	DOERODE,	ERODERND;
Xextern int MAXCTRTRY,	RIFTDIST,	BENDEVERY;
Xextern int BENDBY,	SPEEDBASE,	SPEEDRNG;
Xextern int UNDERSCAN;
Xextern double MR[];
END_OF_src/tec.h
if test 531 -ne `wc -c <src/tec.h`; then
    echo shar: \"src/tec.h\" unpacked with wrong size!
fi
# end of overwriting check
fi
if test -f src/unix.c -a "${1}" != "-c" ; then 
  echo shar: Will not over-write existing file \"src/unix.c\"
else
echo shar: Extracting \"src/unix.c\" \(862 characters\)
sed "s/^X//" >src/unix.c <<'END_OF_src/unix.c'
X/* This program is Copyright (c) 1991 David Allen.  It may be freely
X   distributed as long as you leave my name and copyright notice on it.
X   I'd really like your comments and feedback; send e-mail to
X   allen at viewlogic.com, or send us-mail to David Allen, 10 O'Moore Ave,
X   Maynard, MA 01754. */
X
X#include "const.h"
Xextern int XSIZE, YSIZE, MAXSTEP, step;
Xint picktype;
X
Xmain (argc,argv) int argc; char **argv; {
X   unsigned short seed16v[3];
X
X   /* Initialize random number generator */
X   srand (time ((long *) 0));	/* initialize rand() */
X   seed16v[0] = rand(); seed16v[1] = rand(); seed16v[2] = rand();
X   seed48 (seed16v);	/* initialize lrand48() */
X
X   init (*++argv);
X   for (step=0; step<MAXSTEP; step++) onestep();
X   return (0); }
X
Xcheckmouse () { }
X 
Xpanic (s) char *s; { printf ("PANIC: %s\n", s); exit (1); }
X
Xdraw (ctype, ltype, cra, lra) { }
END_OF_src/unix.c
if test 862 -ne `wc -c <src/unix.c`; then
    echo shar: \"src/unix.c\" unpacked with wrong size!
fi
# end of overwriting check
fi
if test -f src/x.c -a "${1}" != "-c" ; then 
  echo shar: Will not over-write existing file \"src/x.c\"
else
echo shar: Extracting \"src/x.c\" \(7119 characters\)
sed "s/^X//" >src/x.c <<'END_OF_src/x.c'
X/* This program is Copyright (c) 1991 David Allen.  It may be freely
X   distributed as long as you leave my name and copyright notice on it.
X   I'd really like your comments and feedback; send e-mail to
X   allen at viewlogic.com, or send us-mail to David Allen, 10 O'Moore Ave,
X   Maynard, MA 01754.
X
X   Based on code written by by George Ferguson (ferguson at cs.rochester.edu),
X   28 Apr 1990.  That code was intended for an X version of "tec", never
X   released. */
X
X#include <math.h>
X#include <X11/StringDefs.h>
X#include <X11/Intrinsic.h>
X#include <X11/keysym.h>
X#include <X11/Xaw/Box.h>
X#include <X11/Xaw/Command.h>
X#include <X11/Xaw/Viewport.h>
X#include <X11/Shell.h>
X#include "const.h"
X#include "clim.h"
X
X#define SIZE 6
X#define WINDOW_HEIGHT   (SIZE*MAXX)
X#define WINDOW_WIDTH    (SIZE*MAXY)
X
Xextern int MAXSTEP, XSIZE, YSIZE, step;
Xint picktype = M_HEAT;
X
Xstatic XtAppContext appc;
Xstatic Display *Dis;
Xstatic Window Win;
Xstatic Pixmap Pix;
Xstatic Pixmap Pixsave;
Xstatic GC gc_def;
Xstatic GC Gc[32];
X
X
Xstatic Arg simple_args[] = {
X   {XtNfromVert, (XtArgVal) NULL},
X   {XtNheight, (XtArgVal) WINDOW_HEIGHT},
X   {XtNwidth, (XtArgVal) WINDOW_WIDTH} };
X
X
Xunsigned char landcols [] = { 11, 28, 3 }, greycols[256], tecols[256];
Xunsigned char climcols [] = { 9, 20, 18, 2, 3, 18, 22, 26, 14, 17, 12 };
Xstatic char *color_names[] = {
X   "black","white","grey75", "grey50",
X   "MediumPurple1","purple4","purple3","purple2","purple1",
X   "blue4","blue3","blue2","blue1",
X   "DarkGreen","green4","green3","green2","green1",
X   "DarkGoldenrod4","yellow4","yellow3","yellow2","yellow1",
X   "orange4","orange3","orange2","orange1",
X   "brown4","red4","red3","red2","red1" };
X
X
Xmain (argc,argv) int argc; char **argv; {
X   Widget toplevel, top_form, surface;
X   XWindowAttributes wattr; ushort seed16v[3];
X
X   XtToolkitInitialize ();
X   appc = XtCreateApplicationContext ();
X
X   Dis = XtOpenDisplay (appc, NULL, NULL, "Demo", NULL, 0, &argc, argv);
X   toplevel = XtAppCreateShell (NULL, NULL, applicationShellWidgetClass,
X      Dis, NULL, 0);
X   top_form = XtCreateManagedWidget ("top form", formWidgetClass,
X      toplevel, NULL, 0);
X   surface = XtCreateManagedWidget ("drawing surface", simpleWidgetClass,
X      top_form, simple_args, XtNumber(simple_args));
X   XtRealizeWidget (toplevel);
X
X   Win = XtWindow (surface);
X   XGetWindowAttributes (Dis, Win, &wattr);
X   Pix = XCreatePixmap (Dis, Win, WINDOW_WIDTH, WINDOW_HEIGHT, wattr.depth);
X   Pixsave = XCreatePixmap (Dis, Win, WINDOW_WIDTH, WINDOW_HEIGHT, wattr.depth);
X   XSelectInput (Dis, Win,
X      ExposureMask | ButtonPressMask | ButtonReleaseMask |
X      KeyPressMask | StructureNotifyMask );
X
X   gc_def = DefaultGC (Dis, DefaultScreen (Dis));
X   assign_colors ();
X   XFlush (Dis);
X
X   /* Initialize random number generator */
X   srand (time ((long *) 0));	/* initialize rand() */
X   seed16v[0] = rand(); seed16v[1] = rand(); seed16v[2] = rand();
X   seed48 (seed16v);	/* initialize lrand48() */
X
X   XFillRectangle (Dis, Pix, Gc[0], 0, 0, MAXX*SIZE, MAXY*SIZE); redraw ();
X   init (*++argv);
X   for (step=0; step<MAXSTEP; step++) {
X      onestep();
X      redraw();
X      checkmouse (); }
X   XtDestroyApplicationContext (appc);
X   return (0); }
X
X
Xassign_colors () {
X   Colormap colormap; XColor screen_in_out,exact; int i;
X
X   for (i=0; i<256; i++) greycols[i] = 4.0 + (double) i * 27.0 / 254.0;
X   for (i=0; i<16; i++)  tecols[i] = 0;
X   for (; i<80; i++)     tecols[i] = 4.0 + (double) (i-16) * 27.0 / 62.0;
X   for (; i<256; i++)    tecols[i] = 1;
X
X   colormap = DefaultColormap (Dis, DefaultScreen(Dis));
X   for (i=0; i < 32; i++) {
X      XAllocNamedColor (Dis, colormap, color_names[i], &screen_in_out, &exact);
X      Gc[i] = XCreateGC (Dis, Win, 0, (XGCValues *) NULL);
X      XSetForeground (Dis, Gc[i], screen_in_out.pixel);
X      if (i == 0) XSetForeground (Dis, gc_def, screen_in_out.pixel); } }
X
X
X/* Each call to this routine dispatches any pending events.  We are only
X   interested in expose events which require a redraw, and the letter 'q'
X   being pressed to quit.  */
Xcheckmouse () { XEvent e; char c; KeySym sym; XComposeStatus status;
X 
X   while (XtAppPending (appc)) { /* while there are events */
X      XtAppNextEvent (appc, &e);    /* get one */
X      switch (e.type) {             /* and process it */
X         case Expose:
X            if (e.xexpose.window != Win) XtDispatchEvent(&e);
X            else if (e.xexpose.count == 0) redraw ();
X            break;
X         case KeyPress:
X            XLookupString(&e,&c,1,&sym,&status);
X            switch (sym) {
X               case XK_q: step     = MAXSTEP; break;
X               case XK_h: picktype = M_HEAT;  break;
X               case XK_p: picktype = M_PRESS; break;
X               case XK_w: picktype = M_WIND;  break;
X               case XK_r: picktype = M_RAIN;  break;
X               case XK_c: picktype = M_CLIM;  break; }
X            break;
X         default: XtDispatchEvent(&e); } } }
X
X
Xredraw () {
X   XCopyArea (Dis, Pix, Win, Gc[0], 0, 0, WINDOW_WIDTH, WINDOW_HEIGHT, 0, 0);
X   XFlush (Dis); }
X
X
Xrnd (top) short top; { return (lrand48 () % top); }
X
X
Xpanic (s) char *s; { printf ("PANIC: %s\n", s); exit (1); }
X
X
Xdraw (ctype, ltype, cra, lra)
X   int ctype, ltype;
X   unsigned char cra[MAXX][MAXY], lra[MAXX][MAXY]; {
X   register short i, j, k, x; unsigned char *lut;
X
X   switch (ctype) {
X      case DRAW_GREY: lut = greycols; break;
X      case DRAW_LAND: lut = landcols; break;
X      case DRAW_CLIM: lut = climcols; break;
X      case DRAW_TEC:  lut = tecols;   break; }
X   for (j=0; j < YSIZE; j++) for (i=0; i < XSIZE-1; i++) {
X      x = lut[cra[i][j]]; k = i+1;
X      while ((lut[cra[k][j]] == x) && (k < XSIZE-1)) k++;
X      XFillRectangle (Dis, Pix, Gc[x], i*SIZE, j*SIZE, (k-i)*SIZE, SIZE);
X      i = k-1; }
X   switch (ltype) {
X      case LINE_DIAG: diagonal (lra); break;
X      case LINE_CORN: corner   (lra); break;
X      case LINE_NONE: break; } }
X
X
X#define LEFT(i,j,x) \
X   XDrawLine (Dis, Pix, Gc[x], i*SIZE, j*SIZE, i*SIZE, (j+1)*SIZE)
X#define ABOVE(i,j,x) \
X   XDrawLine (Dis, Pix, Gc[x], i*SIZE, j*SIZE, (i+1)*SIZE, j*SIZE)
X#define UPLEFT(i,j,x) \
X   XDrawLine (Dis, Pix, Gc[x], i*SIZE, j*SIZE, (i+1)*SIZE, (j+1)*SIZE)
X#define UPRIGHT(i,j,x) \
X   XDrawLine (Dis, Pix, Gc[x], (i+1)*SIZE, j*SIZE, i*SIZE, (j+1)*SIZE)
X
X
Xdiagonal (ra) unsigned char ra[MAXX][MAXY]; { register short i, j;
X   for (j=0; j<YSIZE; j++) for (i=0; i<XSIZE; i++)
X      switch (ra[i][j]) {
X         case 0:   break;
X         case N:   LEFT    (i, j, 0); break;
X         case S:   LEFT    (i, j, 1); break;
X         case E:   ABOVE   (i, j, 1); break;
X         case W:   ABOVE   (i, j, 0); break;
X         case N|E: UPRIGHT (i, j, 0); break;
X         case N|W: UPLEFT  (i, j, 0); break;
X         case S|E: UPLEFT  (i, j, 1); break;
X         case S|W: UPRIGHT (i, j, 1); break; } }
X
X
Xcorner (ra) unsigned char ra[MAXX][MAXY]; { register short i, j, x;
X   for (j=0; j<YSIZE; j++) for (i=0; i<XSIZE; i++) {
X      x = ra[i][j];
X      if      (x & LINE_0V) LEFT  (i, j, 0);
X      else if (x & LINE_1V) LEFT  (i, j, 1);
X      if      (x & LINE_0H) ABOVE (i, j, 0);
X      else if (x & LINE_1H) ABOVE (i, j, 1); } }
END_OF_src/x.c
if test 7119 -ne `wc -c <src/x.c`; then
    echo shar: \"src/x.c\" unpacked with wrong size!
fi
# end of overwriting check
fi
if test -f src/tec1.c -a "${1}" != "-c" ; then 
  echo shar: Will not over-write existing file \"src/tec1.c\"
else
echo shar: Extracting \"src/tec1.c\" \(10750 characters\)
sed "s/^X//" >src/tec1.c <<'END_OF_src/tec1.c'
X/* This program is Copyright (c) 1991 David Allen.  It may be freely
X   distributed as long as you leave my name and copyright notice on it.
X   I'd really like your comments and feedback; send e-mail to
X   allen at viewlogic.com, or send us-mail to David Allen, 10 O'Moore Ave,
X   Maynard, MA 01754. */
X
X/* This is the file containing all of the important functions except for
X   trysplit (), which splits a continent into pieces.  Also, all of the main
X   arrays are declared here, even a couple that are only used by functions in
X   tec2.c.  The array declarations are first, followed by the sequencing
X   function onestep () and some miscellaneous routines including the text
X   output routines; initialization routines and the routines that do all
X   the interesting stuff are last. */
X
X#include "const.h"
X#include "tec.h"
X
X/* These are the parameters and their default values; each is defined in
X   params.doc */ 
Xint XSIZE = 100,	YSIZE = 100,	MAXSTEP = 100;
Xint MAXBUMP = 50,	BUMPTOL = 50,	UNDERSCAN = 0;
Xint HYDROPCT = 70,	DRAWEVERY = 0,	PRINTMODE = PRINTMODE_NONE;
Xint ZINIT = 22,		ZSUBSUME = 16,	ZCOAST = 16;
Xint ZSHELF = 8,		ZMOUNTAIN = 48, ZERODE = 16;
Xint RIFTPCT = 40,	DOERODE = 1,	ERODERND = 4;
Xint MAXCTRTRY = 50,	RIFTDIST = 5,	BENDEVERY = 6;
Xint BENDBY = 50,	SPEEDRNG = 300,	SPEEDBASE = 200;
X
Xdouble MR [] = { 1.0,1.0,1.0,0.7,0.4,0.1,-0.2,-0.5,-0.8,-1.0 };
Xint MAXLIFE = 10; /* Length of MR vector */
Xint change[1]; /* needed for fileio */
X
X/* The following arrays are global and most are used by functions in both
X   source files.  The two main ones are m and t.  Each is set up to be two
X   2-d arrays, where each array is the size of the whole world.  M is the
X   map; elements in m are indices of plates, showing which squares are
X   covered by which plate.  T is the topography; elements in t are altitudes. */
X 
Xchar m[2][MAXX][MAXY]; unsigned char t[2][MAXX][MAXY];
X 
X/* Several arrays are used by the binary blob segmenter, segment() in tec2.c.
X   These include r, which is used to store fragment indices; many fragments
X   make up one region during a segmentation.  Kid is a lookup table; fragment
X   k belongs to region kid[k] after a segmentation is finished.  Karea[k]
X   is the area of fragment k. */
X 
Xchar r[MAXX][MAXY], kid[MAXFRAG]; int karea [MAXFRAG];
X 
X/* The merge routine gets information from the move routine; when the move
X   routine puts a square of one plate on top of another plate, that information
X   is recorded in the merge matrix mm. */
X 
Xchar mm[MAXPLATE][MAXPLATE];
X 
X/* The erosion routine needs an array to store delta information; during an
X   erosion, the increases or decreases in elevation are summed in e and then
X   applied all at once to the topography. */
X 
Xchar e[MAXX][MAXY];
X 
X/* Several routines need temporary storage for areas and plate identifiers. */
X 
Xint tarea[MAXPLATE]; int ids[MAXPLATE];
X 
X/* The plates in use are stored in this data structure.  Dx,dy are the
X   values to move by THIS STEP ONLY; odx,ody are the permanent move
X   values; rx,ry are the remainder x and y values used by newdxy() to
X   determine dx,dy; age is the age of the plate, in steps; area is the
X   area of the plate, in squares; id is the value in the m array which
X   corresponds to this plate; next is a pointer to the next occupied
X   element of the plate array. */
X 
Xstruct plate p [MAXPLATE];
X 
X/* The linked list header for available plates and used plates are global,
X   as is the step counter.  */
X 
Xint pavail, phead, step;
X 
X 
Xonestep () {
X   /* This is the sequencing routine called by main once per step.
X   It just calls the important subfunctions in order:
X   - trysplit   finds a plate to break up, and computes new velocities
X   - newdxy     computes the deltas to move each plate this step
X   - move       moves the plates
X   - merge      determines results when plates rub together
X   - erode      erodes the terrain, adding or subtracting altitude
X   - draw       draw the resulting array once every DRAWEVERY steps
X   The m and t arrays are double-buffered in the sense that operations go
X   from m[0] to m[1] or vice-versa; src and dest determine which is which. */
X 
X   int src, dest;
X 
X   src = step % 2; dest = 1 - src;
X   if (rnd (100) < RIFTPCT) trysplit (src);
X   newdxy ();
X   move (src, dest);
X   merge (dest);
X   if (DOERODE) erode (dest);
X   draw (DRAW_TEC, LINE_NONE, t[dest], 0);
X
X   if (DRAWEVERY) if (step && !(step % DRAWEVERY)) tecst (dest);
X   if (!DRAWEVERY && (step == MAXSTEP - 1)) tecst (dest); }
X 
X 
Xpalloc () {
X   /* Allocate a plate from the array and return its index.  All the fields
X   of the plate are initialized to 0, except `next'.  That field is used to
X   link together the plate structures in use.  */
X 
X   int x;
X
X   if (!pavail) panic ("No more objects");
X   x = pavail; pavail = p[x].next;
X   p[x].next = phead; phead = x;
X   p[x].area = 0; p[x].age = 0;
X   p[x].rx = 0; p[x].ry = 0;
X   p[x].odx = 0; p[x].ody = 0;
X   p[x].dx = 0; p[x].dy = 0;
X   return (x); }
X 
X 
Xpfree (n) int n; {
X   /* Return a plate array element to the pool of available elements.
X   To check for infinite loops, the variable guard is incremented
X   at each operation; if the number of operations exceeds the maximum
X   possible number, the program panics. */
X 
X   int i, guard = 0;
X 
X   if (phead == n) phead = p[n].next;
X   else {
X      for (i=phead; p[i].next!=n; i=p[i].next)
X         if (++guard > MAXPLATE) panic ("Infinite loop in pfree");
X      p[i].next = p[n].next; }
X   p[n].next = pavail; pavail = n; }
X 
X
Xmainpar (s) char *s; { 
X   if      (CMP ("XSIZE"))     getdim  (&XSIZE, 0);
X   else if (CMP ("YSIZE"))     getdim  (&YSIZE, 0);
X   else if (CMP ("MOVERATE"))  getdvec (&MAXLIFE, MR, 0);
X   else if (CMP ("MAXSTEP"))   getlng  (&MAXSTEP, 0);
X   else if (CMP ("MAXBUMP"))   getlng  (&MAXBUMP, 0);
X   else if (CMP ("BUMPTOL"))   getlng  (&BUMPTOL, 0);
X   else if (CMP ("DRAWEVERY")) getlng  (&DRAWEVERY, 0);
X   else if (CMP ("PRINTMODE")) getlng  (&PRINTMODE, 0);
X   else if (CMP ("HYDROPCT"))  getlng  (&HYDROPCT, 0);
X   else if (CMP ("ZINIT"))     getlng  (&ZINIT, 0);
X   else if (CMP ("ZSUBSUME"))  getlng  (&ZSUBSUME, 0);
X   else if (CMP ("ZCOAST"))    getlng  (&ZCOAST, 0);
X   else if (CMP ("ZSHELF"))    getlng  (&ZSHELF, 0);
X   else if (CMP ("ZMOUNTAIN")) getlng  (&ZMOUNTAIN, 0);
X   else if (CMP ("ZERODE"))    getlng  (&ZERODE, 0);
X   else if (CMP ("RIFTPCT"))   getlng  (&RIFTPCT, 0);
X   else if (CMP ("DOERODE"))   getlng  (&DOERODE, 0);
X   else if (CMP ("ERODERND"))  getlng  (&ERODERND, 0);
X   else if (CMP ("MAXCTRTRY")) getlng  (&MAXCTRTRY, 0);
X   else if (CMP ("RIFTDIST"))  getlng  (&RIFTDIST, 0);
X   else if (CMP ("BENDEVERY")) getlng  (&BENDEVERY, 0);
X   else if (CMP ("BENDBY"))    getlng  (&BENDBY, 0);
X   else if (CMP ("SPEEDBASE")) getlng  (&SPEEDBASE, 0);
X   else if (CMP ("SPEEDRNG"))  getlng  (&SPEEDRNG, 0);
X   else if (CMP ("UNDERSCAN")) getlng  (&UNDERSCAN, 0);
X   else return (0);
X   return (1); }
X
X
Xtecst (src) int src; {
X   /* This function is called whenever map output is called for.  It looks
X   at the parameter `printmode' to decide between long text, simple text,
X   and PostScript output formats.  Note that the default for this
X   function is no output at all, corresponding to PRINTMODE_NONE.  If only
X   one output map is desired, then move the coastline up or down to meet the
X   desired hydrographic percentage. */
X
X   register int i, j, zcoast; int hist[256], goal; unsigned char sk[MAXX][MAXY];
X
X   if (!PRINTMODE) return (0);
X   if (!DRAWEVERY) {
X      /* Create a histogram of the output array */
X      for (i=0; i<256; i++) hist[i] = 0;
X      for (i=0; i<XSIZE; i++)
X         for (j=0; j<YSIZE; j++) hist[t[src][i][j]]++;
X
X      /* Starting from the highest altitude, move down until number of */
X      /* squares above water is slightly greater than the exact goal */
X      goal = XSIZE * YSIZE;
X      goal = (goal * (100 - HYDROPCT)) / 100;
X      for (zcoast=255, i=0; zcoast>0; zcoast--)
X         if ((i += hist[zcoast]) > goal) break;
X
X      /* If the new coast level is zero, then there wasn't enough land */
X      /* to meet the goal, even going right down to the ocean floor.  The */
X      /* only possible result is to panic since the goal can't be met. */
X      if (!zcoast) panic ("Scaled till oceans dried up");
X      ZCOAST = zcoast; }
X
X   if (PRINTMODE != PRINTMODE_SHORT) putmat ("LAND", -1, PRINTMODE, t[src], 0);
X   else {
X      for (i=0; i<XSIZE; i++) for (j=0; j<YSIZE; j++) {
X         if (t[src][i][j] < ZCOAST) sk[i][j] = 0;
X         else if (t[src][i][j] > ZMOUNTAIN) sk[i][j] = 2;
X         else sk[i][j] = 1; }
X      putmat ("LAND", -1, PRINTMODE, sk, 0); }
X   return (0); }
X
X
Xdouble greyscale (x) int x; {
X   /* Called by the PostScript print routine, this function simply computes
X   the intensity from 0-1 corresponding to the altitude 0-255 */
X   if (x < ZCOAST) return ((float) 0);
X   return (1.0 - ((x > 128) ? 128 : x) / 128.0); }
X
X
Xinit (s) char *s; {
X   /* This is the catchall function that initializes everything.  First,
X   it calls getparams() in fileio.c to allow the user to set parameters.  Next,
X   it links together the plates onto the free list and starts the used list
X   at empty.  The first plate is created by a fractal technique and then
X   improved.  Finally, the fractal is copied to the data array and drawn.
X   There are two kinds of improvement done here.  First, islands are
X   eliminated by segmenting the blob and erasing all the regions except
X   for the biggest.  Second, oceans inside the blob (holes) are eliminated
X   by segmenting the _ocean_ and filling in all regions except the biggest. */
X 
X   int besti, x; register int i, j;
X 
X   if (s) if (*s) getparams (s); fileinit ();
X 
X   for (i=1; i<MAXPLATE; i++) p[i].next = i + 1;
X   p[MAXPLATE-1].next = 0;
X   pavail = 1; phead = 0;
X 
X   /* Allocate a plate structure for the first plate and make a blob */
X   x = palloc (); makefrac (0, x);
X
X   /* Segment m[0] looking for x, set besti to the largest region, */
X   /* and zero out all the other regions.  This eliminates islands. */
X   besti = singlefy (0, x);
X   if (besti > 0) for (i=1; i<XSIZE; i++) for (j=1; j<YSIZE; j++)
X      if (kid[r[i][j]] != besti) m[0][i][j] = 0;
X 
X   /* Segment m[0] looking for 0 (ocean), set besti to the largest region, */
X   /* and fill in all the other regions.  This eliminates holes in the blob. */
X   besti = singlefy (0, 0);
X   if (besti > 0) for (i=1; i<XSIZE; i++) for (j=1; j<YSIZE; j++)
X      if (kid[r[i][j]] != besti) m[0][i][j] = x;
X 
X   /* Fill the topo structure with the blob shape while finding its area */
X   for (i=0; i<XSIZE; i++) for (j=0; j<YSIZE; j++)
X      if (m[0][i][j]) { t[0][i][j] = ZINIT; p[x].area++; }
X 
X   /* Draw the blob */
X   if (DRAWEVERY) draw (DRAW_TEC, LINE_NONE, t[0], 0); }
END_OF_src/tec1.c
if test 10750 -ne `wc -c <src/tec1.c`; then
    echo shar: \"src/tec1.c\" unpacked with wrong size!
fi
# end of overwriting check
fi
if test -f src/tec2.c -a "${1}" != "-c" ; then 
  echo shar: Will not over-write existing file \"src/tec2.c\"
else
echo shar: Extracting \"src/tec2.c\" \(14644 characters\)
sed "s/^X//" >src/tec2.c <<'END_OF_src/tec2.c'
X/* This program is Copyright (c) 1991 David Allen.  It may be freely
X   distributed as long as you leave my name and copyright notice on it.
X   I'd really like your comments and feedback; send e-mail to
X   allen at viewlogic.com, or send us-mail to David Allen, 10 O'Moore Ave,
X   Maynard, MA 01754. */
X
X/* This file contains the function trysplit(), which is called from
X   onestep() in tec1.c, and its subfunctions.  One of its subfunctions,
X   segment(), is also called from init() in tec1.c.   Trysplit is the
X   function in charge of splitting one plate into smaller plates. */
X
X
X#include "const.h"
X#include "tec.h"
X
X#define PI 3.14159
X#define TWOPI 6.28318
X#define TWOMILLIPI 0.00628318
X
X/* RIFTMARK is the temporary indicator placed in the arrays to indicate
X   the squares a rift has just appeared.  The function stoprift() puts
X   them in, and trysplit() takes them out before anybody can see them. */
X#define RIFTMARK -1
X
X/* These are all defined in tec1.c */
Xextern char m[2][MAXX][MAXY], r[MAXX][MAXY], kid[MAXFRAG];
Xextern unsigned char t[2][MAXX][MAXY];
Xextern int karea[MAXFRAG], tarea[MAXPLATE], ids[MAXPLATE], step;
Xextern struct plate p [MAXPLATE];
X
Xtrysplit (src) int src; {
X   /* Trysplit is called at most once per step in only 40% of the steps.
X   It first draws a rift on one of the plates, then it segments the result
X   into some number of new plates and some splinters.  If exactly two new
X   non-splinter plates are found, new plate structures are allocated, new
X   dx and dy values are computed, and the old plate is freed.  If anything
X   goes wrong, the rift is erased from the array, returning the array to its
X   previous state.  The functions newrift, segment and newplates do most
X   of the work. */
X
X   register int i, j, a; int count, old, frag, reg;
X
X   if (newrift (src, &old)) if (segment (src, old, &frag, &reg)) if (reg > 1) {
X
X         /* Set tarea[i] to areas of the final segmented regions */
X         for (i=0; i<MAXPLATE; i++) tarea[i] = 0;
X         for (i=1; i<=frag; i++) tarea[kid[i]] += karea[i];
X
X         /* Give up unless exactly two regions are large enough */
X         for (i=1, count=0; i<=reg; i++) if (tarea[i] > MAXSPLINTER) count++; 
X         if (count == 2) {
X
X            /* Compute new dx,dy; update m with the ids of the new plates */
X            newplates (src, old);
X            for (i=0, count=0; i<XSIZE; i++) for (j=0; j<YSIZE; j++) {
X               if (a = r[i][j]) m[src][i][j] = ids[kid[a]];
X               if (m[src][i][j] == RIFTMARK) {
X                  m[src][i][j] = 0; t[src][i][j] = 0; } }
X            pfree (old); return (0); } }
X
X   /* If execution reaches here, the split operation failed; remove rift */
X   if (old) for (i=0; i<XSIZE; i++) for (j=0; j<YSIZE; j++)
X      if (m[src][i][j] == RIFTMARK) {
X         m[src][i][j] = old; p[old].area++; }
X   return (0); }
X
X
Xnewrift (src, old) int src, *old; {
X   /* This function randomly picks a center for a new rift, and draws in
X   a curving line until the line hits either the coast or another plate.
X   If another plate is hit, the rift is invalid and the function returns 0.
X   To find a center, the function generates random x,y values until it
X   finds one that is at least RIFTDIST squares from any ocean square.  If a
X   center is found, a random angle is generated; the rift will pass through
X   the center at that angle.  Next, halfrift() is called twice.  Each call
X   generates the rift leaving the center in one direction.  If everything
X   works out, the function returns the id of the plate the rift is on. */
X
X   int x, y, lx, rx, ty, by, i, j, tries = 0, which; double tt;
X
X   /* Generate a random x, y value */
X   getctr: if (tries > MAXCTRTRY) { *old = 0; return (0); }
X   x = rnd (XSIZE); y = rnd (YSIZE);
X
X   /* If the location is ocean, try again */
X   if (!m[src][x][y]) { tries++; goto getctr; }
X
X   /* Set lx,rx,ty,by to the coordinate values of a box 2*RIFTDIST on a side */
X   /* centered on the center.  Clip the values to make sure they are on the */
X   /* array.  Loop through the box; if a point is ocean, try another center. */
X   lx = (x < RIFTDIST) ? 0 : x - RIFTDIST;
X   rx = (x > XSIZE - RIFTDIST - 1) ? XSIZE - 1 : x + RIFTDIST;
X   ty = (y < RIFTDIST) ? 0 : y - RIFTDIST;
X   by = (y > YSIZE - RIFTDIST - 1) ? YSIZE - 1 : y + RIFTDIST;
X   for (i=lx; i<rx; i++) for (j=ty; j<by; j++)
X      if (!m[src][i][j]) { tries++; goto getctr; }
X
X   /* Found a good center, on plate `which'.  Put a rift indicator in the */
X   /* center.  Generate a random angle t, which is really an integer in the */
X   /* range 0-499 multiplied by 2 PI / 1000.  Call halfrift once for each */
X   /* half of the rift; t is the initial angle for the first call, and */
X   /* t + PI is the initial angle for the second call.  If halfrift() */
X   /* returns zero, abort and return 0; otherwise, return the plate id. */
X   which = m[src][x][y]; m[src][x][y] = RIFTMARK;
X   tt = rnd (500) * TWOMILLIPI;
X   if (!halfrift (src, x, y, which, tt)) { *old = which; return (0); }
X   tt += PI; if (tt > TWOPI) tt -= TWOPI;
X   if (!halfrift (src, x, y, which, tt)) { *old = which; return (0); }
X   *old = which; return (1); }
X
X
Xhalfrift (src, cx, cy, which, tt) int src, cx, cy, which; double tt; {
X   /* Draw a rift from cx,cy on plate `which' at angle t.  At the beginning,
X   digitize the angle using Bresenham's algorithm; once in a while thereafter,
X   modify the angle randomly and digitize it again.  For each square travelled,
X   call stoprift() to see if the rift has left the plate. */
X
X   int ddx, ddy, rdx, rdy, draw, i, a; double dx, dy, adx, ady;
X
X   checkmouse ();
X   /* For-loop against SIZE to guard against infinite loops */
X   for (i=0; i<XSIZE; i++) {
X
X      /* If first square or 1/6 chance at each step, digitize */
X      if (!i || !rnd (BENDEVERY)) {
X
X         /* If not first step, modify angle a little */
X         if (i) tt = tt + (rnd (BENDBY<<1) * TWOMILLIPI) - (BENDBY*TWOMILLIPI);
X         if (tt > TWOPI) tt -= TWOPI; if (tt < 0) tt += TWOPI;
X
X         /* Compute dx and dy, scaled so that larger is exactly +1.0 or -1.0 */
X         dy = sin (tt); dx = cos (tt); adx = ABS(dx); ady = ABS(dy);
X         if (adx > ady) { dy = dy / adx; dx = (dx < 0) ? -1.0: 1.0; }
X         else { dx = dx / ady; dy = (dy < 0) ? -1.0: 1.0; }
X
X         /* Convert to integer value and initialize remainder */
X         /* for each coordinate to half value */
X         ddx = REALSCALE * dx; ddy = REALSCALE * dy;
X         rdx = ddx >> 1; rdy = ddy >> 1; }
X
X      /* Main part of loop, draws one square along line.  The basic idea */
X      /* of Bresenham's algorithm is that if the slope of the line is less */
X      /* than 45 degrees, each time you step one square in X and maybe step */
X      /* one square in Y.  If the slope is greater than 45, step one square */
X      /* in Y and maybe one square in X.  Here, if the slope is less than 45 */
X      /* then ddx == REALSCALE (or -REALSCALE) and the first call to */
X      /* stoprift() is guaranteed.  If stoprift returns <0, all is ok; */
X      /* if zero, the rift ran into the ocean, so stop now; if positive, the */
X      /* rift ran into another plate, which is a perverse condition and the */
X      /* rift must be abandoned.  */
X      rdx += ddx; rdy += ddy;
X      if (rdx >=  REALSCALE) { cx++; rdx -= REALSCALE; draw = 1; }
X      if (rdx <= -REALSCALE) { cx--; rdx += REALSCALE; draw = 1; }
X      if (draw == 1) {
X         a = stoprift (src, cx, cy, which); if (a >= 0) return (!a); }
X      if (rdy >=  REALSCALE) { cy++; rdy -= REALSCALE; draw = 2; }
X      if (rdy <= -REALSCALE) { cy--; rdy += REALSCALE; draw = 2; }
X      if (draw == 2) {
X         a = stoprift (src, cx, cy, which); if (a >= 0) return (!a); } }
X   return (1); }
X
X
Xstoprift (src, x, y, which) int src, x, y, which; {
X   /* This function is called once for each square the rift enters.  It
X   puts a rift marker into m[src] and decides whether the rift can go on.
X   It looks at all four adjacent squares.  If one of them contains ocean
X   or another plate, return immediately so that the rift stops (if ocean)
X   or aborts (if another plate).  If none of them do, then check to make
X   sure the point is within underscan boundaries.  If so, return ok. */
X
X   register int w, a;
X
X   w = which; p[w].area--; m[src][x][y] = RIFTMARK;
X   a = m[src][x][y+1]; if ((a != w) && (a!= RIFTMARK)) return (a != 0);
X   a = m[src][x][y-1]; if ((a != w) && (a!= RIFTMARK)) return (a != 0);
X   a = m[src][x+1][y]; if ((a != w) && (a!= RIFTMARK)) return (a != 0);
X   a = m[src][x-1][y]; if ((a != w) && (a!= RIFTMARK)) return (a != 0);
X   if ((x < UNDERSCAN) || (x > XSIZE - UNDERSCAN)) return (1);
X   if ((y < UNDERSCAN) || (y > YSIZE - UNDERSCAN)) return (1);
X   return (-1); }
X
X
Xsegment (src, match, frag, reg) int src, match, *frag, *reg; {
X   /* This routine implements a standard binary-blob segmentation.  It looks
X   at the array m[src]; match is the value of the blob, and everything else
X   is background.  The result is placed into array r and vectors kid and karea.
X   One 8-connected region can be made up of many fragments; each fragment is
X   assigned a unique index.  Array r contains the frag indices k, while kid[k]
X   is the region frag k belongs to and karea[k] is the area of frag k.
X   Variables frag and reg are set on output to the number of fragments and
X   regions found during the segmentation.  The private vector kk provides one
X   level of indirection for merging fragments; fragment k is merged with
X   fragment kk[k] where kk[k] is the smallest frag index in the region. */
X
X   register int i, j, k, k1, k2, k3, l;
X   char kk [MAXFRAG];
X
X   /* Initialize all frag areas to zero and every frag to merge with itself */
X   for (k=0; k<MAXFRAG; k++) { kk[k] = k; karea[k] = 0; }
X   checkmouse ();
X
X   /* Look at every point in the array */
X   for (k=0, i=0; i<XSIZE; i++) for (j=0; j<YSIZE; j++) {
X
X      /* If too many fragments, give up */
X      if (k == MAXFRAG) return (0);
X
X      /* If this square isn't part of the blob, try the next square */
X      if (m[src][i][j] != match) { r[i][j] = 0; goto bottom; }
X
X      /* It is part of the blob.  Set k1 to the frag id of the square to */
X      /* its left, and set k2 to the frag id of the square above it.  Note */
X      /* that because of the for-loop direction, both of these squares have */
X      /* already been processed. */
X      k1 = i ? kk [r [i-1] [j]] : 0; k2 = j ? kk [r [i] [j-1]] : 0;
X
X      /* If k1 and k2 are both background, start a new fragment */
X      if (!k1 && !k2) { r[i][j] = ++k; karea[k]++; goto bottom; }
X
X      /* If k1 and k2 are part of the same frag, add this square to it */
X      if (k1 && (k1 == k2)) { r[i][j] = k1; karea[k1]++; goto bottom; }
X
X      /* If k1 and k2 belong to different frags, merge them by finding */
X      /* all the frags merged with max(k1,k2) and merging them instead */
X      /* with min(k1,k2).  Add k to that fragment as well. */
X      if (k1 && k2) {
X         if (k2 < k1) { k3 = k1; k1 = k2; k2 = k3; }
X         for (l=1; l<=k; l++) if (kk[l] == k2) kk[l] = k1;
X         r[i][j] = k1; karea[k1]++; goto bottom; }
X
X      /* Default case is that one of k1,k2 is a fragment and the other is */
X      /* background.  Add k to the fragment. */
X      k3 = (k1) ? k1 : k2; r[i][j] = k3; karea[k3]++;
X   bottom: continue; }
X
X   /* Set up vector kid to map from fragments to regions by using i to count */
X   /* unique groups of fragments.  A unique group of fragments is */
X   /* characterized by kk[k] == k; otherwise, frag k is merged with some */
X   /* other fragment. */
X   for (i=0, j=1; j<=k; j++) {
X      if (j == kk[j]) kid[j] = ++i;
X      else kid[j] = kid [kk [j]]; }
X
X   /* Make sure the id of the background is zero; set up return values */
X   kid[0] = 0; *frag = k; *reg = i; return (1); }
X
X
X
Xnewplates (src, old) int src, old; {
X   /* Compute new dx and dy values for plates right after fragmentation.  This
X   function looks at the rift markers in m[src]; variable old is the index of
X   the plate from which the new plates were created.  For each plate adjacent
X   to the rift, this function subtracts the number of plate squares to the left
X   of the rift from the number to the right; this gives some indication of
X   whether the plate should move left or right, and how fast.  The same is done
X   for squares above and below the rift.  The results are put into dx[] and
X   dy[].  At this point some unscaled movement vector is available for both of
X   the new plates.  The vectors are then scaled by the relative sizes of the
X   plates.  The idea is that if one plate is much larger than the other, the
X   small one should move faster.  New plate structures are allocated for the
X   new plates, and the computed dx and dy values are put in them. */
X
X   int dx[MAXPLATE], dy[MAXPLATE];
X   register int i, j, a; int totarea=0, maxmag=0; double scale, b;
X
X   for (i=1; i<MAXPLATE; i++) { dx[i] = 0; dy[i] = 0; ids[i] = 0; }
X   checkmouse ();
X
X   /* For every point in the array, set a to the region id (kid is the */
X   /* lookup table and r contains frag indices); if a is nonzero and */
X   /* the rift is adjacent, adjust counters appropriately */
X   for (i=0; i<XSIZE; i++) for (j=0; j<YSIZE; j++) if (a = kid[r[i][j]]) {
X      if ((i-1 > -1)    && (m[src][i-1][j] == RIFTMARK)) (dx[a])++;
X      if ((i+1 < XSIZE) && (m[src][i+1][j] == RIFTMARK)) (dx[a])--;
X      if ((j-1 > -1)    && (m[src][i][j-1] == RIFTMARK)) (dy[a])++;
X      if ((j+1 < XSIZE) && (m[src][i][j+1] == RIFTMARK)) (dy[a])--; }
X
X   /* For those regions larger than splinters (tarea is set up in trysplit), */
X   /* allocate a new plate structure and initialize its area; compute the */
X   /* magnitude of the dx dy vector and remember the maximum magnitude; also */
X   /* record the total area of new regions */
X   for (i=1; i<MAXPLATE; i++) if (tarea[i] > MAXSPLINTER) {
X      ids[i] = palloc (); p[ids[i]].area = tarea[i];
X      totarea += tarea[i];
X      a =sqrt ((double) ((dx[i]*dx[i]) + (dy[i]*dy[i])));
X      if (a > maxmag) maxmag = a; }
X
X   /* Generate a random speed and predivide so that all speeds computed */
X   /* below are less than the random speed. */
X   scale = (double) (rnd (SPEEDRNG) + SPEEDBASE) / (maxmag * totarea);
X
X   /* Compute the dx and dy for each new plate; note that the speed the */
X   /* plate was moving at before splitting is given by p[old].odx,ody */
X   /* but those must be multiplied by MR to get the actual values */
X   for (i=1; i<MAXPLATE; i++) if (ids[i]) {
X      b = scale * (totarea - tarea[i]);
X      p[ids[i]].odx = p[old].odx * MR [p[old].age] + dx[i] * b;
X      p[ids[i]].ody = p[old].ody * MR [p[old].age] + dy[i] * b; } }
END_OF_src/tec2.c
if test 14644 -ne `wc -c <src/tec2.c`; then
    echo shar: \"src/tec2.c\" unpacked with wrong size!
fi
# end of overwriting check
fi
if test -f src/tec3.c -a "${1}" != "-c" ; then 
  echo shar: Will not over-write existing file \"src/tec3.c\"
else
echo shar: Extracting \"src/tec3.c\" \(14070 characters\)
sed "s/^X//" >src/tec3.c <<'END_OF_src/tec3.c'
X/* This program is Copyright (c) 1991 David Allen.  It may be freely
X   distributed as long as you leave my name and copyright notice on it.
X   I'd really like your comments and feedback; send e-mail to
X   allen at viewlogic.com, or send us-mail to David Allen, 10 O'Moore Ave,
X   Maynard, MA 01754. */
X
X#include "const.h"
X#include "tec.h"
X
X/* These are all defined in tec1.c */
Xextern char m[2][MAXX][MAXY], r[MAXX][MAXY], e[MAXX][MAXY], kid[MAXFRAG],
X   mm[MAXPLATE][MAXPLATE];
Xextern unsigned char t[2][MAXX][MAXY];
Xextern int step, phead, tarea[MAXPLATE], karea[MAXFRAG];
Xextern struct plate p [MAXPLATE];
X
X
Xmakefrac (src, match) int src, match; {
X   /* This function uses a very simple fractal technique to draw a blob.  Four
X   one-dimensional fractals are created and stored in array x, then the
X   fractals are superimposed on a square array, summed and thresholded to
X   produce a binary blob.  Squares in the blob are set to the value in `match'.
X   A one-dimensional fractal of length n is computed like this.  First,
X   set x [n/2] to some height and set the endpoints (x[0] and x[n]) to 0.
X   Then do log-n iterations.  The first iteration computes 2 more values:
X   x[n/4] = average of x[0] and x[n/2], plus some random number, and
X   x[3n/4] = average of x[n/2] and x[n], plus some random number.  The second
X   iteration computes 4 more values (x[n/8], x[3n/8], ...) and so on.  The
X   random number gets smaller by a factor of two each time also.
X 
X   Anyway, you wind up with a number sequence that looks like the cross-section
X   of a mountain.  If you sum two fractals, one horizontal and one vertical,
X   you get a 3-d mountain; but it looks too symmetric.  If you sum four,
X   including the two 45 degree diagonals, you get much better results. */
X 
X   register int xy, dist, n, inc, i, j, k; char x[4][65];
X   int xofs, yofs, xmin, ymin, xmax, ymax, bloblevel, hist[256];
X 
X   /* Compute offsets to put center of blob in center of the world, and
X      compute array limits to clip blob to world size */
X   xofs = (XSIZE - 64) >> 1; yofs = (YSIZE - 64) >> 1;
X   if (xofs < 0) { xmin = -xofs; xmax = 64 + xofs; }
X   else { xmin = 0; xmax = 64; }
X   if (yofs < 0) { ymin = -yofs; ymax = 64 + yofs; }
X   else { ymin = 0; ymax = 64; }
X 
X   for (xy=0; xy<4; xy++) {
X      /* Initialize loop values and fractal endpoints */
X      x [xy] [0] = 0; x [xy] [64] = 0; dist = 32;
X      x [xy] [32] = 24 + rnd (16); n = 2; inc = 16;
X 
X      /* Loop log-n times, each time halving distance and doubling iterations */
X      for (i=0; i<5; i++, dist>>=1, n<<=1, inc>>=1)
X         for (j=0, k=0; j<n; j++, k+=dist)
X            x[xy][k+inc] = ((x[xy][k]+x[xy][k+dist])>>1) + rnd (dist) - inc; }
X 
X   /* Superimpose fractals into the output array.  x[0] is horizontal, x[1] */
X   /* vertical, x[2] diagonal from top left to bottom right, x[3] diagonal */
X   /* from TR to BL.  While superimposing, create a histogram of the values.*/
X   for (i=0; i<256; i++) hist[i] = 0;
X   for (i=xmin; i<xmax; i++) for (j=ymin; j<ymax; j++) {
X      k = x[0][i] + x[1][j] + x[2][(i - j + 64) >> 1] + x[3][(i + j) >> 1];
X      if (k < 0) k = 0; if (k > 255) k = 255;
X      hist[k]++; m[src][i+xofs][j+yofs] = k; }
X
X   /* Pick a threshhold to get as close to the goal number of squares as */
X   /* possible, then go back through the array and adjust it */
X   bloblevel = XSIZE * YSIZE * (100 - HYDROPCT) / 100;
X   for (k=255, i=0; k>=0; k--) if ((i += hist[k]) > bloblevel) break;
X   for (i=xmin; i<xmax; i++) for (j=ymin; j<ymax; j++)
X      m[src][i+xofs][j+yofs] = (m[src][i+xofs][j+yofs] > k) ? match : 0; }
X 
X 
Xsinglefy (src, match) int src, match; {
X   /* This is a subfunction of init() which is called twice to improve the
X   fractal blob.  It calls segment() and then interprets the result.  If
X   only one region was found, no improvement is needed; otherwise, the
X   area of each region must be computed by summing the areas of all its
X   fragments, and the index of the largest region is returned. */
X 
X   int i, reg, frag, besti, besta;
X 
X   segment (src, match, &frag, &reg);
X   if (reg == 1) return (-1); /* No improvement needed */
X 
X   /* Initialize the areas to zero, then sum frag areas */
X   for (i=1; i<=reg; i++) tarea[i] = 0;
X   for (i=1; i<=frag; i++) tarea [kid[i]] += karea [i];
X 
X   /* Pick largest area of all regions and return it */
X   for (i=1, besta=0, besti=0; i<=reg; i++)
X      if (besta < tarea[i]) { besti = i; besta = tarea[i]; }
X   return (besti); }
X 
X 
Xnewdxy () {
X   /* For each plate, compute how many squares it should move this step.
X   Multiply the plate's basic movement vector odx,ody by the age modifier
X   MR[], then add the remainders rx,ry from the last move to get some large
X   integers.  Then turn the large integers into small ones by dividing by
X   REALSCALE and putting the remainders back into rx,ry.  This function also
X   increases the age of each plate, but doesn't let the age of any plate
X   go above MAXLIFE.  This is done to make sure that MR[] does not need to
X   be a long vector. */
X 
X   register int i, a;
X 
X   /* If there is only a single supercontinent, anchor it */
X   for (i=phead, a=0; i; i=p[i].next, a++);
X   if (a == 1) if (p[phead].odx || p[phead].ody) {
X      p[phead].odx = 0; p[phead].ody = 0; }
X
X   for (i=phead; i; i=p[i].next) {
X      a = (p[i].odx * MR[p[i].age]) + p[i].rx;
X      p[i].dx = a / REALSCALE; p[i].rx = a % REALSCALE;
X      a = (p[i].ody * MR[p[i].age]) + p[i].ry;
X      p[i].dy = a / REALSCALE; p[i].ry = a % REALSCALE;
X      if (p[i].age < MAXLIFE-1) (p[i].age)++; } }
X 
X 
Xmove (src, dest) int src, dest; {
X   /* This function moves all the plates that are drifting.  The amount to
X   move by is determined in newdxy().  The function simply steps through
X   every square in the array; if there's a plate in a square, its new location
X   is found and the topography is moved there.  Overlaps between plates are
X   detected and recorded so that merge() can resolve the collision; mountain
X   growing is performed.  If two land squares wind up on top of each other,
X   folded mountains are produced.  If a land square winds up where ocean was
X   previously, that square is the leading edge of a continent and grows a
X   mountain by subsuming the ocean basin. */
X 
X   register int i, j; int a, b, c, x, y;
X 
X   /* Clear out the merge matrix and the destination arrays */
X   for (i=1; i<MAXPLATE; i++) for (j=1; j<MAXPLATE; j++) mm[i][j] = 0;
X   for (i=0; i<XSIZE; i++) for (j=0; j<YSIZE; j++) {
X      m[dest][i][j] = 0; t[dest][i][j] = 0; }
X 
X   checkmouse ();
X   /* Look at every square which belongs to a plate */
X   for (i=0; i<XSIZE; i++) for (j=0; j<YSIZE; j++) if ((a = m[src][i][j]) > 0) {
X 
X      /* Add the plate's dx,dy to the position to get the square's new */
X      /* location; if it is off the map, throw it away */
X      x = p[a].dx + i; y = p[a].dy + j;
X      if ((x >= XSIZE) || (x < 0) || (y >= YSIZE) || (y < 0)) p[a].area--;
X      else { /* It IS on the map */
X
X         /* If the destination is occupied, remove the other guy but */
X         /* remember that the two plates overlapped; set the new height */
X         /* to the larger height plus half the smaller. */
X         if (c = m[dest][x][y]) {
X            (mm[a][c])++; (p[c].area)--;
X            b = t[src][i][j]; c = t[dest][x][y];
X            t[dest][x][y] = (b > c) ? b + (c>>1) : c + (b>>1); }
X
X         /* The destination isn't occupied.  Just copy the height. */
X         else t[dest][x][y] = t[src][i][j];
X
X         /* If this square is over ocean, increase its height. */
X         if (t[src][x][y] < ZCOAST) t[dest][x][y] += ZSUBSUME;
X
X         /* Plate A now owns this square */
X         m[dest][x][y] = a; } } }
X 
X 
Xmerge (dest) int dest; {
X   /* Since move has set up the merge matrix, most of the work is done.  This
X   function calls bump once for each pair of plates which are rubbing; note
X   that a and b below loop through the lower diagonal part of the matrix.
X   One subtle feature is that a plate can bump with several other plates in
X   a step; suppose that the plate is merged with the first plate it bumped.
X   The loop will try to bump the vanished plate with the other plates, which
X   would be wrong.  To avoid this, the lookup table lut is used to provide
X   a level of indirection.  When a plate is merged with another, its lut
X   entry is changed to indicate that future merges with the vanished plate
X   should be applied to the plate it has just been merged with. */
X 
X   char lut[MAXPLATE]; int a, aa, b, bb, i;
X 
X   for (a=1; a<MAXPLATE; a++) lut[a] = a;
X   for (a=2; a<MAXPLATE; a++) for (b=1; b<a; b++) if (mm[a][b] || mm[b][a]) {
X      aa = lut [a]; bb = lut[b];
X      if (aa != bb) if (bump (dest, aa, bb)) {
X         lut[aa] = bb;
X         for (i=1; i<MAXPLATE; i++) if (lut[i] == aa) lut[i] = bb; } } }
X 
X 
Xbump (dest, a, b) int dest, a, b; {
X   /* Plates a and b have been moved on top of each other by some amount;
X   alter their movement rates for a slow collision, possibly merging them.
X   The collision "strength" is a ratio of the area overlap (provided by
X   move ()) to the total area of the plates involved.  A fraction of each
X   plate's current movement vector is subtracted from the movement vector
X   of the other plate.  If the two vectors are now within some tolerance
X   of each other, they are almost at rest so merge them with each other. */
X 
X   double maa, mab, ta, tb, rat, area; register int i, j, x;
X 
X   checkmouse();
X   /* Find a ratio describing how strong the collision is */
X   x = mm[a][b] + mm[b][a]; area = p[a].area + p[b].area;
X   rat = x / (MAXBUMP + (area / 20)); if (rat > 1.0) rat = 1.0;
X 
X   /* Do some math to update the move vectors.  This looks complicated */
X   /* because a plate's actual movement vector must be multiplied by */
X   /* MR[age], and because I have rewritten the equations to maximize */
X   /* use of common factors.  Trust me, it's just inelastic collision. */
X   maa = p[a].area * MR[p[a].age]; mab = p[b].area * MR[p[b].age];
X   ta = MR[p[a].age] * area;
X   p[a].odx = (p[a].odx * maa + p[b].odx * mab * rat) / ta;
X   p[a].ody = (p[a].ody * maa + p[b].ody * mab * rat) / ta;
X   tb = MR[p[b].age] * area;
X   p[b].odx = (p[b].odx * mab + p[a].odx * maa * rat) / tb;
X   p[b].ody = (p[b].ody * mab + p[a].ody * maa * rat) / tb;
X 
X   /* For each axis, compute the remaining relative velocity.  If it is */
X   /* too large, return without merging the plates */
X   if (ABS (p[a].odx*MR[p[a].age] - p[b].odx*MR[p[b].age]) > BUMPTOL) return(0);
X   if (ABS (p[a].ody*MR[p[a].age] - p[b].ody*MR[p[b].age]) > BUMPTOL) return(0);
X 
X   /* The relative velocity is small enough, so merge the plates.  Replace */
X   /* all references to a with b, free a, and tell merge() a was freed. */
X   for (i=0; i<XSIZE; i++) for (j=0; j<YSIZE; j++)
X      if (m[dest][i][j] == a) m[dest][i][j] = b;
X   p[b].area += p[a].area; pfree (a);
X   return (a); }
X 
X 
Xerode (dest) int dest; {
X   /* This function takes the topography in t[dest] and smooths it, lowering
X   mountains and raising lowlands and continental margins.  It does this by
X   stepping across the entire array and doing a computation once for each
X   pair of 8-connected pixels.  The computation is done by onerode(), below.
X   The computation result for a pair is a small delta for each square, which
X   is summed in the array e.  When the computation is finished, the delta
X   is applied; if this pushes an ocean square high enough, it is added to
X   an adjacent plate if one can be found.  Also, if a land square is eroded
X   low enough, it is turned into ocean and removed from its plate. */
X 
X   register int i, j, x, z, xx;
X 
X   /* Zero out the array for the deltas first */
X   for (i=0; i<XSIZE; i++) for (j=0; j<YSIZE; j++) e[i][j] = 0;
X   checkmouse();
X
X   /* Step across the entire array; each pixel is adjacent to 8 others, and */
X   /* it turns out that if four pairs are considered for each pixel, each */
X   /* pair is considered exactly once.  This is important for even erosion */
X   for (i=1; i<XSIZE; i++) for (j=1; j<YSIZE; j++) {
X      onerode (dest, i, j,  0, -1);
X      onerode (dest, i, j, -1, -1);
X      onerode (dest, i, j, -1,  0);
X      if (i < XSIZE-1) onerode (dest, i, j, -1, 1); }
X 
X   /* Now go back across the array, applying the delta values from e[][] */
X   for (i=0; i<XSIZE; i++) for (j=0; j<YSIZE; j++) {
X      z = t[dest][i][j] + e[i][j]; if (z < 0) z = 0; if (z > 255) z = 255;
X 
X      /* If the square just rose above shelf level, look at the four */
X      /* adjacent squares.  If one is a plate, add the square to that plate */
X      if ((z >= ZSHELF) && (t[dest][i][j] < ZSHELF)) { xx = 0;
X         if (i > 1)       if (x = m[dest][i-1][j]) xx = x;
X         if (i < XSIZE-1) if (x = m[dest][i-1][j]) xx = x;
X         if (j > 1)       if (x = m[dest][i][j-1]) xx = x;
X         if (j < YSIZE-1) if (x = m[dest][i][j+1]) xx = x;
X         if (xx) { p[xx].area++; m[dest][i][j] = xx; } }
X 
X      /* Add the increment to the old value; if the square is lower than */
X      /* shelf level but belongs to a plate, remove it from the plate */
X      t[dest][i][j] = z;
X      if ((z < ZSHELF) && (x = m[dest][i][j])) {
X         p[x].area--; m[dest][i][j] = 0; } } }
X
X
Xonerode (dest, i, j, di, dj) int dest, i, j, di, dj; {
X   /* This function is called once per pair of squares in the array.  The
X   amount each square loses to an adjacent but lower square in each step is
X   one-eighth the difference in altitude.  This is coded as a shift right 3
X   bits, but since -1 >> 3 is still -1, the code must be repeated to avoid
X   shifting negative numbers.  Also, since erosion is reduced below the
X   waterline, if an altitude is lower than ZERODE, ZERODE is used instead. */
X
X   register int z, t1, t2;
X
X   t1 = t[dest][i][j]; t2 = t[dest][i+di][j+dj]; z = 0;
X   if ((t1 > t2) && (t1 > ZERODE)) {
X      if (t2 < ZERODE) t2 = ZERODE;
X      z = ((t1 - t2 + ERODERND) >> 3); }
X   else if ((t2 > t1) && (t2 > ZERODE)) {
X      if (t1 < ZERODE) t1 = ZERODE;
X      z = -((t2 - t1 + ERODERND) >> 3); }
X   if (z) { e[i][j] -= z; e[i+di][j+dj] += z; } }
END_OF_src/tec3.c
if test 14070 -ne `wc -c <src/tec3.c`; then
    echo shar: \"src/tec3.c\" unpacked with wrong size!
fi
# end of overwriting check
fi
if test -f src/globe.c -a "${1}" != "-c" ; then 
  echo shar: Will not over-write existing file \"src/globe.c\"
else
echo shar: Extracting \"src/globe.c\" \(3176 characters\)
sed "s/^X//" >src/globe.c <<'END_OF_src/globe.c'
X/* This program is Copyright (c) 1991 David Allen.  It may be freely
X   distributed as long as you leave my name and copyright notice on it.
X   I'd really like your comments and feedback; send e-mail to
X   allen at viewlogic.com, or send us-mail to David Allen, 10 O'Moore
X   Avenue, Maynard, MA 01754. */
X
X/* This file contains a spinning globe animation */
X
X#include "const.h"
X#define N ((MAXX / 2) - 1)
X#define AREA (MAXX * MAXX)
X#define RADIUS 45
X#define PI 3.14159
X#define TWOPI (2.0 * PI)
X#define HALFPI (PI / 2.0)
X#define SET(n,x,y,i,j) m[n][(x)+N][(y)+N] = m[0][(i)+N][(j)+N]
X
Xunsigned char m[21][MAXX][MAXY];
Xint rx[] = {0, 0, 0, 0, 0}, ry[] = {0, N, 0, N, 0};
Xint xofs, prime, xflip, sflip, sxflip, change[1], step = 0;
Xint MAXSTEP = 10000, PRINTMODE = PRINTMODE_SCALE, XSIZE = MAXX, YSIZE = MAXX;
Xint ZCOAST = 0;
X
X
Xinit (s) char *s; { int i;
X   fileinit ();
X   if (!s || !(*s)) panic ("no valid filename"); else getparams (s);
X   for (i=1, xofs=45; i<6; xofs-=10, i++) {
X      prime = 16-i; xflip = i+5;  sflip = 15+i; sxflip = 6-i; compute (); } }
X
X
Xonestep () { static int i = 0;
X   draw (DRAW_TEC, LINE_NONE, m[i], 0); i++; step++;
X   if (i == 5) i = 6; if (i == 16) i = 17; if (i == 21) i = 1; }
X
X
Xmainpar (s) char *s; { int vec [AREA], index = AREA; register int i, j, k;
X
X   if (CMP ("LAND")) {
X      getlvec (&index, vec, 0);
X      for (k=0, j=0; j<MAXX; j++) for (i=0; i<MAXX; i++, k++)
X         m[0][i][j] = (vec[k] > 16) ? vec[k] : 16;
X      return (1); }
X   return (0); }
X
X
Xcompute () {
X   register int i, j, top; int x, y;
X
X   rx[0] = xofs + N; rx[4] = rx[0]; rx[2] = xofs - N;
X   for (j=0; j<RADIUS; j++) {
X      checkmouse ();
X      top = sqrt ((double) (RADIUS * RADIUS - j * j + 0.5));
X      for (i=1-top; i<top; i++) {
X         point (i, j, &x, &y);
X         SET (prime,   i,  j,  x,  y); SET (prime,   i, -j,  x, -y);
X         SET (xflip,  -i,  j, -x,  y); SET (xflip,  -i, -j, -x, -y);
X         permute (x, y, &x, &y);
X         SET (sxflip,  i, -j, -x,  y); SET (sxflip,  i,  j, -x, -y);
X         SET (sflip,  -i, -j,  x,  y); SET (sflip,  -i,  j,  x, -y); } } }
X
X
Xpoint (x, y, i, j) int x, y, *i, *j; {
X   double r, theta, topx, topy, botx, boty; int bot, top;
X
X   r = asin (sqrt ((double)(x * x + y * y)) / RADIUS) * 2.0 / PI;
X   if (x || y) theta = atan2 ((double)y, (double)x);
X   else theta = 0;
X   if (theta <= 0) theta += TWOPI;
X   bot = 0; while (theta > HALFPI) { bot++; theta -= HALFPI; }
X   top = bot + 1; theta = theta / HALFPI;
X   mapr (bot, r, &botx, &boty); mapr (top, r, &topx, &topy);
X   *i = botx + theta * (topx - botx) + 0.5;
X   *j = boty + theta * (topy - boty) + 0.5;
X   if (*i >= N) *i = N-1; if (*j >= N) *j = N-1; }
X
X
Xmapr (n, r, x, y) int n; double r, *x, *y; {
X   *x = r * (rx[n] - xofs) + xofs;
X   *y = r * ry[n];
X   if (*x >= N) { *y = *x - N; *x = N; if (n == 4) *y = -(*y); } }
X
X
Xpermute (x, y, i, j) int x, y, *i, *j; {
X   if ((x >= 0) && (y >= 0)) { *i =  N - y - 1; *j =  x - N + 0; }
X   if ((x <  0) && (y >= 0)) { *i =  y - N + 0; *j = -N - x - 1; }
X   if ((x >= 0) && (y <  0)) { *i =  y + N + 0; *j =  N - x - 1; }
X   if ((x <  0) && (y <  0)) { *i = -N - y - 1; *j =  x + N + 0; } }
X
X
Xgreyscale (x) int x; { }
END_OF_src/globe.c
if test 3176 -ne `wc -c <src/globe.c`; then
    echo shar: \"src/globe.c\" unpacked with wrong size!
fi
# end of overwriting check
fi
echo shar: End of archive 4 \(of 4\).
cp /dev/null ark4isdone
MISSING=""
for I in 1 2 3 4 ; do
    if test ! -f ark${I}isdone ; then
	MISSING="${MISSING} ${I}"
    fi
done
if test "${MISSING}" = "" ; then
    echo You have unpacked all 4 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

exit 0 # Just in case...
-- 
Kent Landfield                   INTERNET: kent at sparky.IMD.Sterling.COM
Sterling Software, IMD           UUCP:     uunet!sparky!kent
Phone:    (402) 291-8300         FAX:      (402) 291-4362
Please send comp.sources.misc-related mail to kent at uunet.uu.net.



More information about the Comp.sources.misc mailing list