Return to compkl.c CVS log

Up to [CSRG BSD Unix] / 42BSD / games / trek

Annotation of 42BSD/games/trek/compkl.c, revision 1.1.1.1

1.1       root        1: #ifndef lint
                      2: static char sccsid[] = "@(#)compkl.c   4.2     (Berkeley)      5/27/83";
                      3: #endif not lint
                      4: 
                      5: # include      "trek.h"
                      6: 
                      7: /*
                      8: **  compute klingon distances
                      9: **
                     10: **     The klingon list has the distances for all klingons recomputed
                     11: **     and sorted.  The parameter is a Boolean flag which is set if
                     12: **     we have just entered a new quadrant.
                     13: **
                     14: **     This routine is used every time the Enterprise or the Klingons
                     15: **     move.
                     16: */
                     17: 
                     18: compkldist(f)
                     19: int    f;              /* set if new quadrant */
                     20: {
                     21:        register int            i, dx, dy;
                     22:        double                  d;
                     23:        double                  temp;
                     24: 
                     25:        if (Etc.nkling == 0)
                     26:                return;
                     27:        for (i = 0; i < Etc.nkling; i++)
                     28:        {
                     29:                /* compute distance to the Klingon */
                     30:                dx = Ship.sectx - Etc.klingon[i].x;
                     31:                dy = Ship.secty - Etc.klingon[i].y;
                     32:                d = dx * dx + dy * dy;
                     33:                d = sqrt(d);
                     34: 
                     35:                /* compute average of new and old distances to Klingon */
                     36:                if (!f)
                     37:                {
                     38:                        temp = Etc.klingon[i].dist;
                     39:                        Etc.klingon[i].avgdist = 0.5 * (temp + d);
                     40:                }
                     41:                else
                     42:                {
                     43:                        /* new quadrant: average is current */
                     44:                        Etc.klingon[i].avgdist = d;
                     45:                }
                     46:                Etc.klingon[i].dist = d;
                     47:        }
                     48: 
                     49:        /* leave them sorted */
                     50:        sortkl();
                     51: }
                     52: 
                     53: 
                     54: /*
                     55: **  sort klingons
                     56: **
                     57: **     bubble sort on ascending distance
                     58: */
                     59: 
                     60: sortkl()
                     61: {
                     62:        struct kling            t;
                     63:        register int            f, i, m;
                     64: 
                     65:        m = Etc.nkling - 1;
                     66:        f = 1;
                     67:        while (f)
                     68:        {
                     69:                f = 0;
                     70:                for (i = 0; i < m; i++)
                     71:                        if (Etc.klingon[i].dist > Etc.klingon[i+1].dist)
                     72:                        {
                     73:                                bmove(&Etc.klingon[i], &t, sizeof t);
                     74:                                bmove(&Etc.klingon[i+1], &Etc.klingon[i], sizeof t);
                     75:                                bmove(&t, &Etc.klingon[i+1], sizeof t);
                     76:                                f = 1;
                     77:                        }
                     78:        }
                     79: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.