Return to move.c CVS log

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

Annotation of researchv10no/games/trek/move.c, revision 1.1

1.1     ! root        1: # include      "trek.h"
        !             2: 
        !             3: /**
        !             4:  **    move under warp or impulse power
        !             5:  **/
        !             6: 
        !             7: float newpos(ramflg, course, time, speed)
        !             8: int    ramflg;
        !             9: int    course;
        !            10: float  time;
        !            11: float  speed;
        !            12: {
        !            13:        double                  angle;
        !            14:        float                   x, y, dx, dy;
        !            15:        register int            ix, iy;
        !            16:        double                  bigger;
        !            17:        int                     n;
        !            18:        register int            i;
        !            19:        float                   dist;
        !            20:        float                   sectsize;
        !            21:        double                  xn;
        !            22:        float                   evtime;
        !            23: 
        !            24:        sectsize = NSECTS;
        !            25:        /* initialize delta factors for move */
        !            26:        angle = course * 0.0174532925;
        !            27:        if (Damage[SINS])
        !            28:                angle =+ Param.navigcrud[1] * (franf() - 0.5);
        !            29:        else
        !            30:                if (Status.sinsbad)
        !            31:                        angle =+ Param.navigcrud[0] * (franf() - 0.5);
        !            32:        dx = -cos(angle);
        !            33:        dy = sin(angle);
        !            34:        bigger = fabs(dx);
        !            35:        dist = fabs(dy);
        !            36:        if (dist > bigger)
        !            37:                bigger = dist;
        !            38:        dx =/ bigger;
        !            39:        dy =/ bigger;
        !            40: 
        !            41:        /* check for LRTB */
        !            42:        evtime = Etc.eventptr[E_LRTB]->date - Status.date;
        !            43:        if (time > evtime && Nkling < 3)
        !            44:        {
        !            45:                time = evtime + 0.05;
        !            46:        }
        !            47:        dist = time * speed;
        !            48: 
        !            49:        /* move within quadrant */
        !            50:        Sect[Sectx][Secty] = EMPTY;
        !            51:        x = Sectx + 0.5;
        !            52:        y = Secty + 0.5;
        !            53:        xn = NSECTS * dist * bigger;
        !            54:        n = xn + 0.5;
        !            55:        Move.free = 0;
        !            56: 
        !            57:        for (i = 0; i < n; i++)
        !            58:        {
        !            59:                ix = (x =+ dx);
        !            60:                iy = (y =+ dy);
        !            61:                if (x < 0.0 || y < 0.0 || x >= sectsize || y >= sectsize)
        !            62:                {
        !            63:                        /* enter new quadrant */
        !            64:                        ix = (Quadx * NSECTS + Sectx + dx * xn + 0.5);
        !            65:                        iy = (Quady * NSECTS + Secty + dy * xn + 0.5);
        !            66:                        Sectx = x;
        !            67:                        Secty = y;
        !            68:                        compkldist(0);
        !            69:                        Move.newquad = 2;
        !            70:                        attack(0);
        !            71:                        checkcond();
        !            72:                        Quadx = ix / NSECTS;
        !            73:                        Quady = iy / NSECTS;
        !            74:                        Sectx = ix % NSECTS;
        !            75:                        Secty = iy % NSECTS;
        !            76:                        if (ix < 0 || Quadx >= NQUADS || iy < 0 || Quady >= NQUADS)
        !            77:                                barrier("negative energy barrier");
        !            78:                        else    initquad(0);
        !            79:                        n = 0;
        !            80:                        break;
        !            81:                }
        !            82:                if (Sect[ix][iy] != EMPTY)
        !            83:                {
        !            84:                        /* we just hit something */
        !            85:                        if (Damage[COMPUTER] || ramflg) {
        !            86:                                collide(ix, iy);
        !            87:                                ix = x - dx;
        !            88:                                iy = y - dy;
        !            89:                        } else if(Sect[ix][iy]==BLACKHOLE) {
        !            90:                                printf("Spock: Captain, We are approaching a black hole\n");
        !            91:                                barrier("black hole");
        !            92:                                Status.resource =- Status.kling * (franf() + 0.5);
        !            93:                                n = 0;
        !            94:                        } else {
        !            95:                                ix = x - dx;
        !            96:                                iy = y - dy;
        !            97:                                printf("Computer reports navigation error; %s stopped at %d,%d\n",
        !            98:                                        Status.shipname, ix, iy);
        !            99:                                Status.energy =- Param.stopengy * speed;
        !           100:                        }
        !           101:                        break;
        !           102:                }
        !           103:        }
        !           104:        if (n > 0)
        !           105:        {
        !           106:                dx = Sectx - ix;
        !           107:                dy = Secty - iy;
        !           108:                dist = sqrt(dx * dx + dy * dy) / NSECTS;
        !           109:                time = dist / speed;
        !           110:                Sectx = ix;
        !           111:                Secty = iy;
        !           112:        }
        !           113:        Sect[Sectx][Secty] = Status.ship;
        !           114:        compkldist(0);
        !           115:        return(time);
        !           116: }
        !           117: 
        !           118: barrier(msg)
        !           119: char   *msg;
        !           120: {
        !           121:        if (!Damage[COMPUTER])
        !           122:        {
        !           123:                Quadx = ranf(NQUADS);
        !           124:                Quady = ranf(NQUADS);
        !           125:                Sectx = ranf(NSECTS);
        !           126:                Secty = ranf(NSECTS);
        !           127:                printf("Computer applies full reverse power to avoid the %s\n", msg);
        !           128:                printf(" A space warp was entered and you ended up in quadrant %d,%d\n",
        !           129:                        Quadx, Quady);
        !           130:        }
        !           131:        else
        !           132:                lose(L_NEGENB);
        !           133:        initquad(0);
        !           134: }

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