Return to killbots.c CVS log

Up to [Synchronet] / sbbs / killbots

Annotation of sbbs/killbots/killbots.c, revision 1.1

1.1     ! root        1: /* KILLBOTS.C */
        !             2: 
        !             3: #include <stdio.h>
        !             4: #include <stdlib.h>
        !             5: 
        !             6: #define GOTOXY(x,y) printf("\x1b[%d;%dH",y,x)
        !             7: 
        !             8: main(int argc, char **argv)
        !             9: {
        !            10:        char str[81],name[31],chainpath[129],done=0,c
        !            11:                ,crx,cry,cgd,cbx[5],cby[5],cbd[5],urx,ury,ugd,ubx[5],uby[5],ubd[5];
        !            12:        FILE *stream;
        !            13: 
        !            14: if(argc!=2) {
        !            15:        printf("\r\nUsage: KILLBOTS <path to chain.txt>\r\n");
        !            16:        getch();
        !            17:        return(1); }
        !            18: strcpy(chainpath,argv[1]);
        !            19: strupr(chainpath);
        !            20: if(!strstr(chainpath,"CHAIN.TXT")) {
        !            21:        if(chainpath[strlen(chainpath)-1]!='\\');
        !            22:                strcat(chainpath,"\\");
        !            23:        strcat(chainpath,"CHAIN.TXT"); }
        !            24: if((stream=fopen(chainpath,"rb"))==NULL) {
        !            25:        printf("\7\r\nError opening %s\r\n",chainpath);
        !            26:        getch();
        !            27:        return(1); }
        !            28: fgets(str,81,stream);  /* user number */
        !            29: fgets(str,81,stream);  /* user name */
        !            30: str[strlen(str)-2]=0;  /* chop off CRLF */
        !            31: sprintf(name,"%-.30s",str);
        !            32: fclose(stream);
        !            33: randomize();
        !            34: printf("\x1b[2JWelcome to KILLBOTS, %s!\r\n",name);
        !            35: getch();
        !            36: printf("\x1b[2J");
        !            37: putchar('�');
        !            38: for(c=0;c<78;c++)
        !            39:        putchar('�');
        !            40: putchar('�');
        !            41: for(c=0;c<19;c++)
        !            42:        printf("�\x1b[78C�");
        !            43: putchar('�');
        !            44: for(c=0;c<78;c++)
        !            45:        putchar('�');
        !            46: putchar('�');
        !            47: for(c=0;c<2;c++)
        !            48:        printf("�\x1b[78C�");
        !            49: putchar('�');
        !            50: for(c=0;c<78;c++)
        !            51:        putchar('�');
        !            52: putchar('�');
        !            53: crx=cry=3;
        !            54: cgd='R';
        !            55: for(c=0;c<5;c++)
        !            56:        cbx[c]=cby[c]=cbd[c]=0;
        !            57: urx=78;
        !            58: ury=19;
        !            59: ugd='L';
        !            60: for(c=0;c<5;c++)
        !            61:        ubx[c]=uby[c]=ubd[c]=0;
        !            62: while(!done) {
        !            63:        for(c=0;c<5;c++)
        !            64:                if(cbd[c]) {
        !            65:                        GOTOXY(cbx[c],cby[c]);
        !            66:                        putch(' ');
        !            67:                        switch(cbd[c]) {
        !            68:                                case 'L':
        !            69:                                        cbx[c]-=4;
        !            70:                                        break;
        !            71:                                case 'R':
        !            72:                                        cbx[c]+=4;
        !            73:                                        break;
        !            74:                                case 'U':
        !            75:                                        cby[c]-=2;
        !            76:                                        break;
        !            77:                                case 'D':
        !            78:                                        cby[c]+=2;
        !            79:                                        break; }
        !            80:                        if((cbx[c]==urx && cby[c]==ury) ||
        !            81:                                (cbd[c]=='R' && cby[c]==ury && (cbx[c]>urx && cbx[c]-4<urx)) ||
        !            82:                                (cbd[c]=='L' && cby[c]==ury && (cbx[c]<urx && cbx[c]+4>urx)) ||
        !            83:                                (cbd[c]=='U' && cbx[c]==urx && (cby[c]<ury && cby[c]+2>ury)) ||
        !            84:                                (cbd[c]=='D' && cbx[c]==urx && (cby[c]>ury && cby[c]-2<ury))) {
        !            85:                                GOTOXY(urx,ury);
        !            86:                                putchar('#');
        !            87:                                GOTOXY(3,23);
        !            88:                                printf("You're dead!");
        !            89:                                getch();
        !            90:                                done=1; }
        !            91:                        if(cbx[c]>79 || cbx[c]<2 || cby[c]>19 || cby[c]<2)
        !            92:                                cbd[c]=0;
        !            93:                        else {
        !            94:                 GOTOXY(cbx[c],cby[c]);
        !            95:                                putchar('*'); } }
        !            96:        for(c=0;c<5;c++)
        !            97:                if(ubd[c]) {
        !            98:                        GOTOXY(ubx[c],uby[c]);
        !            99:                        putch(' ');
        !           100:                        switch(ubd[c]) {
        !           101:                                case 'L':
        !           102:                                        ubx[c]-=4;
        !           103:                                        break;
        !           104:                                case 'R':
        !           105:                                        ubx[c]+=4;
        !           106:                                        break;
        !           107:                                case 'U':
        !           108:                                        uby[c]-=2;
        !           109:                                        break;
        !           110:                                case 'D':
        !           111:                                        uby[c]+=2;
        !           112:                                        break; }
        !           113:             if((ubx[c]==crx && uby[c]==cry) ||
        !           114:                                (ubd[c]=='R' && uby[c]==cry && (ubx[c]>crx && ubx[c]-4<crx)) ||
        !           115:                                (ubd[c]=='L' && uby[c]==cry && (ubx[c]<crx && ubx[c]+4>crx)) ||
        !           116:                                (ubd[c]=='U' && ubx[c]==crx && (uby[c]<cry && uby[c]+2>cry)) ||
        !           117:                                (ubd[c]=='D' && ubx[c]==crx && (uby[c]>cry && uby[c]-2<cry))) {
        !           118:                                GOTOXY(crx,cry);
        !           119:                                putchar('#');
        !           120:                                GOTOXY(3,23);
        !           121:                                printf("Got 'em!");
        !           122:                                getch();
        !           123:                                done=1; }
        !           124:                        if(ubx[c]>79 || ubx[c]<2 || uby[c]>19 || uby[c]<2)
        !           125:                                ubd[c]=0;
        !           126:                        else {
        !           127:                 GOTOXY(ubx[c],uby[c]);
        !           128:                                putchar('+'); } }
        !           129:        if(!random(4)) {
        !           130:                GOTOXY(crx,cry);
        !           131:                putchar(' ');   /* erase man */
        !           132:                switch(cgd) {   /* computer robot gun dirrection */
        !           133:                        case 'L':
        !           134:                                printf("\b\b");
        !           135:                                break;
        !           136:                        case 'U':
        !           137:                                GOTOXY(crx,cry-1);
        !           138:                                break;
        !           139:                        case 'D':
        !           140:                                GOTOXY(crx,cry+1);
        !           141:                                break; }
        !           142:                putchar(' ');   /* erase gun */
        !           143:                switch(random(9)) {
        !           144:                        case 1:
        !           145:                                if(crx>3)
        !           146:                                        crx--;
        !           147:                                break;
        !           148:                        case 2:
        !           149:                                if(cry>3)
        !           150:                                        cry--;
        !           151:                                break;
        !           152:                        case 3:
        !           153:                                if(crx<78)
        !           154:                                        crx++;
        !           155:                                break;
        !           156:                        case 4:
        !           157:                                if(cry<19)
        !           158:                                        cry++;
        !           159:                                break;
        !           160:                        case 5:
        !           161:                                if(cry>3 && crx>3) {
        !           162:                                        crx--;
        !           163:                                        cry--; }
        !           164:                                break;
        !           165:                        case 6:
        !           166:                                if(cry<19 && crx>3) {
        !           167:                                        crx--;
        !           168:                                        cry++; }
        !           169:                                break;
        !           170:                        case 7:
        !           171:                                if(cry<19 && crx<78) {
        !           172:                                        crx++;
        !           173:                                        cry++; }
        !           174:                                break;
        !           175:                        case 8:
        !           176:                                if(cry>3 && crx<78) {
        !           177:                                        crx++;
        !           178:                                        cry--; }
        !           179:                                break; }
        !           180:                GOTOXY(crx,cry);
        !           181:                putchar(2);
        !           182:                switch(random(4)) {
        !           183:                        case 0:
        !           184:                                cgd='R';
        !           185:                                break;
        !           186:                        case 1:
        !           187:                                cgd='L';
        !           188:                                break;
        !           189:                        case 2:
        !           190:                                cgd='U';
        !           191:                                break;
        !           192:                        case 3:
        !           193:                                cgd='D';
        !           194:                                break; }
        !           195:                for(c=0;c<5;c++)
        !           196:                        if(!cbd[c])
        !           197:                                break;
        !           198:                switch(cgd) {   /* computer robot gun dirrection */
        !           199:                        case 'L':
        !           200:                                GOTOXY(crx-1,cry);
        !           201:                                putchar(17);
        !           202:                                if(c==5)
        !           203:                                        break;
        !           204:                                if(ury+1>=cry && ury-1<=cry && urx<crx) {
        !           205:                                        cbx[c]=crx-2;
        !           206:                                        cby[c]=cry;
        !           207:                                        cbd[c]='L'; }
        !           208:                                break;
        !           209:                        case 'R':
        !           210:                                putchar(16);
        !           211:                                if(c==5)
        !           212:                                        break;
        !           213:                                if(ury+1>=cry && ury-1<=cry && urx>crx) {
        !           214:                                        cbx[c]=crx+2;
        !           215:                                        cby[c]=cry;
        !           216:                                        cbd[c]='R'; }
        !           217:                                break;
        !           218:                        case 'U':
        !           219:                                GOTOXY(crx,cry-1);
        !           220:                                putchar(30);
        !           221:                                if(c==5)
        !           222:                                        break;
        !           223:                                if(urx+1>=crx && urx-1<=crx && ury<cry) {
        !           224:                                        cbx[c]=crx;
        !           225:                                        cby[c]=cry-2;
        !           226:                                        cbd[c]='U'; }
        !           227:                                break;
        !           228:                        case 'D':
        !           229:                                GOTOXY(crx,cry+1);
        !           230:                                putchar(31);
        !           231:                                if(c==5)
        !           232:                                        break;
        !           233:                                if(urx+1>=crx && urx-1<=crx && ury>cry) {
        !           234:                                        cbx[c]=crx;
        !           235:                                        cby[c]=cry+2;
        !           236:                                        cbd[c]='D'; }
        !           237:                                break; } }
        !           238:        /*
        !           239:        for(c=0;c<5;c++)
        !           240:                if(cbd[c]) {
        !           241:                        GOTOXY(cbx[c],cby[c]);
        !           242:                        putchar('%'); }
        !           243:        */
        !           244:        if(kbhit()) {
        !           245:                GOTOXY(urx,ury);
        !           246:                putchar(' ');
        !           247:                switch(ugd) {   /* computer robot gun dirrection */
        !           248:                        case 'L':
        !           249:                                printf("\b\b");
        !           250:                                break;
        !           251:                        case 'U':
        !           252:                                GOTOXY(urx,ury-1);
        !           253:                                break;
        !           254:                        case 'D':
        !           255:                                GOTOXY(urx,ury+1);
        !           256:                                break; }
        !           257:                putchar(' ');   /* erase gun */
        !           258:                switch(toupper(getch())) {
        !           259:                        case 'Q':
        !           260:                                done=1;
        !           261:                                break;
        !           262:                        case 'J':
        !           263:                                if(urx>3)
        !           264:                                        urx--;
        !           265:                                break;
        !           266:                        case 'I':
        !           267:                                if(ury>3)
        !           268:                                        ury--;
        !           269:                                break;
        !           270:                        case 'K':
        !           271:                                if(urx<78)
        !           272:                                        urx++;
        !           273:                                break;
        !           274:                        case 'M':
        !           275:                                if(ury<19)
        !           276:                                        ury++;
        !           277:                                break;
        !           278:                        case 'U':
        !           279:                                if(ury>3 && urx>3) {
        !           280:                                        urx--;
        !           281:                                        ury--; }
        !           282:                                break;
        !           283:                        case 'N':
        !           284:                                if(ury<19 && urx>3) {
        !           285:                                        urx--;
        !           286:                                        ury++; }
        !           287:                                break;
        !           288:                        case ',':
        !           289:                                if(ury<19 && urx<78) {
        !           290:                                        urx++;
        !           291:                                        ury++; }
        !           292:                                break;
        !           293:                        case 'O':
        !           294:                                if(ury>3 && urx<78) {
        !           295:                                        urx++;
        !           296:                                        ury--; }
        !           297:                                break;
        !           298:                        case 'C':
        !           299:                                ugd='D';
        !           300:                                break;
        !           301:                        case 'R':
        !           302:                                ugd='U';
        !           303:                                break;
        !           304:                        case 'F':
        !           305:                                ugd='R';
        !           306:                                break;
        !           307:                        case 'D':
        !           308:                                ugd='L';
        !           309:                                break;
        !           310:                        case ' ':       /* fire */
        !           311:                                for(c=0;c<5;c++)
        !           312:                                        if(!ubd[c])
        !           313:                                                break;
        !           314:                                if(c==5)
        !           315:                                        break;
        !           316:                                ubd[c]=ugd;
        !           317:                                switch(ugd) {
        !           318:                                        case 'R':
        !           319:                                                ubx[c]=urx+2;
        !           320:                                                uby[c]=ury;
        !           321:                                                break;
        !           322:                                        case 'L':
        !           323:                                                ubx[c]=urx-2;
        !           324:                                                uby[c]=ury;
        !           325:                                                break;
        !           326:                                        case 'U':
        !           327:                                                ubx[c]=urx;
        !           328:                                                uby[c]=ury-2;
        !           329:                                                break;
        !           330:                                        case 'D':
        !           331:                                                ubx[c]=urx;
        !           332:                                                uby[c]=ury+2;
        !           333:                                                break; } }
        !           334:                GOTOXY(urx,ury);
        !           335:                putchar(1);
        !           336:                switch(ugd) {   /* user robot gun dirrection */
        !           337:                        case 'L':
        !           338:                                GOTOXY(urx-1,ury);
        !           339:                                putchar(17);
        !           340:                                break;
        !           341:                        case 'R':
        !           342:                                putchar(16);
        !           343:                                break;
        !           344:                        case 'U':
        !           345:                                GOTOXY(urx,ury-1);
        !           346:                                putchar(30);
        !           347:                                break;
        !           348:                        case 'D':
        !           349:                                GOTOXY(urx,ury+1);
        !           350:                                putchar(31);
        !           351:                                break; } }
        !           352:        /*
        !           353:        for(c=0;c<5;c++)
        !           354:                if(ubd[c]) {
        !           355:                        GOTOXY(ubx[c],uby[c]);
        !           356:                        putchar('@'); }
        !           357:        */
        !           358:        delay(150);     }
        !           359: delay(2000);
        !           360: printf("\x1b[2J");
        !           361: }
        !           362: 

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