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

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.