Return to compkl.c CVS log

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

Annotation of 43BSD/games/trek/compkl.c, revision 1.1

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

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