Return to computer.c CVS log

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

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

1.1     ! root        1: # include      "trek.h"
        !             2: 
        !             3: /**
        !             4:  **    on-board computer
        !             5:  **/
        !             6: 
        !             7: CVNTAB Cputab[]
        !             8: {
        !             9:        "r",                    "ecord",
        !            10:        "m",                    "ove",
        !            11:        "t",                    "rajectory",
        !            12:        "c",                    "ourse",
        !            13:        "s",                    "core",
        !            14:        "p",                    "heff",
        !            15:        "w",                    "arpcost",
        !            16:        "i",                    "mpcost",
        !            17:        "d",                    "istresslist",
        !            18:        "b",                    "ase",
        !            19:        "k",                    "alculator",
        !            20:        "x",                    "",
        !            21:        "y",                    "",
        !            22:        0
        !            23: };
        !            24: 
        !            25: computer()
        !            26: {
        !            27:        char                    c;
        !            28:        int                     ix, iy;
        !            29:        register int            i, j;
        !            30:        int                     tqx, tqy, tsx, tsy;
        !            31:        int                     cost, course;
        !            32:        float                   dist, time;
        !            33:        float                   warpfac;
        !            34:        EVENT                   *e;
        !            35: 
        !            36:        if (Damage[COMPUTER])
        !            37:        {
        !            38:                printf("Computer disabled.\n");
        !            39:                return;
        !            40:        }
        !            41:        do{
        !            42:            if((i=getcodpar("Request", Cputab))<0) return;
        !            43:            switch(c = *(Cputab[i].abrev)) {
        !            44: 
        !            45:            case 'r':                   /* star chart */
        !            46:                printf("Computer record of galaxy for all L.R. scans\n",
        !            47:                         Status.shipname, Quadx, Quady);
        !            48:                scanall(0);
        !            49:                break;
        !            50: 
        !            51:            case 't':                   /* trajectory */
        !            52:                if (chksrs()==0)
        !            53:                        break;
        !            54:                if (Nkling <= 0)
        !            55:                {
        !            56:                        printf("No Klingons in this quadrant.\n");
        !            57:                        break;
        !            58:                }
        !            59:                for (i = 0; i < Nkling; i++)
        !            60:                {
        !            61:                        printf("Klingon at %d,%d", Kling[i].x, Kling[i].y);
        !            62:                        course=dokalc(Quadx, Quady, Kling[i].x, Kling[i].y, &dist);
        !            63:                        prkalc(course,dist);
        !            64:                }
        !            65:                break;
        !            66: 
        !            67:            case 'c':                   /* course */
        !            68:            case 'm':                   /* move */
        !            69:                if(readsep("/")) {
        !            70:                        tqx = Quadx;
        !            71:                        tqy = Quady;
        !            72:                } else {
        !            73:                        if(getintpar("Quadrant", &ix)==0) break;
        !            74:                        readsep(",");
        !            75:                        if(getintpar("quadrant y-coordinate", &iy)==0) break;
        !            76:                        tqx = ix;
        !            77:                        tqy = iy;
        !            78:                        readsep("/");
        !            79:                }
        !            80:                if(getsect(&ix,&iy)==0)
        !            81:                        break;
        !            82:                tsx = ix;
        !            83:                tsy = iy;
        !            84:                if(chkquad(tqx,tqy)) {
        !            85:                        course=dokalc(tqx, tqy, tsx, tsy, &dist);
        !            86:                        if(c=='m') {
        !            87:                                if(Status.cond!=DOCKED)
        !            88:                                        warp(0,course,dist);
        !            89:                                else
        !            90:                                        printf("%s is docked.\n", Status.shipname);
        !            91:                        } else {
        !            92:                                printf("%d,%d/%d,%d to %d,%d/%d,%d",
        !            93:                                        Quadx, Quady, Sectx, Secty, tqx, tqy, tsx, tsy);
        !            94:                                prkalc(course, dist);
        !            95:                        }
        !            96:                }
        !            97:                break;
        !            98: 
        !            99:            case 's':                   /* score */
        !           100:                score();
        !           101:                break;
        !           102: 
        !           103:            case 'p':                   /* phasers effective */
        !           104:                if(getfltpar("Range", &dist)==0 ||
        !           105:                        chkdist(dist)==0) break;
        !           106:                dist =* 10.0;
        !           107:                cost = pow(0.90, dist) * 100 + 0.5;
        !           108:                printf("Phasers are %d%% effective at that range.\n", cost);
        !           109:                break;
        !           110: 
        !           111:            case 'w':                   /* warp cost */
        !           112:                if(getfltpar("Distance", &dist)==0 ||
        !           113:                        chkdist(dist)==0 ||
        !           114:                        getfltpar("Warp factor", &warpfac)==0) break;
        !           115:                cost = (dist + 0.05) * warpfac * warpfac * warpfac;
        !           116:                if(Status.shldup)
        !           117:                        cost =* 2;
        !           118:                time = Param.warptime * dist / (warpfac * warpfac);
        !           119:                if(Status.cloaked)
        !           120:                        cost =+ Param.cloakenergy*time;
        !           121:                printf("Distance %.2f cost %.2f stardates %d units",
        !           122:                        dist, time, cost);
        !           123:                if(Status.shldup)
        !           124:                        printf(" (shields up)");
        !           125:                if(Status.cloaked)
        !           126:                        printf(" (CLOAKED)");
        !           127:                printf("\n");
        !           128:                break;
        !           129: 
        !           130:            case 'i':                   /* impulse cost */
        !           131:                if(getfltpar("Distance", &dist)==0) break;
        !           132:                cost = 20 + 100 * dist;
        !           133:                time = dist / 0.095;
        !           134:                printf("Distance %.2f cost %.2f stardates %d units\n",
        !           135:                        dist, time, cost);
        !           136:                break;
        !           137: 
        !           138: 
        !           139:            case 'd':                   /* distresslist */
        !           140:                j = 0;
        !           141:                for (i = 0; i < MAXEVENTS; i++)
        !           142:                {
        !           143:                        e = &Event[i];
        !           144:                        if ((e->systemname&E_NREPORT)==0)
        !           145:                                j =| report(e);
        !           146:                }
        !           147:                if (j==0)
        !           148:                        printf("No known distress calls are active.\n");
        !           149:                break;
        !           150: 
        !           151:            case 'b':                   /* star base */
        !           152:                {double d; int dx, dy, b;
        !           153:                if((b=findbase(&d))<0 && Damage[SRSCAN]) {
        !           154:                        printf("S.R. scanners damaged\n");
        !           155:                } else {
        !           156:                        printf("nearest star base is ");
        !           157:                        if(b>=0) {
        !           158:                                dx=Base[b].x; dy=Base[b].y;
        !           159:                                printf("in quadrant %d,%d\n", dx, dy);
        !           160:                        } else  {
        !           161:                                dx=Starbase.x; dy=Starbase.y;
        !           162:                                printf("at sector %d,%d\n", dx, dy);
        !           163:                        }
        !           164:                }
        !           165:                }
        !           166:                break;
        !           167: 
        !           168:            case 'x':                   /* x scan */
        !           169:            case 'y':
        !           170:                {int    x_axis;
        !           171:                if(Damage[SRSCAN]) {
        !           172:                        printf("S.R. scanners damaged\n");
        !           173:                        break;
        !           174:                }
        !           175:                if(getintpar("coordinate",&ix)==0) break;
        !           176:                if(ix<0 || ix>NSECTS) {
        !           177:                        printf("Out of range\n");
        !           178:                        break;
        !           179:                }
        !           180:                x_axis=(c=='x');
        !           181:                printf("%d,%d ", (x_axis?ix:0), (x_axis?0:ix));
        !           182:                for(i=0;i<NSECTS;i++) {
        !           183:                        printf(" %c", (x_axis ? Sect[ix][i] : Sect[i][ix]));
        !           184:                }
        !           185:                printf("  %d,%d\n", (x_axis?ix:NSECTS-1), (x_axis?NSECTS-1:ix));
        !           186:                }
        !           187:                break;
        !           188: 
        !           189:            case 'k':                   /* calculator */
        !           190:                printf("The calculator is broken.\n");
        !           191:                break;
        !           192:            }
        !           193:        } while(readsep(";"));
        !           194: }
        !           195: 
        !           196: 
        !           197: dokalc(tqx, tqy, tsx, tsy, dist)
        !           198: float *dist;
        !           199: {
        !           200:        double          dx, dy;
        !           201:        float           quadsize;
        !           202:        double          angle;
        !           203:        int             course;
        !           204: 
        !           205:        quadsize = NSECTS;
        !           206:        dx = (Quadx + Sectx / quadsize) - (tqx + tsx / quadsize);
        !           207:        dy = (tqy + tsy / quadsize) - (Quady + Secty / quadsize);
        !           208:        angle = atan2(dy, dx);
        !           209:        if (angle < 0.0)
        !           210:                angle =+ 6.283185307;
        !           211:        course = angle * 57.29577951 + 0.5;
        !           212:        dx = sqrt(dx*dx + dy*dy);
        !           213:        *dist=dx;
        !           214:        return(course);
        !           215: }
        !           216: 
        !           217: prkalc(course,dist)
        !           218: float dist;
        !           219: {
        !           220:        printf(": course %3d, distance %.3f\n", course, dist);
        !           221: }
        !           222: 
        !           223: chkdist(d)
        !           224: float d;
        !           225: {
        !           226:        register int b;
        !           227: 
        !           228:        if (b=(d < 0.0 || d > 15.0))
        !           229:                printf("Distances must be positive.\n");
        !           230:        return(!b);
        !           231: }
        !           232: 
        !           233: chksect(sx,sy)
        !           234: {
        !           235:        register int b;
        !           236: 
        !           237:        if(b = (sx<0 || sy<0 || sx>=NSECTS || sy>=NSECTS))
        !           238:                printf("%d,%d bad sector coordinates\n", sx, sy);
        !           239:        return(!b);
        !           240: }
        !           241: 
        !           242: chkquad(qx,qy)
        !           243: {
        !           244:        register int b;
        !           245: 
        !           246:        if(b = (qx<0 || qy<0 || qx>=NQUADS || qy>=NQUADS))
        !           247:                printf("%d,%d bad quadrant coordinates\n", qx, qy);
        !           248:        return(!b);
        !           249: }
        !           250: 
        !           251: prsect(flg,i,j)
        !           252: {
        !           253:        register int    k, b, n;
        !           254:        char            c;
        !           255:        QUAD            *q;
        !           256: 
        !           257:        q = &Quad[i][j];
        !           258:        if(flg) {
        !           259:                q->scanned=((q->stars>=0)
        !           260:                                ? (q->qkling * 100 + q->bases * 10 + q->stars)
        !           261:                                : 1000
        !           262:                           );
        !           263:        }
        !           264:        n=q->scanned;
        !           265:        if (n >= 1000)
        !           266:                printf(((n==1000)?" ///":" .#."));
        !           267:        else {
        !           268:                if (n < 0)
        !           269:                        printf(" ...");
        !           270:                else {
        !           271:                        k=n/100; b=(n =% 100)/10; n =% 10;
        !           272:                        if(i==Quadx && j==Quady)
        !           273:                                b=Status.ship;
        !           274:                        else    if(b)   b='#';
        !           275:                        c=(k?'0':' ');
        !           276:                        printf(" %c%c%c", (k?k+'0':' '), (b?b:c), n+'0');
        !           277:                }
        !           278:        }
        !           279: }
        !           280: 
        !           281: getsect(ax,ay)
        !           282: int    *ax, *ay;
        !           283: {
        !           284:        if(getintpar("Sector", ax)==0 ||
        !           285:                (readsep(","), getintpar("sector y-coordinate", ay)==0) ||
        !           286:                chksect(*ax,*ay)==0)
        !           287:                return(0);
        !           288:        return(1);
        !           289: }
        !           290: 
        !           291: scanall(flg)
        !           292: {
        !           293:        register int    i, j;
        !           294: 
        !           295:        printf("  ");
        !           296:        for (i = 0; i < NQUADS; i++)
        !           297:                printf("-%d- ", i);
        !           298:        printf("\n");
        !           299:        for (i = 0; i < NQUADS; i++)
        !           300:        {
        !           301:                if(mkfault) break;
        !           302:                printf("%d", i);
        !           303:                for (j = 0; j < NQUADS; j++)
        !           304:                {
        !           305:                        prsect(flg,i,j);
        !           306:                }
        !           307:                printf(" %d\n", i);
        !           308:        }
        !           309:        printf("  ");
        !           310:        for (i = 0; i < NQUADS; i++)
        !           311:                printf("-%d- ", i);
        !           312:        printf("\n");
        !           313: }
        !           314: 
        !           315: 
        !           316: chksrs()
        !           317: {
        !           318:        if(Damage[SRSCAN]) {
        !           319:                printf("S.R. scanners damaged");
        !           320:                if(Status.cond==DOCKED) {
        !           321:                        printf("; using starbase scanners.\n");
        !           322:                        return(1);
        !           323:                } else
        !           324:                        printf("\n");
        !           325:                return(0);
        !           326:        } else  return(1);
        !           327: }

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