Return to compkl.c CVS log

Up to [Research Unix] / researchv10no / games / trek

Annotation of researchv10no/games/trek/compkl.c, revision 1.1.1.1

1.1       root        1: # include      "trek.h"
                      2: 
                      3: /**
                      4:  **    compute klingon distances
                      5:  **/
                      6: 
                      7: compkldist(f)
                      8: int    f;              /* set if new quadrant */
                      9: {
                     10:        register int            i, dx, dy;
                     11:        double                  d;
                     12:        double                  temp;
                     13: 
                     14:        if (Nkling == 0)
                     15:                return;
                     16:        for (i = 0; i < Nkling; i++)
                     17:        {
                     18:                /* compute distance to the Klingon */
                     19:                dx = Sectx - Kling[i].x;
                     20:                dy = Secty - Kling[i].y;
                     21:                d = dx*dx + dy*dy; d = sqrt(d);
                     22:                /* computer average of new and old distances to Klingon */
                     23:                if (!f)
                     24:                {
                     25:                        temp = Kling[i].dist;
                     26:                        Kling[i].avgdist = 0.5 * (temp + d);
                     27:                }
                     28:                else
                     29:                        Kling[i].avgdist = d;
                     30:                Kling[i].dist = d;
                     31:        }
                     32:        sortkl();
                     33: }
                     34: 
                     35: 
                     36: /**
                     37:  **    sort klingons
                     38:  **            bubble sort on ascending distance
                     39:  **/
                     40: 
                     41: sortkl()
                     42: {
                     43:        KLINGONS                t;
                     44:        register int            f, i, m;
                     45: 
                     46:        m = Nkling - 1;
                     47:        f = 1;
                     48:        while (f)
                     49:        {
                     50:                f = 0;
                     51:                for (i = 0; i < m; i++)
                     52:                        if (Kling[i].dist > Kling[i+1].dist)
                     53:                        {
                     54:                                bmove(&Kling[i], &t, sizeof t);
                     55:                                bmove(&Kling[i+1], &Kling[i], sizeof t);
                     56:                                bmove(&t, &Kling[i+1], sizeof t);
                     57:                                f = 1;
                     58:                        }
                     59:        }
                     60:        return;
                     61: }

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