Annotation of src/tekprep.c, revision 1.1.1.1

1.1       root        1: /***************************************************************************
                      2:  *   TEKPREP.C -                                                           *
                      3:  *                                                                         *
                      4:  *                                                                         *
                      5:  ***************************************************************************/
                      6: 
                      7: #include <stdio.h>
                      8: #include <fcntl.h>
                      9: #include <io.h>
                     10: #include <sys\types.h>
                     11: #include <sys\stat.h>
                     12: #include <string.h>
                     13: #include <stdlib.h>
                     14: #include <dos.h>
                     15: #include "build.h"
                     16: #include "names.h"
                     17: 
                     18: #include "tekwar.h"
                     19: 
                     20: #pragma aux copybuf =         \
                     21:        "rep movsd",             \
                     22:        parm [esi][edi][ecx]     \
                     23: 
                     24: #define fillsprite(newspriteindex2,x2,y2,z2,cstat2,shade2,pal2,            \
                     25:                clipdist2,xrepeat2,yrepeat2,xoffset2,yoffset2,picnum2,ang2,      \
                     26:                xvel2,yvel2,zvel2,owner2,sectnum2,statnum2,lotag2,hitag2,extra2) \
                     27: {                                                                          \
                     28:        spritetype *spr2;                                                     \
                     29:        spr2 = &sprite[newspriteindex2];                                      \
                     30:        spr2->x = x2; spr2->y = y2; spr2->z = z2;                             \
                     31:        spr2->cstat = cstat2; spr2->shade = shade2;                           \
                     32:        spr2->pal = pal2; spr2->clipdist = clipdist2;                         \
                     33:        spr2->xrepeat = xrepeat2; spr2->yrepeat = yrepeat2;                   \
                     34:        spr2->xoffset = xoffset2; spr2->yoffset = yoffset2;                   \
                     35:        spr2->picnum = picnum2; spr2->ang = ang2;                             \
                     36:        spr2->xvel = xvel2; spr2->yvel = yvel2; spr2->zvel = zvel2;           \
                     37:        spr2->owner = owner2;                                                 \
                     38:        spr2->lotag = lotag2; spr2->hitag = hitag2; spr2->extra = -1;         \ 
                     39:        copybuf(&spr2->x,&osprite[newspriteindex2].x,3);                      \
                     40: }
                     41: 
                     42: #define   lm(_str_) printf(" %s...\n", _str_);
                     43: 
                     44: #pragma aux setvmode =        \
                     45:        "int 0x10",              \
                     46:        parm [eax]               \
                     47: 
                     48: #pragma aux mulscale =        \
                     49:        "imul ebx",              \
                     50:        "shrd eax, edx, cl",     \
                     51:        parm [eax][ebx][ecx]     \
                     52:        modify [edx]             \
                     53: 
                     54: extern    void      cdpreinit(void);
                     55: extern    int       ovmode;
                     56: extern    char      moreoptions[];
                     57: extern    char      toggles[];
                     58: extern    int       difficulty,soundv, musicv,mousesensitivity,headbobon;
                     59: extern    char      activemenu;
                     60: extern    char      generalplay;
                     61: extern    char      singlemapmode;
                     62: 
                     63: void      placerandompic(long picnum);
                     64: 
                     65: sectortype          *sectptr[MAXSECTORS];
                     66: spritetype          *sprptr[MAXSPRITES];
                     67: walltype            *wallptr[MAXWALLS];
                     68: struct    spriteextension     spriteXT[MAXSPRITES];
                     69: struct    spriteextension     *sprXTptr[MAXSPRITES];
                     70: long      startx,starty,startz,starta,starts;
                     71: 
                     72: #define   MAXSTARTSPOTS  16
                     73: int       startspotcnt;
                     74: struct    startspottype {
                     75:      long      x,y,z;
                     76:      short     sectnum;
                     77: };
                     78: struct    startspottype       startspot[MAXSTARTSPOTS];
                     79: 
                     80: extern    int  accessiblemap(int);
                     81: int       firsttimethru=1;
                     82: 
                     83: int       subwaysound[4];
                     84: 
                     85: prepareboard(char *daboardfilename)
                     86: {
                     87:        short     startwall, endwall, dasector;
                     88:        long      i, j, k, s, dax, day, daz, dax2, day2;
                     89:      int       rdonly;
                     90:      int       l;
                     91: 
                     92:      initsprites();   
                     93: 
                     94:      if( firsttimethru ) {
                     95:             getmessageleng = 0;
                     96:             typemessageleng = 0;
                     97:        randomseed = 17L;
                     98:      }
                     99: 
                    100:        // clear (do)animation's list
                    101:        animatecnt = 0;
                    102:        typemode = 0;
                    103:        locselectedgun=1;
                    104:        locselectedgun2=1;
                    105: 
                    106:      // for when revision control has map files attrib +r set
                    107:      rdonly=( access(daboardfilename, W_OK) != 0 );
                    108:      if( rdonly ) {
                    109:           chmod(daboardfilename, S_IRWXU|S_IRWXG|S_IRWXO);
                    110:      }
                    111:        if (loadboard(daboardfilename,&posx[0],&posy[0],&posz[0],&ang[0],&cursectnum[0]) == -1)
                    112:        {
                    113:                musicoff();
                    114:                uninitmultiplayers();
                    115:                uninittimer();
                    116:                uninitkeys();
                    117:                uninitengine();
                    118:                uninitsb();
                    119:                setvmode(ovmode);        //Set back to text mode
                    120:                printf("Board not found\n");
                    121:                exit(0);
                    122:        }
                    123:      if( rdonly ) {
                    124:           chmod(daboardfilename, S_IROTH);
                    125:      }
                    126: 
                    127:      startx=posx[0];
                    128:      starty=posy[0];
                    129:      startz=posz[0];
                    130:      starta=ang[0];
                    131:      starts=cursectnum[0];
                    132: 
                    133:        for(i=0;i<MAXPLAYERS;i++)
                    134:        {
                    135:                posx[i] = posx[0];
                    136:                posy[i] = posy[0];
                    137:                posz[i] = posz[0];
                    138:                ang[i] = ang[0];
                    139:                cursectnum[i] = cursectnum[0];
                    140:                ocursectnum[i] = cursectnum[0];
                    141:                horiz[i] = 100;
                    142:                lastchaingun[i] = 0;
                    143:                health[i] = 100;
                    144:          #ifdef RESETSCORE
                    145:                score[i] = 0L;
                    146:          #endif
                    147:                dimensionmode[i] = 3;
                    148:                numbombs[i] = -1;
                    149:                zoom[i] = 768L;
                    150:                deaths[i] = 0L;
                    151:                playersprite[i] = -1;
                    152:                saywatchit[i] = -1;
                    153:                oposx[i] = posx[0];
                    154:                oposy[i] = posy[0];
                    155:                oposz[i] = posz[0];
                    156:                ohoriz[i] = horiz[0];
                    157:                ozoom[i] = zoom[0];
                    158:                oang[i] = ang[0];
                    159:        }
                    160: 
                    161:        setup3dscreen();
                    162: 
                    163:      if( firsttimethru ) {
                    164:        olocvel = 0; olocvel2 = 0;
                    165:        olocsvel = 0; olocsvel2 = 0;
                    166:        olocangvel = 0; olocangvel2 = 0;
                    167:        olocbits = 0; olocbits2 = 0;
                    168:        for(i=0;i<MAXPLAYERS;i++) {
                    169:                fsyncvel[i] = syncvel[i] = osyncvel[i] = 0;
                    170:                fsyncsvel[i] = syncsvel[i] = osyncsvel[i] = 0;
                    171:                fsyncangvel[i] = syncangvel[i] = osyncangvel[i] = 0;
                    172:                fsyncbits[i] = syncbits[i] = osyncbits[i] = 0;
                    173:        }
                    174:      }
                    175: 
                    176:        for(i=0;i<MAXPLAYERS;i++)
                    177:        {
                    178:                waterfountainwall[i] = -1;
                    179:                waterfountaincnt[i] = 0;
                    180:        }
                    181:        slimesoundcnt[i] = 0;
                    182:        warpsectorcnt = 0;      //Make a list of warping sectors
                    183:        xpanningsectorcnt = 0;  //Make a list of wall x-panning sectors
                    184:        floorpanningcnt = 0;    //Make a list of slime sectors
                    185:        dragsectorcnt = 0;      //Make a list of moving platforms
                    186:        swingcnt = 0;           //Make a list of swinging doors
                    187:        revolvecnt = 0;         //Make a list of revolving doors
                    188:        subwaytrackcnt = 0;     //Make a list of subways
                    189: 
                    190:      // intitialize subwaysound[]s
                    191:      for( i=0; i<4; i++ ) {
                    192:           subwaysound[i]=-1;
                    193:      }
                    194: 
                    195:        // scan sector tags
                    196:        for(i=0;i<numsectors;i++)
                    197:        {
                    198:                switch(sector[i].lotag)
                    199:                {
                    200:                        case 4:
                    201:                                floorpanninglist[floorpanningcnt++] = i;
                    202:                                break;
                    203:                case 5060:
                    204:                     if( option[4] != 0 ) {
                    205:                          sector[i].lotag=0;
                    206:                     }
                    207:                     break;
                    208:                case 25:
                    209:                     if( (singlemapmode != 0) || (generalplay != 0) || (option[4] != 0) ) {
                    210:                          sector[i].lotag=0;
                    211:                     }
                    212:                     break;
                    213:                        case 10:
                    214:                     if( (generalplay == 0) && (option[4] == 0) && (warpsectorcnt < 64) ) {
                    215:                            warpsectorlist[warpsectorcnt++] = i;
                    216:                     }
                    217:                                break;
                    218:                        case 11:
                    219:                                xpanningsectorlist[xpanningsectorcnt++] = i;
                    220:                                break;
                    221:                        case 12:
                    222:                                dasector = i;
                    223:                                dax = 0x7fffffff;
                    224:                                day = 0x7fffffff;
                    225:                                dax2 = 0x80000000;
                    226:                                day2 = 0x80000000;
                    227:                                startwall = sector[i].wallptr;
                    228:                                endwall = startwall+sector[i].wallnum-1;
                    229:                                for(j=startwall;j<=endwall;j++)
                    230:                                {
                    231:                                        if (wall[j].x < dax) dax = wall[j].x;
                    232:                                        if (wall[j].y < day) day = wall[j].y;
                    233:                                        if (wall[j].x > dax2) dax2 = wall[j].x;
                    234:                                        if (wall[j].y > day2) day2 = wall[j].y;
                    235:                                        if (wall[j].lotag == 3) k = j;
                    236:                                }
                    237:                                if (wall[k].x == dax) dragxdir[dragsectorcnt] = -16;
                    238:                                if (wall[k].y == day) dragydir[dragsectorcnt] = -16;
                    239:                                if (wall[k].x == dax2) dragxdir[dragsectorcnt] = 16;
                    240:                                if (wall[k].y == day2) dragydir[dragsectorcnt] = 16;
                    241: 
                    242:                                dasector = wall[startwall].nextsector;
                    243:                                dragx1[dragsectorcnt] = 0x7fffffff;
                    244:                                dragy1[dragsectorcnt] = 0x7fffffff;
                    245:                                dragx2[dragsectorcnt] = 0x80000000;
                    246:                                dragy2[dragsectorcnt] = 0x80000000;
                    247:                                startwall = sector[dasector].wallptr;
                    248:                                endwall = startwall+sector[dasector].wallnum-1;
                    249:                                for(j=startwall;j<=endwall;j++)
                    250:                                {
                    251:                                        if (wall[j].x < dragx1[dragsectorcnt]) dragx1[dragsectorcnt] = wall[j].x;
                    252:                                        if (wall[j].y < dragy1[dragsectorcnt]) dragy1[dragsectorcnt] = wall[j].y;
                    253:                                        if (wall[j].x > dragx2[dragsectorcnt]) dragx2[dragsectorcnt] = wall[j].x;
                    254:                                        if (wall[j].y > dragy2[dragsectorcnt]) dragy2[dragsectorcnt] = wall[j].y;
                    255:                                }
                    256: 
                    257:                                dragx1[dragsectorcnt] += (wall[sector[i].wallptr].x-dax);
                    258:                                dragy1[dragsectorcnt] += (wall[sector[i].wallptr].y-day);
                    259:                                dragx2[dragsectorcnt] -= (dax2-wall[sector[i].wallptr].x);
                    260:                                dragy2[dragsectorcnt] -= (day2-wall[sector[i].wallptr].y);
                    261: 
                    262:                                dragfloorz[dragsectorcnt] = sector[i].floorz;
                    263: 
                    264:                                dragsectorlist[dragsectorcnt++] = i;
                    265:                                break;
                    266:                        case 13:
                    267:                                startwall = sector[i].wallptr;
                    268:                                endwall = startwall+sector[i].wallnum-1;
                    269:                                for(j=startwall;j<=endwall;j++)
                    270:                                {
                    271:                                        if (wall[j].lotag == 4)
                    272:                                        {
                    273:                                                k = wall[wall[wall[wall[j].point2].point2].point2].point2;
                    274:                                                if ((wall[j].x == wall[k].x) && (wall[j].y == wall[k].y))
                    275:                                                {     //Door opens counterclockwise
                    276:                                                        swingwall[swingcnt][0] = j;
                    277:                                                        swingwall[swingcnt][1] = wall[j].point2;
                    278:                                                        swingwall[swingcnt][2] = wall[wall[j].point2].point2;
                    279:                                                        swingwall[swingcnt][3] = wall[wall[wall[j].point2].point2].point2;
                    280:                                                        swingangopen[swingcnt] = 1536;
                    281:                                                        swingangclosed[swingcnt] = 0;
                    282:                                                        swingangopendir[swingcnt] = -1;
                    283:                                                }
                    284:                                                else
                    285:                                                {     //Door opens clockwise
                    286:                                                        swingwall[swingcnt][0] = wall[j].point2;
                    287:                                                        swingwall[swingcnt][1] = j;
                    288:                                                        swingwall[swingcnt][2] = lastwall(j);
                    289:                                                        swingwall[swingcnt][3] = lastwall(swingwall[swingcnt][2]);
                    290:                                                        swingwall[swingcnt][4] = lastwall(swingwall[swingcnt][3]);
                    291:                                                        swingangopen[swingcnt] = 512;
                    292:                                                        swingangclosed[swingcnt] = 0;
                    293:                                                        swingangopendir[swingcnt] = 1;
                    294:                                                }
                    295:                                                for(k=0;k<4;k++)
                    296:                                                {
                    297:                                                        swingx[swingcnt][k] = wall[swingwall[swingcnt][k]].x;
                    298:                                                        swingy[swingcnt][k] = wall[swingwall[swingcnt][k]].y;
                    299:                                                }
                    300: 
                    301:                                                swingsector[swingcnt] = i;
                    302:                                                swingang[swingcnt] = swingangclosed[swingcnt];
                    303:                                                swinganginc[swingcnt] = 0;
                    304:                                                swingcnt++;
                    305:                                        }
                    306:                                }
                    307:                                break;
                    308:                        case 14:
                    309:                                startwall = sector[i].wallptr;
                    310:                                endwall = startwall+sector[i].wallnum-1;
                    311:                                dax = 0L;
                    312:                                day = 0L;
                    313:                                for(j=startwall;j<=endwall;j++)
                    314:                                {
                    315:                                        dax += wall[j].x;
                    316:                                        day += wall[j].y;
                    317:                                }
                    318:                                revolvepivotx[revolvecnt] = dax / (endwall-startwall+1);
                    319:                                revolvepivoty[revolvecnt] = day / (endwall-startwall+1);
                    320: 
                    321:                                k = 0;
                    322:                                for(j=startwall;j<=endwall;j++)
                    323:                                {
                    324:                                        revolvex[revolvecnt][k] = wall[j].x;
                    325:                                        revolvey[revolvecnt][k] = wall[j].y;
                    326:                                        k++;
                    327:                                }
                    328:                                revolvesector[revolvecnt] = i;
                    329:                                revolveang[revolvecnt] = 0;
                    330: 
                    331: 
                    332:                                revolvecnt++;
                    333:                                break;
                    334:                        case 15:
                    335:                                subwaytracksector[subwaytrackcnt][0] = i;
                    336:                                subwaystopcnt[subwaytrackcnt] = 0;
                    337:                                dax = 0x7fffffff;
                    338:                                day = 0x7fffffff;
                    339:                                dax2 = 0x80000000;
                    340:                                day2 = 0x80000000;
                    341:                                startwall = sector[i].wallptr;
                    342:                                endwall = startwall+sector[i].wallnum-1;
                    343:                                for(j=startwall;j<=endwall;j++)
                    344:                                {
                    345:                                        if (wall[j].x < dax) dax = wall[j].x;
                    346:                                        if (wall[j].y < day) day = wall[j].y;
                    347:                                        if (wall[j].x > dax2) dax2 = wall[j].x;
                    348:                                        if (wall[j].y > day2) day2 = wall[j].y;
                    349:                                }
                    350:                                for(j=startwall;j<=endwall;j++)
                    351:                                {
                    352:                                        if (wall[j].lotag == 5)
                    353:                                        {
                    354:                                     if( (wall[j].x > dax) && (wall[j].y > day) && (wall[j].x < dax2) && (wall[j].y < day2) ) {
                    355:                                                     subwayx[subwaytrackcnt] = wall[j].x;
                    356:                                                }
                    357:                                                else {
                    358:                                                     subwaystop[subwaytrackcnt][subwaystopcnt[subwaytrackcnt]] = wall[j].x;
                    359:                                    if( accessiblemap(wall[j].hitag) == 0 ) {
                    360:                                                          subwaystop[subwaytrackcnt][subwaystopcnt[subwaytrackcnt]]=0;
                    361:                                    }
                    362:                                                     subwaystopcnt[subwaytrackcnt]++;
                    363:                                                }
                    364:                                        }
                    365:                                }
                    366:                     // de-sparse stoplist but keep increasing x order
                    367:                     for( j=0; j<subwaystopcnt[subwaytrackcnt]; j++ ) {
                    368:                          if( subwaystop[subwaytrackcnt][j] == 0 ) {
                    369:                               for( l=j+1; l<subwaystopcnt[subwaytrackcnt]; l++ ) {
                    370:                                    if( subwaystop[subwaytrackcnt][l] != 0 ) {
                    371:                                         subwaystop[subwaytrackcnt][j]=subwaystop[subwaytrackcnt][l];
                    372:                                         subwaystop[subwaytrackcnt][l]=0;
                    373:                                         l=subwaystopcnt[subwaytrackcnt];
                    374:                                    }
                    375:                               }
                    376:                          }
                    377:                     }
                    378:                     // recount stopcnt
                    379:                     subwaystopcnt[subwaytrackcnt]=0;
                    380:                     while( subwaystop[subwaytrackcnt][subwaystopcnt[subwaytrackcnt]] != 0 ) {
                    381:                                     subwaystopcnt[subwaytrackcnt]++;
                    382:                     }
                    383: 
                    384:                                for(j=1;j<subwaystopcnt[subwaytrackcnt];j++)
                    385:                                        for(k=0;k<j;k++)
                    386:                                                if (subwaystop[subwaytrackcnt][j] < subwaystop[subwaytrackcnt][k])
                    387:                                                {
                    388:                                                        s = subwaystop[subwaytrackcnt][j];
                    389:                                                        subwaystop[subwaytrackcnt][j] = subwaystop[subwaytrackcnt][k];
                    390:                                                        subwaystop[subwaytrackcnt][k] = s;
                    391:                                                }
                    392: 
                    393:                                subwaygoalstop[subwaytrackcnt] = 0;
                    394:                                for(j=0;j<subwaystopcnt[subwaytrackcnt];j++)
                    395:                                        if (labs(subwaystop[subwaytrackcnt][j]-subwayx[subwaytrackcnt]) < labs(subwaystop[subwaytrackcnt][subwaygoalstop[subwaytrackcnt]]-subwayx[subwaytrackcnt]))
                    396:                                                subwaygoalstop[subwaytrackcnt] = j;
                    397: 
                    398:                                subwaytrackx1[subwaytrackcnt] = dax;
                    399:                                subwaytracky1[subwaytrackcnt] = day;
                    400:                                subwaytrackx2[subwaytrackcnt] = dax2;
                    401:                                subwaytracky2[subwaytrackcnt] = day2;
                    402: 
                    403:                                subwaynumsectors[subwaytrackcnt] = 1;
                    404:                                for(j=0;j<numsectors;j++)
                    405:                                        if (j != i)
                    406:                                        {
                    407:                                                startwall = sector[j].wallptr;
                    408:                                                if (wall[startwall].x > subwaytrackx1[subwaytrackcnt])
                    409:                                                        if (wall[startwall].y > subwaytracky1[subwaytrackcnt])
                    410:                                                                if (wall[startwall].x < subwaytrackx2[subwaytrackcnt])
                    411:                                                                        if (wall[startwall].y < subwaytracky2[subwaytrackcnt])
                    412:                                                                        {
                    413:                                                                                if (sector[j].lotag == 16)
                    414:                                                                                        sector[j].lotag = 17;   //Make special subway door
                    415: 
                    416:                                                                                if (sector[j].floorz != sector[i].floorz)
                    417:                                                                                {
                    418:                                                                                        sector[j].ceilingstat |= 64;
                    419:                                                                                        sector[j].floorstat |= 64;
                    420:                                                                                }
                    421:                                                                                subwaytracksector[subwaytrackcnt][subwaynumsectors[subwaytrackcnt]] = j;
                    422:                                                                                subwaynumsectors[subwaytrackcnt]++;
                    423:                                                                        }
                    424:                                        }
                    425: 
                    426:                                subwayvel[subwaytrackcnt] = 32;  // orig 64
                    427:                                subwaypausetime[subwaytrackcnt] = 720;
                    428:                                subwaytrackcnt++;
                    429:                                break;
                    430:                }
                    431:        }
                    432: 
                    433:        // scan wall tags
                    434:        ypanningwallcnt = 0;
                    435:        for(i=0;i<numwalls;i++)
                    436:        {
                    437:                if (wall[i].lotag == 1) ypanningwalllist[ypanningwallcnt++] = i;
                    438:        }
                    439: 
                    440:        // scan sprite tags&picnum's
                    441:        rotatespritecnt = 0;
                    442:      startspotcnt=0;
                    443:        for(i=0;i<MAXSPRITES;i++)
                    444:        {
                    445:           if( sprite[i].picnum == STARTPOS ) {
                    446:                if( startspotcnt < MAXSTARTSPOTS ) {
                    447:                     startspot[startspotcnt].x=sprite[i].x;
                    448:                     startspot[startspotcnt].y=sprite[i].y;
                    449:                     startspot[startspotcnt].z=sprite[i].z;
                    450:                     startspot[startspotcnt].sectnum=sprite[i].sectnum;
                    451:                     startspotcnt++;
                    452:                }
                    453:                jsdeletesprite(i);
                    454:           }
                    455:           else if( sprite[i].lotag == 3 ) {
                    456:                rotatespritelist[rotatespritecnt++] = i;
                    457:           }
                    458:           else if( option[4] != 0 ) {
                    459:                if( sprite[i].lotag == 1009 ) {
                    460:                     jsdeletesprite(i);
                    461:                }
                    462:           }
                    463:        }
                    464:      if( (startspotcnt == 0) && (option[4] != 0) ) {
                    465:           crash("no net startspots");
                    466:      }
                    467: 
                    468:        for(i=0;i<(MAXSECTORS>>3);i++) show2dsector[i] = 0xff;
                    469:        for(i=0;i<(MAXWALLS>>3);i++) show2dwall[i] = 0xff;
                    470:      automapping = 0;  
                    471:      // tags that make wall/sector not show up on 2D map
                    472:      for( i=0; i < MAXSECTORS; i++ ) {
                    473:           if( sector[i].lotag == 9901 ) {
                    474:                show2dsector[i>>3] &= ~(1<<(i&7));
                    475:                     startwall = sector[i].wallptr;
                    476:                        endwall = startwall+sector[i].wallnum-1;
                    477:                        for( j=startwall; j<=endwall; j++) {
                    478:                     show2dwall[j>>3] &= ~(1<<(j&7));
                    479:                     show2dwall[(wall[j].nextwall)>>3] &= ~(1<<((wall[j].nextwall)&7));
                    480:                        }
                    481:           }
                    482:      }
                    483:      for( i=0; i < MAXWALLS; i++ ) {
                    484:           if( wall[i].lotag == 9900 ) {
                    485:                show2dwall[i>>3] &= ~(1<<(i&7));
                    486:           }
                    487:      }
                    488: 
                    489:      if( firsttimethru ) {
                    490:             lockclock = 0;
                    491:             ototalclock = 0;
                    492:             gotlastpacketclock = 0;
                    493:             masterslavetexttime = 0;
                    494:      }
                    495: 
                    496:      if( option[4] != 0 ) {
                    497:           firsttimethru=0;
                    498:      }
                    499: 
                    500:      tekpreptags();
                    501:      initspriteXTs();
                    502: 
                    503:      // put guns somewhere on map
                    504:      if( option[4] > 0 ) {
                    505:           placerandompic(3094L);
                    506:           placerandompic(3093L);
                    507:           placerandompic(3095L);
                    508:           placerandompic(3091L);
                    509:           placerandompic(3090L);
                    510:      }
                    511: }
                    512: 
                    513: findrandomspot(long *x, long *y, short *sectnum)
                    514: {
                    515:        short startwall, endwall, s;
                    516:        long dax, day, minx, maxx, miny, maxy, cnt, k;
                    517: 
                    518:        cnt = 256;
                    519:        while (cnt > 0)
                    520:        {
                    521:                do
                    522:                {
                    523:             k = mulscale(krand_intercept("PREP 521"),numsectors,16);
                    524:                } while ((sector[k].ceilingz >= sector[k].floorz) || (sector[k].lotag != 0) || ((sector[k].floorstat&2) != 0));
                    525: 
                    526:                startwall = sector[k].wallptr;
                    527:                endwall = startwall+sector[k].wallnum-1;
                    528:                if (endwall > startwall)
                    529:                {
                    530:                        dax = 0L;
                    531:                        day = 0L;
                    532:                        minx = 0x7fffffff; maxx = 0x80000000;
                    533:                        miny = 0x7fffffff; maxy = 0x80000000;
                    534: 
                    535:                        for(s=startwall;s<=endwall;s++)
                    536:                        {
                    537:                                dax += wall[s].x;
                    538:                                day += wall[s].y;
                    539:                                if (wall[s].x < minx) minx = wall[s].x;
                    540:                                if (wall[s].x > maxx) maxx = wall[s].x;
                    541:                                if (wall[s].y < miny) miny = wall[s].y;
                    542:                                if (wall[s].y > maxy) maxy = wall[s].y;
                    543:                        }
                    544:                        if ((maxx-minx > 256) && (maxy-miny > 256))
                    545:                        {
                    546:                                dax /= (endwall-startwall+1);
                    547:                                day /= (endwall-startwall+1);
                    548:                                if (inside(dax,day,k) == 1)
                    549:                                {
                    550:                                        *x = dax;
                    551:                                        *y = day;
                    552:                                        *sectnum = k;
                    553:                                        return;
                    554:                                }
                    555:                        }
                    556:                }
                    557:                cnt--;
                    558:        }
                    559: }
                    560: 
                    561: void
                    562: netstartspot(long *x, long *y,short *sectnum)
                    563: {
                    564:      int       rv;
                    565: 
                    566:      rv=( int)((krand_intercept("PREP 564"))&15L);
                    567:      if (rv >= startspotcnt) {
                    568:           rv=0;
                    569:      }
                    570:      *x=startspot[rv].x;
                    571:      *y=startspot[rv].y;
                    572:      *sectnum=startspot[rv].sectnum;
                    573: }
                    574: 
                    575: void
                    576: placerandompic(long picnum)
                    577: {
                    578:        short     startwall, endwall, s;
                    579:        long      dax, day, minx, maxx, miny, maxy, cnt, k;
                    580:      int       j;
                    581: 
                    582:        cnt = 256;
                    583:        while (cnt > 0)
                    584:        {
                    585:                do
                    586:                {
                    587:             k = mulscale(krand_intercept("PREP 585"),numsectors,16);
                    588:                } while ((sector[k].ceilingz >= sector[k].floorz) || (sector[k].lotag != 0) || ((sector[k].floorstat&2) != 0));
                    589: 
                    590:                startwall = sector[k].wallptr;
                    591:                endwall = startwall+sector[k].wallnum-1;
                    592:                if (endwall > startwall)
                    593:                {
                    594:                        dax = 0L;
                    595:                        day = 0L;
                    596:                        minx = 0x7fffffff; maxx = 0x80000000;
                    597:                        miny = 0x7fffffff; maxy = 0x80000000;
                    598: 
                    599:                        for(s=startwall;s<=endwall;s++)
                    600:                        {
                    601:                                dax += wall[s].x;
                    602:                                day += wall[s].y;
                    603:                                if (wall[s].x < minx) minx = wall[s].x;
                    604:                                if (wall[s].x > maxx) maxx = wall[s].x;
                    605:                                if (wall[s].y < miny) miny = wall[s].y;
                    606:                                if (wall[s].y > maxy) maxy = wall[s].y;
                    607:                        }
                    608:                        if ((maxx-minx > 256) && (maxy-miny > 256))
                    609:                        {
                    610:                                dax /= (endwall-startwall+1);
                    611:                                day /= (endwall-startwall+1);
                    612:                                if (inside(dax,day,k) == 1)
                    613:                                {
                    614:                          j=jsinsertsprite(k,0);
                    615:                          if( j != -1 ) { 
                    616:                                 fillsprite(j,dax,day,sector[k].floorz,0,-8,0,
                    617:                                          12,16,16,0,0,0,0,
                    618:                                          0,0,0,0,k,0,0,0,-1);
                    619:                               sprite[j].z-=((tilesizy[sprite[j].picnum]*sprite[j].yrepeat)<<1);
                    620:                               switch( picnum ) {
                    621:                               }
                    622:                               sprite[j].picnum=picnum;
                    623:                          }
                    624:                                        return;
                    625:                                }
                    626:                        }
                    627:                }
                    628:                cnt--;
                    629:        }
                    630: }
                    631: 
                    632: extern
                    633: short dieframe[];
                    634: 
                    635: tekrestoreplayer(short snum)
                    636: {
                    637:        setsprite(playersprite[snum],posx[snum],posy[snum],posz[snum]+(KENSPLAYERHEIGHT<<8));
                    638:        sprite[playersprite[snum]].ang = ang[snum];
                    639:        sprite[playersprite[snum]].xrepeat = 24;
                    640:        sprite[playersprite[snum]].yrepeat = 24;
                    641:        horiz[snum] = 100;
                    642:      health[snum]=MAXHEALTH;
                    643:      fireseq[snum]=0;
                    644:      restockammo(snum);
                    645:      stun[snum]=MAXSTUN;
                    646:      fallz[snum]=0;
                    647:      drawweap[snum]=0;
                    648:      invredcards[snum]=0;
                    649:      invbluecards[snum]=0;
                    650:      invaccutrak[snum]=0;
                    651:      dieframe[snum]=0;
                    652:      if( option[4] != 0 ) {
                    653:           weapons[snum]=0;
                    654:           weapons[snum]=flags32[GUN2FLAG]|flags32[GUN3FLAG];
                    655:      }
                    656:      else {
                    657:           weapons[snum]=0;
                    658:           weapons[snum]=flags32[GUN1FLAG]|flags32[GUN2FLAG]|flags32[GUN3FLAG];
                    659:      }
                    660: }
                    661: 
                    662: initplayersprite(short snum)
                    663: {
                    664:        long      i;
                    665: 
                    666:        if (playersprite[snum] >= 0) return;
                    667: 
                    668:      i=jsinsertsprite(cursectnum[snum], 8);
                    669:      if( i == -1 ) {
                    670:           crash("initplayersprite: jsinsertsprite on player %d failed", snum);
                    671:      }
                    672:      playersprite[snum]=i;
                    673:      sprite[i].x=posx[snum];
                    674:      sprite[i].y=posy[snum];
                    675:      sprite[i].z=posz[snum]+(KENSPLAYERHEIGHT<<8);
                    676:      sprite[i].cstat = 0x101;
                    677:      sprite[i].shade=0;
                    678:      if( option[4] == 0 ) {
                    679:           sprite[i].pal=0;
                    680:      }
                    681:      else {
                    682:           sprite[i].pal=snum+16;
                    683:      }
                    684:      sprite[i].clipdist=32;
                    685:      sprite[i].xrepeat=24;
                    686:      sprite[i].yrepeat=24;
                    687:      sprite[i].xoffset=0;
                    688:      sprite[i].yoffset=0;
                    689:      sprite[i].picnum=DOOMGUY;
                    690:      sprite[i].ang=ang[snum];
                    691:      sprite[i].xvel=0;
                    692:      sprite[i].yvel=0;
                    693:      sprite[i].zvel=0;
                    694:      sprite[i].owner=snum+4096;
                    695:      sprite[i].sectnum=cursectnum[snum];
                    696:      sprite[i].statnum=8;
                    697:      sprite[i].lotag=0;
                    698:      sprite[i].hitag=0;
                    699:      // important to set extra = -1
                    700:      sprite[i].extra=-1;     
                    701: 
                    702:      tekrestoreplayer(snum);
                    703: }
                    704: 
                    705: initptrlists()
                    706: {
                    707:      int       i;
                    708: 
                    709:      for( i=0; i < MAXSPRITES; i++ ) {
                    710:           sprptr[i]=&sprite[i];
                    711:           sprXTptr[i]=&spriteXT[i];
                    712:      }
                    713:      for( i=0; i < MAXSECTORS; i++ ) {
                    714:           sectptr[i]=&sector[i];
                    715:      }
                    716:      for( i=0; i < MAXWALLS; i++ ) {
                    717:           wallptr[i]=&wall[i];
                    718:      }
                    719: 
                    720:      return 0;
                    721: }
                    722: 
                    723: tekpreinit(void)
                    724: {
                    725:      int  i,j,k,l;
                    726:      FILE *fp;
                    727: 
                    728:      cdpreinit();
                    729: 
                    730:      if( (fp=fopen("lookup.dat","rb")) != NULL ) {  
                    731:           l=getc(fp);
                    732:           for (j=0 ; j < l ; j++) {
                    733:                k=getc(fp);
                    734:                for (i=0 ; i < 256 ; i++) {
                    735:                     tempbuf[i]=getc(fp);
                    736:                }
                    737:                makepalookup(k,tempbuf,0,0,0,1);
                    738:           }
                    739:           fclose(fp);
                    740:      }
                    741:      if( (option[4] != 0) && ((fp=fopen("nlookup.dat","rb")) != NULL) ) {  
                    742:           l=getc(fp);
                    743:           for (j=0 ; j < l ; j++) {
                    744:                k=getc(fp);
                    745:                for (i=0 ; i < 256 ; i++) {
                    746:                     tempbuf[i]=getc(fp);
                    747:                }
                    748:                makepalookup(k+15,tempbuf,0,0,0,1);
                    749:           }
                    750:           fclose(fp);
                    751:      }
                    752: 
                    753:      makepalookup(255,tempbuf,60,60,60,1);
                    754: 
                    755:      pskyoff[0]=0;  // 2 tiles
                    756:      pskyoff[1]=1;
                    757:      pskyoff[2]=2;
                    758:      pskyoff[3]=3;
                    759:      pskybits=2;    // tile 4 times, every 90 deg.
                    760:      parallaxtype=1;   
                    761:      parallaxyoffs=112;
                    762:      initptrlists();
                    763:      initpaletteshifts();
                    764:      initmenu();
                    765:      initmoreoptions();
                    766:      if( screensize == 0 ) {
                    767:           screensize=xdim+8;
                    768:      }
                    769:      activemenu=0;
                    770: 
                    771:      return 0;
                    772: }
                    773: 
                    774: #define   NUMSETOPTS          2
                    775: 
                    776: short     comp;
                    777: long      bps;
                    778: 
                    779: char *setopts[]={
                    780:         "COM PORT:",
                    781:         "BAUD RATE:"
                    782: };
                    783: 
                    784: void
                    785: mdmreadsettings(void)
                    786: {
                    787:         short i,n;
                    788:         long l;
                    789:         char buf[80],*ptr;
                    790:         FILE *fp;
                    791: 
                    792:         fp=fopen("modem.dat","r");
                    793:         if (fp == NULL) {
                    794:                  return;
                    795:         }
                    796:         while (fgets(buf,80,fp) != NULL) {
                    797:                  for (i=0 ; i < NUMSETOPTS ; i++) {
                    798:                           if ((ptr=strstr(buf,setopts[i])) != NULL) {
                    799:                                        ptr+=strlen(setopts[i]);
                    800:                                        switch (i) {
                    801:                                        case 0:   // com port
                    802:                                                 sscanf(ptr,"%d",&n);
                    803:                                                 if (n < 1 || n > 4) {
                    804:                                                          break;
                    805:                                                 }
                    806:                                                 comp=n;
                    807:                                                 break;
                    808:                                        case 1:   // baud rate
                    809:                                                 sscanf(ptr,"%ld",&l);
                    810:                                                 if (l < 2400L || l > 115200L) {
                    811:                                                          break;
                    812:                                                 }
                    813:                                                 bps=l;
                    814:                                                 break;
                    815:                                        }
                    816:                           }
                    817:                  }
                    818:         }
                    819:         fclose(fp);
                    820: }
                    821: 
                    822: tekinitmultiplayers()
                    823: {
                    824:      char      opt5=0;
                    825: 
                    826:      if( (option[4] > 0) && (option[4] < 5) ) {
                    827:           mdmreadsettings();
                    828:           switch( bps ) {
                    829:           case 2400:  opt5=0x00; break;
                    830:           case 4800:  opt5=0x01; break;
                    831:           case 14400: opt5=0x03; break;
                    832:           case 19200: opt5=0x04; break;
                    833:           case 28800: opt5=0x05; break;
                    834:           default:    opt5=0x02; break;
                    835:           }
                    836:           if( (comp == 1) || (comp == 3) ) {
                    837:                opt5|=0x20;
                    838:           }
                    839:           else {
                    840:                opt5|=0x10;
                    841:           }
                    842:             initmultiplayers(comp,opt5);
                    843:      }
                    844:      else {
                    845:             initmultiplayers(option[4],option[5]);
                    846:      }
                    847: }
                    848: 
                    849: extern
                    850: char palette[],
                    851:      palette1[256][3],
                    852:      palette2[256][3];
                    853: 
                    854: extern
                    855: int  noenemiesflag;
                    856: 
                    857: short mappic[]={
                    858:      1608,1609,1610,1611,1612,1613,1614
                    859: };
                    860: 
                    861: int  coopmode,
                    862:      switchlevelsflag;
                    863: 
                    864: void
                    865: teknetpickmap(void)
                    866: {
                    867:      short i,map=0;
                    868:      long lastclock=0L,rotangle=0L,zoom=0L;
                    869: 
                    870:      noenemiesflag=1;
                    871:      if (coopmode) {
                    872:           noenemiesflag=0;
                    873:      }
                    874:      if (switchlevelsflag) {
                    875:           strcpy(boardfilename,"NET1.MAP");
                    876:      }
                    877:      setgamemode();
                    878:      initpaletteshifts();
                    879:      memcpy(palette1, palette, 768);
                    880:      memset(palette, 0, 768);
                    881:      clearview(0);
                    882:      if (switchlevelsflag) {
                    883:           goto skippick;
                    884:      }
                    885:      lastclock=totalclock;
                    886:      do {
                    887:           if (keystatus[0x49] || keystatus[0x4B] || keystatus[0xC9] || keystatus[0xCB]) {
                    888:                if (map > 0) {
                    889:                     map--;
                    890:                }
                    891:                else {
                    892:                     map=6;
                    893:                }
                    894:                keystatus[0x49]=keystatus[0x4B]=0;
                    895:                keystatus[0xC9]=keystatus[0xCB]=0;
                    896:                zoom=0L;
                    897:           }
                    898:           if (keystatus[0x51] || keystatus[0x4D] || keystatus[0xD1] || keystatus[0xCD]) {
                    899:                if (map < 6) {
                    900:                     map++;
                    901:                }
                    902:                else {
                    903:                     map=0;
                    904:                }
                    905:                keystatus[0x51]=keystatus[0x4D]=0;
                    906:                keystatus[0xD1]=keystatus[0xCD]=0;
                    907:                zoom=0L;
                    908:           }
                    909:           zoom+=(totalclock-lastclock)<<10;
                    910:           rotangle+=((totalclock-lastclock)<<5);
                    911:           lastclock=totalclock;
                    912:           if (zoom > 65536L) {
                    913:                zoom=65536L;
                    914:                rotangle=0;
                    915:           }
                    916:           clearview(0);
                    917:           rotatesprite(xdim<<15,ydim<<15,zoom,rotangle,mappic[map],0,0,0);
                    918:           overwritesprite((xdim>>1)-160,0,408,0,0,0);
                    919:           sprintf(tempbuf,"MULTIPLAYER MAP %d",map+1);
                    920:           printext((xdim>>1)-(strlen(tempbuf)<<2),ydim-16,tempbuf,ALPHABET2,255);
                    921:           nextpage();
                    922:      } while (keystatus[0x1C] == 0 && keystatus[0x9C] == 0 && keystatus[0x01] == 0);
                    923:      if (keystatus[0x1C] || keystatus[0x9C]) {
                    924:           keystatus[0x1C]=0;
                    925:           sprintf(boardfilename,"NET%d.MAP",map+1);
                    926:      }
                    927:      else if (keystatus[0x01]) {
                    928:           keystatus[0x01]=0;
                    929:           crash("Multiplayer game aborted!");
                    930:      }
                    931: skippick:
                    932:      prepareboard(boardfilename);
                    933:      precache();
                    934:      clearview(0);
                    935:      memcpy(palette, palette1, 768);
                    936:      fadein(0,255,16);
                    937: }
                    938: 
                    939: tekloadsetup()
                    940: {
                    941:        int  fil;
                    942:      
                    943:        if ((fil = open("setup.dat",O_BINARY|O_RDWR,S_IREAD)) != -1)
                    944:        {
                    945:                read(fil,&option[0],NUMOPTIONS);
                    946:                read(fil,&keys[0],NUMKEYS);
                    947:           tekloadmoreoptions(fil);
                    948:                close(fil);
                    949:        }
                    950:        switch( option[0] ) {
                    951:                case 0: initengine(0,chainxres[option[6]&15],chainyres[option[6]>>4]); break;
                    952:                case 1: initengine(1,vesares[option[6]&15][0],vesares[option[6]&15][1]); break;
                    953:                case 2: initengine(2,320L,200L); break;
                    954:                case 3: initengine(3,320L,200L); break;
                    955:                case 4: initengine(4,320L,200L); break;
                    956:                case 5: initengine(5,320L,200L); break;
                    957:                case 6: initengine(6,320L,200L); break;
                    958:        }
                    959: }
                    960: 
                    961: teksavesetup(void)
                    962: {
                    963:      int  fil;
                    964: 
                    965:      if ((fil=open("setup.dat",O_BINARY|O_RDWR,S_IREAD)) != -1) {
                    966:           if (option[4] < 5) {
                    967:                option[4]=0;
                    968:           }
                    969:           write(fil,&option[0],NUMOPTIONS);
                    970:           write(fil,&keys[0],NUMKEYS);
                    971:           teksavemoreoptions(fil);
                    972:           close(fil);
                    973:      }
                    974: }
                    975: 
                    976: tekview(long *x1,long *y1, long *x2,long *y2)
                    977: {
                    978:      if( screensize <= xdim ) {
                    979:           *y1+=16;
                    980:           *y2+=16;
                    981:      }
                    982: }

unix.superglobalmegacorp.com