Annotation of src/tektag.c, revision 1.1.1.1

1.1       root        1: /***************************************************************************
                      2:  *   TEKTAG.C  - Tag specific code for TEKWAR game                         *
                      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 "build.h"
                     13: #include "names.h"
                     14: 
                     15: #include "tekwar.h"
                     16: 
                     17: struct    soundtype {
                     18:      int       handle;
                     19:      int       offset;
                     20:      int       plevel;
                     21:      int       playing;
                     22:      long      x,y;
                     23:      long      cache_ptr;
                     24:      long      cache_length;
                     25:      char      cache_lock;
                     26: };
                     27: extern    struct    soundtype     *dsoundptr[MAXSOUNDS];
                     28: extern    char      soundmode;
                     29: extern    int       goreflag;
                     30: extern    char      activemenu;
                     31: 
                     32: //jsa new stuff for vehicle sound switching
                     33: extern    char *mapnames[];
                     34: 
                     35: #define   AMBUPDATEDIST  4000L
                     36: 
                     37: #define   BOBBMAX        512
                     38: #define   BOBBDELTA      128
                     39: 
                     40: int       headbobon=1;
                     41: long      headbob,bobstep=BOBBDELTA;
                     42: 
                     43: #define   VEHICLEHEIGHT  -13312
                     44: 
                     45: #define   MAXANIMPICS         32
                     46: #define   MAXDELAYFUNCTIONS   32
                     47: 
                     48: #define   BLUEKEYITEM         0
                     49: #define   REDKEYITEM          1
                     50: #define   ELEVACTIVATED       31
                     51: 
                     52: #define   DOORUPTAG           6
                     53: #define   DOORDOWNTAG         7
                     54: #define   DOORSPLITHOR        8
                     55: #define   DOORSPLITVER        9
                     56: #define   DOORSWINGTAG        13
                     57: #define   DOORREVOLVETAG      14        // sector tags
                     58: 
                     59: #define   PLATFORMELEVTAG     1000      // additional sector tags
                     60: #define   BOXELEVTAG          1003
                     61: #define   PLATFORMDELAYTAG    1004
                     62: #define   BOXDELAYTAG         1005
                     63: #define   DOORFLOORTAG        1006
                     64: #define   PLATFORMDROPTAG     1007
                     65: 
                     66: #define   DST_BAYDOOR         10
                     67: #define   DST_HYDRAULICDOOR   20
                     68: #define   DST_ELEVATORDOOR    30
                     69: #define   DST_MATRIXDOOR1     40
                     70: #define   DST_MATRIXDOOR2     50
                     71: #define   DST_MATRIXDOOR3     60
                     72: #define   DST_MATRIXDOOR4     70
                     73: 
                     74: #define   SPRITEELEVATORTAG   1500
                     75: 
                     76: #define   PULSELIGHT          0         // sector effect tags flags32[]
                     77: #define   FLICKERLIGHT        1
                     78: #define   DELAYEFFECT         2
                     79: #define   WPANNING            3
                     80: #define   FPANNING            4
                     81: #define   CPANNING            5
                     82: #define   FLICKERDELAY        6
                     83: #define   BLINKDELAY          7
                     84: #define   STEADYLIGHT         8
                     85: #define   WARPSECTOR          9
                     86: #define   KILLSECTOR          10
                     87: #define   DOORSPEEDEFFECT     11
                     88: #define   QUICKCLOSE          12
                     89: #define   SOUNDON             13
                     90: #define   SOUNDOFF            14
                     91: #define   DOORSUBTYPE         15
                     92: 
                     93: #define   DOORDELAY      (CLKIPS*4)
                     94: #define   DOORSPEED      128L
                     95: #define   ELEVSPEED      256L
                     96: 
                     97: char onelev[MAXPLAYERS];
                     98: 
                     99: struct sectoreffect {
                    100:      unsigned long sectorflags;
                    101:      long animate;
                    102:      int  hi,lo;
                    103:      int  delay,delayreset;
                    104:      int  ang;
                    105:      int  triggerable;
                    106:      int  warpto;
                    107:      long warpx,warpy,warpz;
                    108:      long sin,cos;
                    109:      short damage;
                    110: };
                    111: struct    sectoreffect   sectoreffect[MAXSECTORS];
                    112: struct    sectoreffect   *septrlist[MAXSECTORS];
                    113: int       secnt,sexref[MAXSECTORS];
                    114: 
                    115: #define   MAXDOORS       200
                    116: enum {
                    117:      D_NOTHING=0,
                    118:      D_OPENDOOR,
                    119:      D_CLOSEDOOR,
                    120:      D_OPENING,
                    121:      D_CLOSING,
                    122:      D_WAITING,
                    123:      D_SHUTSOUND,
                    124:      D_OPENSOUND
                    125: };
                    126: enum {
                    127:      DOORCLOSED=0,
                    128:      DOOROPENING,
                    129:      DOOROPENED,
                    130:      DOORCLOSING
                    131: };
                    132: struct doortype {
                    133:      int  type;
                    134:      int  state;
                    135:      int  sector;
                    136:      int  step;
                    137:      int  delay;
                    138:      long goalz[4];
                    139:      long points[4];
                    140:      int  walls[8];
                    141:      long centx;
                    142:      long centy;
                    143:      long centz;
                    144:      int  subtype;   // jeff added 9-20
                    145: };
                    146: struct    doortype  doortype[MAXDOORS];
                    147: struct    doortype  *doorptr[MAXDOORS];
                    148: int       doorxref[MAXSECTORS],numdoors;
                    149: 
                    150: #define   MAXFLOORDOORS  25
                    151: struct floordoor {
                    152:      int  state;
                    153:      int  sectnum;
                    154:      int  wall1,wall2;
                    155:      int  dist1,dist2;
                    156:      int  dir;
                    157: };
                    158: struct    floordoor      floordoor[MAXFLOORDOORS];
                    159: struct    floordoor      *floordoorptr[MAXFLOORDOORS];
                    160: int       fdxref[MAXSECTORS],numfloordoors;
                    161: 
                    162: #define   MAXSECTORVEHICLES   10
                    163: #define   MAXVEHICLEPOINTS    200
                    164: #define   MAXVEHICLETRACKS    50
                    165: #define   MAXVEHICLESECTORS   30                                
                    166: #define   SECTORVEHICLETAG    1010
                    167: struct sectorvehicle {
                    168:      short acceleration,accelto;
                    169:      short speed,speedto,movespeed;                              
                    170:      short angle,angleto;
                    171:      long pivotx,pivoty;
                    172:      short numpoints;
                    173:      short point[MAXVEHICLEPOINTS];
                    174:      long pointx[MAXVEHICLEPOINTS];
                    175:      long pointy[MAXVEHICLEPOINTS];
                    176:      short track;
                    177:      short tracknum;
                    178:      long trackx[MAXVEHICLETRACKS];
                    179:      long tracky[MAXVEHICLETRACKS];
                    180:      char stop[MAXVEHICLETRACKS];                                
                    181:      long distx,disty;
                    182:      short sector[MAXVEHICLESECTORS];                            
                    183:      short numsectors;                                           
                    184:      long waittics,waitdelay;                                    
                    185:      short stoptrack;
                    186:      short killw[4];
                    187:      int       soundindex;          
                    188: };
                    189: struct    sectorvehicle  sectorvehicle[MAXSECTORVEHICLES];
                    190: struct    sectorvehicle  *sectvehptr[MAXSECTORVEHICLES];
                    191: int       numvehicles;
                    192: 
                    193: #define   MAXSPRITEELEVS 25
                    194: #define   MAXPARTS       20
                    195: #define   MAXELEVFLOORS  20
                    196: #define   MAXELEVDOORS   4
                    197: enum {
                    198:      E_OPENINGDOOR=0,
                    199:      E_CLOSINGDOOR,
                    200:      E_WAITING,
                    201:      E_MOVING,
                    202:      E_NEXTFLOOR
                    203: };
                    204: enum {
                    205:      E_GOINGUP=0,
                    206:      E_GOINGDOWN
                    207: };
                    208: #define   E_WAITDELAY    CLKIPS*4
                    209: #define   E_DOOROPENPOS  15360
                    210: struct elevatortype {
                    211:      long hilevel;
                    212:      long lolevel;
                    213: };
                    214: struct    elevatortype   elevator[MAXSECTORS];
                    215: struct    elevatortype   *evptrlist[MAXSECTORS];
                    216: 
                    217: struct spriteelev {
                    218:      int  state;
                    219:      int  parts;
                    220:      int  sprnum[MAXPARTS];
                    221:      int  door[MAXELEVDOORS];
                    222:      long doorpos;
                    223:      long startz[MAXPARTS];
                    224:      long floorz[MAXELEVFLOORS];
                    225:      int  curfloor;
                    226:      int  curdir;
                    227:      int  delay;
                    228:      int  floors;
                    229:      long floorpos;
                    230:      int  doors;
                    231: };
                    232: struct    spriteelev     spriteelev[MAXSPRITEELEVS];
                    233: struct    spriteelev     *sprelevptr[MAXSPRITEELEVS];
                    234: int       sprelevcnt;
                    235: 
                    236: unsigned
                    237: long flags32[32]={
                    238:      0x80000000,0x40000000,0x20000000,0x10000000,
                    239:      0x08000000,0x04000000,0x02000000,0x01000000,
                    240:      0x00800000,0x00400000,0x00200000,0x00100000,
                    241:      0x00080000,0x00040000,0x00020000,0x00010000,
                    242:      0x00008000,0x00004000,0x00002000,0x00001000,
                    243:      0x00000800,0x00000400,0x00000200,0x00000100,
                    244:      0x00000080,0x00000040,0x00000020,0x00000010,
                    245:      0x00000008,0x00000004,0x00000002,0x00000001
                    246: };
                    247: 
                    248: #define   MAXMAPSOUNDFX            32
                    249: #define   MAP_SFX_AMBIENT          0
                    250: #define   MAP_SFX_SECTOR           1
                    251: #define   MAP_SFX_TOGGLED          2
                    252: #define   MAP_SFX_TURN_ON          3
                    253: #define   MAP_SFX_TURN_OFF         4
                    254: struct mapsndfxtype {
                    255:      long      x,y;
                    256:      short     sector;
                    257:      int       snum;
                    258:      int       loops;
                    259:      int       type;
                    260:      int       id;
                    261: };
                    262: struct    mapsndfxtype    mapsndfx[MAXMAPSOUNDFX];
                    263: struct    mapsndfxtype    *mapsndfxptr[MAXMAPSOUNDFX];
                    264: int       totalmapsndfx=0;
                    265: 
                    266: long      ambupdateclock;
                    267: 
                    268: struct animpic {
                    269:      short frames;
                    270:      short *pic;
                    271:      short tics;
                    272:      long nextclock;
                    273: } animpic[MAXANIMPICS],*animpicptr[MAXANIMPICS];
                    274: 
                    275: struct delayfunc {
                    276:      void (*func)(short);
                    277:      int  tics;
                    278:      short parm;
                    279: } delayfunc[MAXDELAYFUNCTIONS],*delayfuncptr[MAXDELAYFUNCTIONS];
                    280: 
                    281: extern    void      newmap(int);
                    282: 
                    283: long      subwaystopdir[4] = { 1L, 1L, 1L, 1L };
                    284: void      checktoggledmapsndfx(short dasect) ;
                    285: int       numanimates;
                    286: short     numdelayfuncs;
                    287: int       loopinsound=-1;
                    288: int       baydoorloop=-1;
                    289: int       ambsubloop=-1;
                    290: 
                    291: #pragma aux copybuf =\
                    292:        "rep movsd",\
                    293:        parm [esi][edi][ecx]\
                    294: 
                    295: #pragma aux klabs =\
                    296:        "test eax, eax",\
                    297:        "jns skipnegate",\
                    298:        "neg eax",\
                    299:        "skipnegate:",\
                    300:        parm [eax]\
                    301: 
                    302: 
                    303: operatesector(short dasector)
                    304: {     //Door code
                    305:        long i, j, k, s, nexti, good, cnt, datag;
                    306:        long dax, day, daz, dax2, day2, daz2, centx, centy;
                    307:        short startwall, endwall, wallfind[2];
                    308: 
                    309:        datag = sector[dasector].lotag;
                    310: 
                    311:      // lights out / on
                    312:      if( datag == 33 ) {
                    313:           if( sectptr[dasector]->visibility >= 212 ) {
                    314:                sectptr[dasector]->visibility=0;
                    315:           }
                    316:           else {
                    317:                sectptr[dasector]->visibility=212;
                    318:           }
                    319:           return;
                    320:      }
                    321: 
                    322:        startwall = sector[dasector].wallptr;
                    323:        endwall = startwall + sector[dasector].wallnum - 1;
                    324:        centx = 0L, centy = 0L;
                    325:        for(i=startwall;i<=endwall;i++)
                    326:        {
                    327:                centx += wall[i].x;
                    328:                centy += wall[i].y;
                    329:        }
                    330:        centx /= (endwall-startwall+1);
                    331:        centy /= (endwall-startwall+1);
                    332: 
                    333:      // kens swinging door
                    334:        if( datag == 13 ) {  
                    335:                for( i=0; i<swingcnt; i++ ) {
                    336:                        if( swingsector[i] == dasector ) {
                    337:                                if( swinganginc[i] == 0 ) {
                    338:                                        if( swingang[i] == swingangclosed[i] ) {
                    339:                                                swinganginc[i] = swingangopendir[i];
                    340:                                        }
                    341:                                        else {
                    342:                                                swinganginc[i] = -swingangopendir[i];
                    343:                          }
                    344:                                }
                    345:                                else {
                    346:                                        swinganginc[i] = -swinganginc[i];
                    347:                     }
                    348:                        }
                    349:                }
                    350:        }
                    351: 
                    352:      // kens true sideways double-sliding door
                    353:        if( datag == 16 ) {
                    354:             // get 2 closest line segments to center (dax, day)
                    355:                wallfind[0] = -1;
                    356:                wallfind[1] = -1;
                    357:                for( i=startwall;i<=endwall;i++ )
                    358:                        if (wall[i].lotag == 6)
                    359:                        {
                    360:                                if (wallfind[0] == -1)
                    361:                                        wallfind[0] = i;
                    362:                                else
                    363:                                        wallfind[1] = i;
                    364:                        }
                    365: 
                    366:                for(j=0;j<2;j++)
                    367:                {
                    368:                        if ((((wall[wallfind[j]].x+wall[wall[wallfind[j]].point2].x)>>1) == centx) && (((wall[wallfind[j]].y+wall[wall[wallfind[j]].point2].y)>>1) == centy))
                    369:                        {     //door was closed
                    370:                                        //find what direction door should open
                    371:                                i = wallfind[j]-1; if (i < startwall) i = endwall;
                    372:                                dax2 = wall[i].x-wall[wallfind[j]].x;
                    373:                                day2 = wall[i].y-wall[wallfind[j]].y;
                    374:                                if (dax2 != 0)
                    375:                                {
                    376:                                        dax2 = wall[wall[wall[wall[wallfind[j]].point2].point2].point2].x;
                    377:                                        dax2 -= wall[wall[wall[wallfind[j]].point2].point2].x;
                    378:                                        setanimation(&wall[wallfind[j]].x,wall[wallfind[j]].x+dax2,4L,0L);
                    379:                                        setanimation(&wall[i].x,wall[i].x+dax2,4L,0L);
                    380:                                        setanimation(&wall[wall[wallfind[j]].point2].x,wall[wall[wallfind[j]].point2].x+dax2,4L,0L);
                    381:                                        setanimation(&wall[wall[wall[wallfind[j]].point2].point2].x,wall[wall[wall[wallfind[j]].point2].point2].x+dax2,4L,0L);
                    382:                                }
                    383:                                else if (day2 != 0)
                    384:                                {
                    385:                                        day2 = wall[wall[wall[wall[wallfind[j]].point2].point2].point2].y;
                    386:                                        day2 -= wall[wall[wall[wallfind[j]].point2].point2].y;
                    387:                                        setanimation(&wall[wallfind[j]].y,wall[wallfind[j]].y+day2,4L,0L);
                    388:                                        setanimation(&wall[i].y,wall[i].y+day2,4L,0L);
                    389:                                        setanimation(&wall[wall[wallfind[j]].point2].y,wall[wall[wallfind[j]].point2].y+day2,4L,0L);
                    390:                                        setanimation(&wall[wall[wall[wallfind[j]].point2].point2].y,wall[wall[wall[wallfind[j]].point2].point2].y+day2,4L,0L);
                    391:                                }
                    392:                        }
                    393:                        else
                    394:                        {    //door was not closed
                    395:                                i = wallfind[j]-1; if (i < startwall) i = endwall;
                    396:                                dax2 = wall[i].x-wall[wallfind[j]].x;
                    397:                                day2 = wall[i].y-wall[wallfind[j]].y;
                    398:                                if (dax2 != 0)
                    399:                                {
                    400:                                        setanimation(&wall[wallfind[j]].x,centx,4L,0L);
                    401:                                        setanimation(&wall[i].x,centx+dax2,4L,0L);
                    402:                                        setanimation(&wall[wall[wallfind[j]].point2].x,centx,4L,0L);
                    403:                                        setanimation(&wall[wall[wall[wallfind[j]].point2].point2].x,centx+dax2,4L,0L);
                    404:                                }
                    405:                                else if (day2 != 0)
                    406:                                {
                    407:                                        setanimation(&wall[wallfind[j]].y,centy,4L,0L);
                    408:                                        setanimation(&wall[i].y,centy+day2,4L,0L);
                    409:                                        setanimation(&wall[wall[wallfind[j]].point2].y,centy,4L,0L);
                    410:                                        setanimation(&wall[wall[wall[wallfind[j]].point2].point2].y,centy+day2,4L,0L);
                    411:                                }
                    412:                        }
                    413:                }
                    414:        }
                    415: 
                    416:      tekoperatesector(dasector);
                    417: }
                    418: 
                    419: 
                    420: extern    int  subwaysound[4];
                    421: 
                    422: tagcode()
                    423: {
                    424:        long      i, nexti, j, k, l, s, dax, day, daz, dax2, day2, cnt, good;
                    425:        short     startwall, endwall, dasector, p, oldang;
                    426: 
                    427:        for(i=0;i<warpsectorcnt;i++)
                    428:        {
                    429:                dasector = warpsectorlist[i];
                    430:                j = ((lockclock&127)>>2);
                    431:                if (j >= 16) j = 31-j;
                    432:                {
                    433:                        sector[dasector].ceilingshade = j;
                    434:                        sector[dasector].floorshade = j;
                    435:                        startwall = sector[dasector].wallptr;
                    436:                        endwall = startwall+sector[dasector].wallnum-1;
                    437:                        for(s=startwall;s<=endwall;s++)
                    438:                                wall[s].shade = j;
                    439:                }
                    440:        }
                    441: 
                    442:        for(p=connecthead;p>=0;p=connectpoint2[p])
                    443:                if (sector[cursectnum[p]].lotag == 10)  //warp sector
                    444:                {
                    445:                        if (cursectnum[p] != ocursectnum[p])
                    446:                        {
                    447:                                warpsprite(playersprite[p]);
                    448:                                posx[p] = sprite[playersprite[p]].x;
                    449:                                posy[p] = sprite[playersprite[p]].y;
                    450:                                posz[p] = sprite[playersprite[p]].z;
                    451:                                ang[p] = sprite[playersprite[p]].ang;
                    452:                                cursectnum[p] = sprite[playersprite[p]].sectnum;
                    453:                                sprite[playersprite[p]].z += (KENSPLAYERHEIGHT<<8);
                    454:                        }
                    455:                }
                    456: 
                    457: 
                    458:        for( i=0; i<xpanningsectorcnt; i++ ) {
                    459:                dasector = xpanningsectorlist[i];
                    460:                startwall = sector[dasector].wallptr;
                    461:                endwall = startwall+sector[dasector].wallnum-1;
                    462:                for( s=startwall; s<=endwall; s++ ) {
                    463:                        wall[s].xpanning = ((lockclock>>2)&255);
                    464:           }
                    465:        }
                    466: 
                    467:        for( i=0; i<ypanningwallcnt; i++ ) {
                    468:                wall[ypanningwalllist[i]].ypanning = ~(lockclock&255);
                    469:      }
                    470: 
                    471:        for( i=0; i<rotatespritecnt; i++ ) {
                    472:                sprite[rotatespritelist[i]].ang += (TICSPERFRAME<<2);
                    473:                sprite[rotatespritelist[i]].ang &= 2047;
                    474:        }
                    475: 
                    476:      // kens slime floor
                    477:        for( i=0; i<floorpanningcnt; i++ ) {
                    478:                sector[floorpanninglist[i]].floorxpanning = ((lockclock>>2)&255);
                    479:                sector[floorpanninglist[i]].floorypanning = ((lockclock>>2)&255);
                    480:        }
                    481: 
                    482:        for( i=0; i<dragsectorcnt; i++ ) {
                    483:                dasector = dragsectorlist[i];
                    484:                startwall = sector[dasector].wallptr;
                    485:                endwall = startwall+sector[dasector].wallnum-1;
                    486:                if (wall[startwall].x+dragxdir[i] < dragx1[i]) dragxdir[i] = 16;
                    487:                if (wall[startwall].y+dragydir[i] < dragy1[i]) dragydir[i] = 16;
                    488:                if (wall[startwall].x+dragxdir[i] > dragx2[i]) dragxdir[i] = -16;
                    489:                if (wall[startwall].y+dragydir[i] > dragy2[i]) dragydir[i] = -16;
                    490:                for( j=startwall; j<=endwall; j++) {
                    491:                        dragpoint(j,wall[j].x+dragxdir[i],wall[j].y+dragydir[i]);
                    492:           }
                    493:                j = sector[dasector].floorz;
                    494:                sector[dasector].floorz = dragfloorz[i]+(sintable[(lockclock<<4)&2047]>>3);
                    495:                for( p=connecthead; p>=0; p=connectpoint2[p] ) {
                    496:                        if( cursectnum[p] == dasector ) {
                    497:                                posx[p] += dragxdir[i];
                    498:                                posy[p] += dragydir[i];
                    499:                                posz[p] += (sector[dasector].floorz-j);
                    500:                                setsprite(playersprite[p],posx[p],posy[p],posz[p]+(KENSPLAYERHEIGHT<<8));
                    501:                                sprite[playersprite[p]].ang = ang[p];
                    502:                                frameinterpolate = 0;
                    503:                        }
                    504:           }
                    505:        }
                    506: 
                    507:        for(i=0;i<swingcnt;i++)
                    508:        {
                    509:                if (swinganginc[i] != 0)
                    510:                {
                    511:                        oldang = swingang[i];
                    512:                        for(j=0;j<(TICSPERFRAME<<2);j++)
                    513:                        {
                    514:                                swingang[i] = ((swingang[i]+2048+swinganginc[i])&2047);
                    515:                                if (swingang[i] == swingangclosed[i])
                    516:                                {
                    517:                          if( j == ((TICSPERFRAME<<2)-1) ) {
                    518:                               playsound(S_JUMP,swingx[i][0],swingy[i][0],0,ST_UPDATE);
                    519:                          }
                    520:                                        swinganginc[i] = 0;
                    521:                                }
                    522:                                if (swingang[i] == swingangopen[i]) { 
                    523:                          if( j == ((TICSPERFRAME<<2)-1) ) {
                    524:                               playsound(S_JUMP,swingx[i][0],swingy[i][0],0,ST_UPDATE);
                    525:                          }
                    526:                          swinganginc[i] = 0;
                    527:                     }
                    528:                        }
                    529:                        for(k=1;k<=3;k++)
                    530:                                rotatepoint(swingx[i][0],swingy[i][0],swingx[i][k],swingy[i][k],swingang[i],&wall[swingwall[i][k]].x,&wall[swingwall[i][k]].y);
                    531: 
                    532:                        if (swinganginc[i] != 0)
                    533:                        {
                    534:                                for(p=connecthead;p>=0;p=connectpoint2[p])
                    535:                                        if ((cursectnum[p] == swingsector[i]) || (testneighborsectors(cursectnum[p],swingsector[i]) == 1))
                    536:                                        {
                    537:                                                cnt = 256;
                    538:                                                do
                    539:                                                {
                    540:                                                        good = 1;
                    541: 
                    542:                                                                //swingangopendir is -1 if forwards, 1 is backwards
                    543:                                                        l = (swingangopendir[i] > 0);
                    544:                                                        for(k=l+3;k>=l;k--)
                    545:                                                                if (clipinsidebox(posx[p],posy[p],swingwall[i][k],128L) != 0)
                    546:                                                                {
                    547:                                                                        good = 0;
                    548:                                                                        break;
                    549:                                                                }
                    550: 
                    551:                                                        if (good == 0)
                    552:                                                        {
                    553:                                                                if (cnt == 256)
                    554:                                                                {
                    555:                                                                        swinganginc[i] = -swinganginc[i];
                    556:                                                                        swingang[i] = oldang;
                    557:                                                                }
                    558:                                                                else
                    559:                                                                {
                    560:                                                                        swingang[i] = ((swingang[i]+2048-swinganginc[i])&2047);
                    561:                                                                }
                    562:                                                                for(k=1;k<=3;k++)
                    563:                                                                        rotatepoint(swingx[i][0],swingy[i][0],swingx[i][k],swingy[i][k],swingang[i],&wall[swingwall[i][k]].x,&wall[swingwall[i][k]].y);
                    564:                                                                if (swingang[i] == swingangclosed[i])
                    565:                                                                {
                    566:                                                                        swinganginc[i] = 0;
                    567:                                                                        break;
                    568:                                                                }
                    569:                                                                if (swingang[i] == swingangopen[i])
                    570:                                                                {
                    571:                                                                        swinganginc[i] = 0;
                    572:                                                                        break;
                    573:                                                                }
                    574:                                                                cnt--;
                    575:                                                        }
                    576:                                                } while ((good == 0) && (cnt > 0));
                    577:                                        }
                    578:                        }
                    579: 
                    580:                }
                    581:        }
                    582: 
                    583:        for(i=0;i<revolvecnt;i++)
                    584:        {
                    585:                startwall = sector[revolvesector[i]].wallptr;
                    586:                endwall = startwall + sector[revolvesector[i]].wallnum - 1;
                    587: 
                    588:                revolveang[i] = ((revolveang[i]+2048-(TICSPERFRAME<<2))&2047);
                    589:                for(k=startwall;k<=endwall;k++)
                    590:                {
                    591:                        rotatepoint(revolvepivotx[i],revolvepivoty[i],revolvex[i][k-startwall],revolvey[i][k-startwall],revolveang[i],&dax,&day);
                    592:                        dragpoint(k,dax,day);
                    593:                }
                    594:        }
                    595: 
                    596:        for(i=0;i<subwaytrackcnt;i++)
                    597:        {
                    598:           if( subwaysound[i] == -1 ) {
                    599:                subwaysound[i]=playsound(S_SUBWAYLOOP,subwayx[i],subwaytracky1[i],-1,ST_VEHUPDATE);
                    600:           }
                    601:           else {
                    602:                  updatevehiclesnds(subwaysound[i],subwayx[i],subwaytracky1[i]);
                    603:           }
                    604: 
                    605:                dasector = subwaytracksector[i][0];
                    606:                startwall = sector[dasector].wallptr;
                    607:                endwall = startwall+sector[dasector].wallnum-1;
                    608:                for(k=startwall;k<=endwall;k++)
                    609:                {
                    610:                        if (wall[k].x > subwaytrackx1[i])
                    611:                                if (wall[k].y > subwaytracky1[i])
                    612:                                        if (wall[k].x < subwaytrackx2[i])
                    613:                                                if (wall[k].y < subwaytracky2[i])
                    614:                                                        wall[k].x += (subwayvel[i]&0xfffffffc);
                    615:                }
                    616: 
                    617:                for(j=1;j<subwaynumsectors[i];j++)
                    618:                {
                    619:                        dasector = subwaytracksector[i][j];
                    620: 
                    621:                        startwall = sector[dasector].wallptr;
                    622:                        endwall = startwall+sector[dasector].wallnum-1;
                    623:                        for(k=startwall;k<=endwall;k++)
                    624:                                wall[k].x += (subwayvel[i]&0xfffffffc);
                    625: 
                    626:                        s = headspritesect[dasector];
                    627:                        while (s != -1)
                    628:                        {
                    629:                                k = nextspritesect[s];
                    630:                                sprite[s].x += (subwayvel[i]&0xfffffffc);
                    631:                                s = k;
                    632:                        }
                    633:                }
                    634: 
                    635:                for(p=connecthead;p>=0;p=connectpoint2[p])
                    636:                        if (cursectnum[p] != subwaytracksector[i][0])
                    637:                                if (sector[cursectnum[p]].floorz != sector[subwaytracksector[i][0]].floorz)
                    638:                                        if (posx[p] > subwaytrackx1[i])
                    639:                                                if (posy[p] > subwaytracky1[i])
                    640:                                                        if (posx[p] < subwaytrackx2[i])
                    641:                                                                if (posy[p] < subwaytracky2[i])
                    642:                                                                {
                    643:                                                                        posx[p] += (subwayvel[i]&0xfffffffc);
                    644: 
                    645:                                                                                //Update sprite representation of player
                    646:                                                                        setsprite(playersprite[p],posx[p],posy[p],posz[p]+(KENSPLAYERHEIGHT<<8));
                    647:                                                                        sprite[playersprite[p]].ang = ang[p];
                    648:                                                                        frameinterpolate = 0;
                    649:                                                                }
                    650: 
                    651:                subwayx[i] += (subwayvel[i]&0xfffffffc);
                    652: 
                    653:                k = subwaystop[i][subwaygoalstop[i]] - subwayx[i];
                    654:                if( k > 0 ) { 
                    655:                        if( k > 2048 ) {
                    656:                     if( subwayvel[i] == 12 ) {
                    657:                          playsound(S_SUBWAYSTART,subwayx[0],subwaytracky1[0],0,ST_UNIQUE | ST_NOUPDATE);
                    658:                     }
                    659:                                if (subwayvel[i] < 128) subwayvel[i]++;
                    660:                        }
                    661:                        else {
                    662:                     if( subwayvel[i] == 32 ) {
                    663:                          playsound(S_SUBWAYSTOP,subwayx[0],subwaytracky1[0],0,ST_UNIQUE | ST_NOUPDATE);
                    664:                     }
                    665:                                subwayvel[i] = (k>>4)+1;
                    666:                }
                    667:                }
                    668:                else if( k < 0 ) {
                    669:                        if( k < -2048 ) {
                    670:                     if( subwayvel[i] == -12 ) {
                    671:                          playsound(S_SUBWAYSTART,subwayx[0],subwaytracky1[0],0,ST_UNIQUE | ST_NOUPDATE);
                    672:                     }
                    673:                                if (subwayvel[i] > -128) subwayvel[i]--;
                    674:                        }
                    675:                        else {
                    676:                     if( subwayvel[i] == -32) {
                    677:                          playsound(S_SUBWAYSTOP,subwayx[0],subwaytracky1[0],0,ST_UNIQUE | ST_NOUPDATE);
                    678:                     }
                    679:                                subwayvel[i] = ((k>>4)-1);
                    680:                }
                    681:                }
                    682: 
                    683:                if (((subwayvel[i]>>2) == 0) && (labs(k) < 2048))
                    684:                {
                    685:                        if (subwaypausetime[i] == 720)
                    686:                        {
                    687:                                for(j=1;j<subwaynumsectors[i];j++)   //Open all subway doors
                    688:                                {
                    689:                                        dasector = subwaytracksector[i][j];
                    690:                                        if (sector[dasector].lotag == 17)
                    691:                                        {
                    692:                                                sector[dasector].lotag = 16;
                    693:                               playsound(S_BIGSWINGCL,subwayx[i],subwaytracky1[i],0,ST_NOUPDATE | ST_UNIQUE);
                    694:                                                operatesector(dasector);
                    695:                                                sector[dasector].lotag = 17;
                    696:                                        }
                    697:                                }
                    698:                        }
                    699:                        if ((subwaypausetime[i] >= 120) && (subwaypausetime[i]-TICSPERFRAME < 120))
                    700:                        {
                    701:                                for(j=1;j<subwaynumsectors[i];j++)   //Close all subway doors
                    702:                                {
                    703:                                        dasector = subwaytracksector[i][j];
                    704:                                        if (sector[dasector].lotag == 17)
                    705:                                        {
                    706:                                                sector[dasector].lotag = 16;
                    707:                               playsound(S_BIGSWINGCL,subwayx[i],subwaytracky1[i],0,ST_NOUPDATE | ST_UNIQUE);
                    708:                                                operatesector(dasector);
                    709:                                                sector[dasector].lotag = 17;
                    710:                                        }
                    711:                                }
                    712:                        }
                    713: 
                    714:                        subwaypausetime[i] -= TICSPERFRAME;
                    715:                        if (subwaypausetime[i] < 0)
                    716:                        {
                    717:                                subwaypausetime[i] = 720;
                    718:                                if( subwaygoalstop[i] == (subwaystopcnt[i]-1) ) {
                    719:                          subwaystopdir[i]=-1;
                    720:                          subwaygoalstop[i]=subwaystopcnt[i]-2;
                    721:                     }
                    722:                     else if( subwaygoalstop[i] == 0 ) {
                    723:                          subwaygoalstop[i]=1;
                    724:                          subwaystopdir[i]= 1;
                    725:                     }
                    726:                     else {
                    727:                          subwaygoalstop[i]+=subwaystopdir[i];
                    728:                     }
                    729:                        }
                    730:                }
                    731:        }
                    732: 
                    733:      tektagcode();
                    734: }
                    735: 
                    736: testneighborsectors(short sect1, short sect2)
                    737: {
                    738:        short i, startwall, num1, num2;
                    739: 
                    740:        num1 = sector[sect1].wallnum;
                    741:        num2 = sector[sect2].wallnum;
                    742: 
                    743:      // traverse walls of sector with fewest walls (for speed)
                    744:        if( num1 < num2 ) {
                    745:                startwall = sector[sect1].wallptr;
                    746:                for(i=num1-1;i>=0;i--)
                    747:                        if (wall[i+startwall].nextsector == sect2)
                    748:                                return(1);
                    749:        }
                    750:        else {
                    751:                startwall = sector[sect2].wallptr;
                    752:                for(i=num2-1;i>=0;i--)
                    753:                        if (wall[i+startwall].nextsector == sect1)
                    754:                                return(1);
                    755:        }
                    756:        return(0);
                    757: }
                    758: 
                    759: tekpreptags()
                    760: {
                    761:      int       angle,hitag,i,j,k,lotag,n,s,w1,w2,w3,w4;
                    762:      long      dax,day,endwall,startwall,x1,x2,y1,y2;
                    763:      short     killwcnt;
                    764:      unsigned  long      effect;
                    765:      spritetype *spr;
                    766: 
                    767:      totalmapsndfx=0;
                    768:      secnt=0;                                    
                    769:      memset(sexref,0,sizeof(int)*MAXSECTORS);    
                    770: 
                    771:      for (j=0 ; j < MAXSECTORS ; j++) {
                    772:           memset(&sectoreffect[j],0,sizeof(struct sectoreffect));
                    773:           sectoreffect[j].warpto=-1;
                    774:           if (septrlist[j] != NULL) {
                    775:                septrlist[j]=NULL;
                    776:           }
                    777:           if (evptrlist[j] != NULL) {
                    778:                memset(evptrlist[j],0,sizeof(struct elevatortype));
                    779:                evptrlist[j]=NULL;
                    780:           }
                    781:      }
                    782:      for (j=0 ; j < MAXDOORS ; j++) {
                    783:           doorptr[j]=&doortype[j];
                    784:           memset(doorptr[j],0,sizeof(struct doortype));
                    785:      }
                    786:      numfloordoors=0;
                    787:      for (j=0 ; j < MAXSECTORS ; j++) {
                    788:           fdxref[j]=-1;
                    789:      }
                    790:      for (j=0 ; j < MAXFLOORDOORS ; j++) {
                    791:           floordoorptr[j]=&floordoor[j];
                    792:           memset(floordoorptr[j],0,sizeof(struct floordoor));
                    793:      }
                    794:      for (j=0 ; j < MAXSPRITEELEVS ; j++) {
                    795:           sprelevptr[j]=&spriteelev[j];
                    796:           memset(&spriteelev[j],0,sizeof(struct spriteelev));
                    797:      }
                    798:      for (j=0 ; j < MAXMAPSOUNDFX ; j++) {   
                    799:           mapsndfxptr[j]=&mapsndfx[j];
                    800:           memset(mapsndfxptr[j], 0, sizeof(struct mapsndfxtype));
                    801:      }
                    802:      numvehicles=0;
                    803:      for (j=0 ; j < MAXSECTORVEHICLES ; j++) {
                    804:           sectvehptr[j]=&sectorvehicle[j];
                    805:           memset(sectvehptr[j],0,sizeof(struct sectorvehicle));
                    806:           sectvehptr[j]->soundindex=-1;
                    807:      }
                    808: 
                    809:      numdoors=0;
                    810:      for (j=0 ; j < numsectors ; j++) {
                    811:           if (sectptr[j]->ceilingpal != 0) {
                    812:                startwall=sectptr[j]->wallptr;
                    813:                endwall=startwall+sectptr[j]->wallnum-1;
                    814:                for (i=startwall ; i <= endwall ; i++) {
                    815:                     wallptr[i]->pal=sectptr[j]->ceilingpal;
                    816:                }
                    817:           }
                    818:           switch (sectptr[j]->lotag) {
                    819:           case DOORUPTAG:
                    820:           case DOORDOWNTAG:
                    821:           case DOORSPLITHOR:
                    822:           case DOORSPLITVER:
                    823:           case PLATFORMELEVTAG:
                    824:           case PLATFORMDELAYTAG:
                    825:           case BOXELEVTAG:
                    826:           case BOXDELAYTAG:
                    827:           case PLATFORMDROPTAG:
                    828:                if (sectptr[j]->lotag == BOXDELAYTAG
                    829:                          || sectptr[j]->lotag == PLATFORMDELAYTAG) {
                    830:                     evptrlist[j]=&elevator[j];
                    831:                     k=nextsectorneighborz(j,sectptr[j]->floorz,1,1);
                    832:                     evptrlist[j]->hilevel=sectptr[j]->floorz;
                    833:                     evptrlist[j]->lolevel=sectptr[k]->floorz;
                    834:                }
                    835:                n=numdoors++;
                    836:                if (numdoors >= MAXDOORS) {
                    837:                     break;
                    838:                }
                    839:                switch (sectptr[j]->lotag) {
                    840:                case DOORUPTAG:
                    841:                case DOORDOWNTAG:
                    842:                case DOORSPLITHOR:
                    843:                     doorptr[n]->step=DOORSPEED;
                    844:                     break;
                    845:                case DOORSPLITVER:
                    846:                     doorptr[n]->step=4L;
                    847:                     break;
                    848:                case PLATFORMELEVTAG:
                    849:                case PLATFORMDELAYTAG:
                    850:                case BOXELEVTAG:
                    851:                case BOXDELAYTAG:
                    852:                case PLATFORMDROPTAG:
                    853:                     doorptr[n]->step=ELEVSPEED;
                    854:                     break;
                    855:                }
                    856:                doorptr[n]->centx=doorptr[n]->centy=0L;
                    857:                startwall=sectptr[j]->wallptr;
                    858:                endwall=startwall+sectptr[j]->wallnum-1;
                    859:                for (k=0,i=startwall ; i <= endwall ; i++) {
                    860:                     if (wallptr[i]->lotag == 6 && k < 8) {
                    861:                          doorptr[n]->walls[k]=i;
                    862:                          doorptr[n]->walls[k+1]=i+1;
                    863:                          doorptr[n]->walls[k+2]=i+2;
                    864:                          doorptr[n]->walls[k+3]=i-1;
                    865:                          dax=wallptr[doorptr[n]->walls[k]]->x;
                    866:                          if (wallptr[doorptr[n]->walls[k+3]]->x == dax) {
                    867:                               day=wallptr[i+2]->y;
                    868:                               doorptr[n]->points[k/2]=day;
                    869:                               day=wallptr[wallptr[i+2]->point2]->y;
                    870:                               doorptr[n]->points[(k/2)+1]=day;
                    871:                          }
                    872:                          else {
                    873:                               dax=wallptr[i+2]->x;
                    874:                               doorptr[n]->points[k/2]=dax;
                    875:                               dax=wallptr[wallptr[i+2]->point2]->x;
                    876:                               doorptr[n]->points[(k/2)+1]=dax;
                    877:                          }
                    878:                          k+=4;
                    879:                     }
                    880:                     doorptr[n]->centx+=wallptr[i]->x;
                    881:                     doorptr[n]->centy+=wallptr[i]->y;
                    882:                }
                    883:                doorptr[n]->centx/=(endwall-startwall+1);
                    884:                doorptr[n]->centy/=(endwall-startwall+1);
                    885:                doorptr[n]->centz=(sectptr[j]->ceilingz+sectptr[j]->floorz)/2;
                    886:                doorptr[n]->type=sectptr[j]->lotag;
                    887:                doorptr[n]->sector=j;
                    888:                doorxref[j]=n;  
                    889:                break;
                    890:           case DOORFLOORTAG:
                    891:                k=fdxref[j]=numfloordoors++;
                    892:                floordoorptr[k]->state=DOORCLOSED;
                    893:                floordoorptr[k]->sectnum=i;
                    894:                startwall=sectptr[j]->wallptr;
                    895:                endwall=startwall+sectptr[j]->wallnum-1;
                    896:                for (i=startwall ; i <= endwall ; i++) {
                    897:                     if (wallptr[i]->lotag == 6) {
                    898:                          if (floordoorptr[k]->wall1 == 0) {
                    899:                               w1=floordoorptr[k]->wall1=i;
                    900:                               w2=wallptr[w1]->point2;
                    901:                          }
                    902:                          else {
                    903:                               w3=floordoorptr[k]->wall2=i;
                    904:                               w4=wallptr[w3]->point2;
                    905:                          }
                    906:                     }
                    907:                }
                    908:                x1=wallptr[w1]->x;       // close the doors all the way
                    909:                y1=wallptr[w1]->y;
                    910:                x2=wallptr[w4]->x;
                    911:                y2=wallptr[w4]->y;
                    912:                dragpoint(w1,(x1+x2)/2,(y1+y2)/2);
                    913:                if (x1 != x2) {
                    914:                     if (x1 < x2) {
                    915:                          dragpoint(w4,(x1+x2)/2+1,(y1+y2)/2);
                    916:                          floordoorptr[k]->dir=3;
                    917:                     }
                    918:                     else {
                    919:                          dragpoint(w4,(x1+x2)/2-1,(y1+y2)/2);
                    920:                          floordoorptr[k]->dir=1;
                    921:                     }
                    922:                     x1=wallptr[w1]->x;
                    923:                     w1=wallptr[wallptr[wallptr[w1]->nextwall]->point2]->point2;
                    924:                     floordoorptr[k]->dist1=abs(x1-wallptr[w1]->x)-50;
                    925:                }
                    926:                else if (y1 != y2) {
                    927:                     if (y1 < y2) {
                    928:                          dragpoint(w4,(x1+x2)/2,(y1+y2)/2+1);
                    929:                          floordoorptr[k]->dir=0;
                    930:                     }
                    931:                     else {
                    932:                          dragpoint(w4,(x1+x2)/2,(y1+y2)/2-1);
                    933:                          floordoorptr[k]->dir=2;
                    934:                     }
                    935:                     y1=wallptr[w1]->y;
                    936:                     w1=wallptr[wallptr[wallptr[w1]->nextwall]->point2]->point2;
                    937:                     floordoorptr[k]->dist1=abs(y1-wallptr[w1]->y)-50;
                    938:                }
                    939:                x1=wallptr[w2]->x;
                    940:                y1=wallptr[w2]->y;
                    941:                x2=wallptr[w3]->x;
                    942:                y2=wallptr[w3]->y;
                    943:                dragpoint(w2,(x1+x2)/2,(y1+y2)/2);
                    944:                if (x1 != x2) {
                    945:                     if (x1 < x2) {
                    946:                          dragpoint(w3,(x1+x2)/2+1,(y1+y2)/2);
                    947:                     }
                    948:                     else {
                    949:                          dragpoint(w3,(x1+x2)/2-1,(y1+y2)/2);
                    950:                     }
                    951:                     x1=wallptr[w2]->x;
                    952:                     w2=wallptr[wallptr[wallptr[w2]->nextwall]->point2]->point2;
                    953:                     floordoorptr[k]->dist2=abs(x1-wallptr[w2]->x)-50;
                    954:                }
                    955:                else if (y1 != y2) {
                    956:                     if (y1 < y2) {
                    957:                          dragpoint(w3,(x1+x2)/2,(y1+y2)/2+1);
                    958:                     }
                    959:                     else {
                    960:                          dragpoint(w3,(x1+x2)/2,(y1+y2)/2-1);
                    961:                     }
                    962:                     y1=wallptr[w2]->y;
                    963:                     w2=wallptr[wallptr[wallptr[w2]->nextwall]->point2]->point2;
                    964:                     floordoorptr[k]->dist2=abs(y1-wallptr[w2]->y)-50;
                    965:                }
                    966:                break;
                    967:           default:
                    968:                break;
                    969:           }
                    970:           if (sectptr[j]->hitag >= SECTORVEHICLETAG &&
                    971:              sectptr[j]->hitag < SECTORVEHICLETAG+MAXSECTORVEHICLES) {
                    972:                k=sectptr[j]->hitag-SECTORVEHICLETAG;
                    973:                if (sectvehptr[k]->pivotx == 0 && sectvehptr[k]->pivoty == 0) {
                    974:                     numvehicles++;
                    975:                     for (i=0 ; i < MAXSPRITES ; i++) {
                    976:                          spr=sprptr[i];
                    977:                          if (spr->lotag == sectptr[j]->hitag
                    978:                             && spr->hitag == sectptr[j]->hitag) {
                    979:                               sectvehptr[k]->pivotx=spr->x;
                    980:                               sectvehptr[k]->pivoty=spr->y;
                    981:                               jsdeletesprite(i);
                    982:                               break;
                    983:                          }
                    984:                     }
                    985:                }
                    986:                x1=sectvehptr[k]->pivotx;
                    987:                y1=sectvehptr[k]->pivoty;
                    988:                n=sectvehptr[k]->numpoints;
                    989:                startwall=sectptr[j]->wallptr;
                    990:                endwall=startwall+sectptr[j]->wallnum-1;
                    991:                killwcnt=0;
                    992:                for (i=startwall ; i <= endwall ; i++) {
                    993:                     if (wallptr[i]->lotag == 6) {
                    994:                          sectvehptr[k]->killw[killwcnt++]=i;
                    995:                     }
                    996:                     sectvehptr[k]->point[n]=i;
                    997:                     sectvehptr[k]->pointx[n]=x1-wallptr[i]->x;
                    998:                     sectvehptr[k]->pointy[n]=y1-wallptr[i]->y;
                    999:                     n++;
                   1000:                     if (n >= MAXVEHICLEPOINTS) {
                   1001:                          crash("tekprepareboard: vehicle #%d has too "
                   1002:                               "many points",sectptr[j]->hitag);
                   1003:                     }
                   1004:                }
                   1005:                sectvehptr[k]->numpoints=n;
                   1006:                n=sectvehptr[k]->numsectors++;    
                   1007:                sectvehptr[k]->sector[n]=j;       
                   1008:                        sectvehptr[k]->soundindex=-1;   
                   1009:           }
                   1010:      }
                   1011: 
                   1012:      sprelevcnt=0;
                   1013:      for (i=0 ; i < MAXSPRITES ; i++) {
                   1014:           spr=sprptr[i];
                   1015:           if (spr->statnum < MAXSTATUS) {
                   1016:                switch (spr->picnum) {
                   1017:                case SNDFX_SECTOR:
                   1018:                case SNDFX_AMBIENT:
                   1019:                case SNDFX_TOGGLED:
                   1020:                     if( totalmapsndfx == MAXMAPSOUNDFX ) {
                   1021:                          jsdeletesprite(i);
                   1022:                          break;
                   1023:                     }
                   1024:                     mapsndfxptr[totalmapsndfx]->x=sprite[i].x;
                   1025:                     mapsndfxptr[totalmapsndfx]->y=sprite[i].y;
                   1026:                     mapsndfxptr[totalmapsndfx]->sector=sprite[i].sectnum;
                   1027:                     mapsndfxptr[totalmapsndfx]->snum=sprite[i].lotag;
                   1028:                     mapsndfxptr[totalmapsndfx]->id=-1;
                   1029:                     if( mapsndfxptr[totalmapsndfx]->snum > TOTALSOUNDS ) {
                   1030:                          mapsndfxptr[totalmapsndfx]->snum=(TOTALSOUNDS-1);
                   1031:                     }
                   1032:                     mapsndfxptr[totalmapsndfx]->loops=sprite[i].hitag-1;
                   1033:                     switch( spr->picnum ) {
                   1034:                     case SNDFX_AMBIENT:
                   1035:                          mapsndfxptr[totalmapsndfx]->type=MAP_SFX_AMBIENT;
                   1036:                          break;
                   1037:                     case SNDFX_SECTOR:
                   1038:                          mapsndfxptr[totalmapsndfx]->type=MAP_SFX_SECTOR;
                   1039:                          break;
                   1040:                     case SNDFX_TOGGLED:
                   1041:                          mapsndfxptr[totalmapsndfx]->type=MAP_SFX_TOGGLED;
                   1042:                          break;
                   1043:                     }
                   1044:                     totalmapsndfx++;
                   1045:                     jsdeletesprite(i);
                   1046:                     break;
                   1047:                case SECTOREFFECT:
                   1048:                     if (spr->lotag < 1000) {
                   1049:                          continue;
                   1050:                     }
                   1051:                     s=spr->sectnum;
                   1052:                     septrlist[s]=&sectoreffect[s];
                   1053:                     if (septrlist[s]->sectorflags == 0) {
                   1054:                          s=sexref[secnt++]=spr->sectnum;
                   1055:                          if (secnt == MAXSECTORS) {
                   1056:                               crash("setupboard: Sector Effector limit exceeded");
                   1057:                          }
                   1058:                          septrlist[s]->warpto=-1;
                   1059:                     }
                   1060:                     effect=flags32[spr->lotag-1000];
                   1061:                     septrlist[s]->sectorflags|=effect;
                   1062:                     if( (effect&flags32[QUICKCLOSE]) != 0 ) {
                   1063:                     }
                   1064:                     else if( (effect&flags32[SOUNDON]) != 0 ) {
                   1065:                          // match mapsndfx with same hitag
                   1066:                          septrlist[s]->hi=spr->hitag;
                   1067:                     }
                   1068:                     else if( (effect&flags32[SOUNDOFF]) != 0 ) {
                   1069:                          // match mapsndfx with same hitag
                   1070:                          septrlist[s]->hi=spr->hitag;
                   1071:                     }
                   1072:                     else if ((effect&flags32[PULSELIGHT]) != 0
                   1073:                        || (effect&flags32[FLICKERLIGHT]) != 0
                   1074:                        || (effect&flags32[FLICKERDELAY]) != 0
                   1075:                        || (effect&flags32[BLINKDELAY]) != 0
                   1076:                        || (effect&flags32[STEADYLIGHT]) != 0) {
                   1077:                          septrlist[s]->lo=sectptr[s]->floorshade;
                   1078:                          septrlist[s]->hi=sectptr[s]->ceilingshade;
                   1079:                          septrlist[s]->animate=1;
                   1080:                          if (spr->hitag != 0) {
                   1081:                               septrlist[s]->triggerable=spr->hitag;
                   1082:                          }
                   1083:                          else {
                   1084:                               septrlist[s]->triggerable=0;
                   1085:                          }
                   1086:                          startwall=sectptr[s]->wallptr;
                   1087:                          endwall=startwall+sectptr[s]->wallnum-1;
                   1088:                          for (j=startwall ; j <= endwall ; j++) {
                   1089:                               wallptr[j]->shade=sectptr[s]->floorshade;
                   1090:                          }
                   1091:                          sectptr[s]->ceilingshade=sectptr[s]->floorshade;
                   1092:                     }
                   1093:                     else if ((effect&flags32[DELAYEFFECT]) != 0) {
                   1094:                          septrlist[s]->delay=spr->hitag;
                   1095:                          septrlist[s]->delayreset=septrlist[s]->delay;
                   1096:                     }
                   1097:                     if ((effect&flags32[WPANNING]) != 0) {
                   1098:                          angle=septrlist[s]->ang=spr->ang;
                   1099:                          septrlist[s]->sin=(long)sintable[((angle+2048)&2047)];
                   1100:                          septrlist[s]->cos=(long)sintable[((angle+2560)&2047)];
                   1101:                          startwall=sectptr[s]->wallptr;
                   1102:                          endwall=startwall+sectptr[s]->wallnum-1;
                   1103:                          for (j=startwall ; j <= endwall ; j++) {
                   1104:                               if (wallptr[j]->lotag == 0) {
                   1105:                                    wallptr[j]->lotag=spr->lotag;
                   1106:                               }
                   1107:                          }
                   1108:                     }
                   1109:                     if ((effect&flags32[FPANNING]) != 0 ||
                   1110:                                         (effect&flags32[CPANNING]) != 0) {
                   1111:                          angle=septrlist[s]->ang=spr->ang;
                   1112:                          septrlist[s]->sin=(long)sintable[((angle+2048)&2047)];
                   1113:                          septrlist[s]->cos=(long)sintable[((angle+2560)&2047)];
                   1114:                     }
                   1115:                     if ((effect&flags32[WARPSECTOR]) != 0) {
                   1116:                          for( j=0; j<MAXSECTORS; j++ ) {
                   1117:                               if( sector[j].hitag == spr->hitag ) {
                   1118:                                    septrlist[s]->warpto=j;
                   1119:                                    j=MAXSECTORS;
                   1120:                               }
                   1121:                          }
                   1122:                     }
                   1123:                     if ((effect&flags32[KILLSECTOR]) != 0) {
                   1124:                          if (spr->hitag == 0) {
                   1125:                               septrlist[s]->damage=9999;
                   1126:                          }
                   1127:                          else {
                   1128:                               septrlist[s]->damage=spr->hitag;
                   1129:                          }
                   1130:                     }
                   1131:                     if ((effect&flags32[DOORSPEEDEFFECT]) != 0) {
                   1132:                          doorptr[doorxref[spr->sectnum]]->step=spr->hitag;
                   1133:                     }
                   1134:                     // jeff added 9-20
                   1135:                     if ((effect&flags32[DOORSUBTYPE]) != 0) {
                   1136:                          doorptr[doorxref[spr->sectnum]]->subtype=spr->hitag;
                   1137:                     }
                   1138:                     jsdeletesprite(i);
                   1139:                     break;
                   1140:                default:
                   1141:                     if (spr->lotag >= SECTORVEHICLETAG
                   1142:                        && spr->lotag < SECTORVEHICLETAG+MAXSECTORVEHICLES) {
                   1143:                          k=spr->lotag-SECTORVEHICLETAG;
                   1144:                          n=spr->hitag;
                   1145:                          sectvehptr[k]->trackx[n]=spr->x;
                   1146:                          sectvehptr[k]->tracky[n]=spr->y;
                   1147:                          if (spr->picnum == STOPPIC) {
                   1148:                               sectvehptr[k]->stop[n]=1;
                   1149:                               sectvehptr[k]->waitdelay=CLKIPS*8;
                   1150:                          }
                   1151:                          else {
                   1152:                               sectvehptr[k]->stop[n]=0;
                   1153:                          }
                   1154:                          if (spr->picnum == SPEEDPIC) {
                   1155:                               if (sectvehptr[k]->speedto == 0 && spr->hitag > 0) {
                   1156:                                    sectvehptr[k]->speedto=spr->hitag;
                   1157:                                    sectvehptr[k]->movespeed=sectvehptr[k]->speedto;
                   1158:                               }
                   1159:                               jsdeletesprite(i);
                   1160:                               break;
                   1161:                          }
                   1162:                          sectvehptr[k]->tracknum++;
                   1163:                          jsdeletesprite(i);
                   1164:                     }
                   1165:                     if ((spr->lotag < 2000) && (spr->lotag >= SPRITEELEVATORTAG)) {
                   1166:                          j=spr->lotag-SPRITEELEVATORTAG;
                   1167:                          if (spr->hitag >= 100) {
                   1168:                               k=(spr->hitag-100)+1;
                   1169:                               if (k >= MAXELEVFLOORS) {
                   1170:                                    crash("setupboard: Only %d levels allowed "
                   1171:                                         "for sprite elevators",MAXELEVFLOORS);
                   1172:                               }
                   1173:                               sprelevptr[j]->floorz[k]=spr->z;
                   1174:                               sprelevptr[j]->floors++;
                   1175:                          }
                   1176:                          else {
                   1177:                               k=sprelevptr[j]->parts;
                   1178:                               sprelevptr[j]->sprnum[k]=i;
                   1179:                               if (spr->hitag == 6 || spr->hitag == 7) {
                   1180:                                    if (sprelevptr[j]->floorpos == 0) {
                   1181:                                         sprelevcnt++;
                   1182:                                    }
                   1183:                                    sprelevptr[j]->door[sprelevptr[j]->doors]=i;
                   1184:                                    sprelevptr[j]->floorz[0]=spr->z;
                   1185:                                    sprelevptr[j]->floorpos=spr->z;
                   1186:                                    sprelevptr[j]->doors++;
                   1187:                               }
                   1188:                               sprelevptr[j]->startz[k]=spr->z;
                   1189:                               sprelevptr[j]->parts++;
                   1190:                          }
                   1191:                     }
                   1192:                     break;
                   1193:                }
                   1194:           }
                   1195: 
                   1196:      }
                   1197: 
                   1198:      numanimates=0;
                   1199:      for (j=0 ; j < MAXANIMPICS ; j++) {
                   1200:           animpicptr[j]=&animpic[j];
                   1201:           memset(animpicptr[j],0,sizeof(struct animpic));
                   1202:      }
                   1203:      numdelayfuncs=0;
                   1204:      for (j=0 ; j < MAXDELAYFUNCTIONS ; j++) {
                   1205:           delayfuncptr[j]=&delayfunc[j];
                   1206:           memset(delayfuncptr[j],0,sizeof(struct delayfunc));
                   1207:      }
                   1208: }
                   1209: 
                   1210: tekoperatesector(short dasector)
                   1211: {
                   1212:      short          endwall,s,startwall;
                   1213:      int            centx,centy,datag,i,j;
                   1214: 
                   1215:      s=dasector;
                   1216:      datag=sectptr[s]->lotag;
                   1217: 
                   1218:      switch (datag) {
                   1219:      case BOXELEVTAG:
                   1220:      case PLATFORMELEVTAG:
                   1221:      case BOXDELAYTAG:
                   1222:      case PLATFORMDELAYTAG:
                   1223:      case DOORUPTAG:          // a door that opens up
                   1224:      case DOORDOWNTAG:
                   1225:      case DOORSPLITHOR:
                   1226:      case DOORSPLITVER:
                   1227:      case PLATFORMDROPTAG:
                   1228:           i=doorxref[s];
                   1229:             if (i == -1) {
                   1230:                  crash("operatesector: invalid door reference for sector %d",s);
                   1231:             }
                   1232:             switch (doorptr[i]->state) {
                   1233:             case D_NOTHING:
                   1234:             case D_CLOSING:
                   1235:             case D_CLOSEDOOR:
                   1236:             case D_SHUTSOUND:
                   1237:                  doorptr[i]->state=D_OPENDOOR;
                   1238:                  break;
                   1239:             default:
                   1240:                  if (datag != PLATFORMDROPTAG) {
                   1241:                          doorptr[i]->state=D_CLOSEDOOR;
                   1242:                  }
                   1243:                  break;
                   1244:             }
                   1245:             break;
                   1246:      case DOORFLOORTAG:
                   1247:             floordoorptr[fdxref[s]]->state=DOOROPENING;
                   1248:           playsound(S_FLOOROPEN,0,0,0,ST_IMMEDIATE);
                   1249:             break;
                   1250:      }
                   1251: }
                   1252: 
                   1253: warp(long *x, long *y, long *z, short *daang, short *dasector)
                   1254: {
                   1255:        short          startwall, endwall, s;
                   1256:        long           i, j, dax, day, ox, oy;
                   1257: 
                   1258:        ox = *x; oy = *y;
                   1259: 
                   1260:        for( i=0; i<warpsectorcnt; i++ ) {
                   1261:             if( warpsectorlist[i] == *dasector ) {
                   1262:                        j = sector[*dasector].hitag;
                   1263:                        do {
                   1264:                                i++;
                   1265:                                if (i >= warpsectorcnt) i = 0;
                   1266:                        } while( sector[warpsectorlist[i]].hitag != j );
                   1267:                        *dasector = warpsectorlist[i];
                   1268:                        break;
                   1269:                }
                   1270:      }
                   1271: 
                   1272:        // find center of sector
                   1273:        startwall = sector[*dasector].wallptr;
                   1274:        endwall = startwall+sector[*dasector].wallnum-1;
                   1275:        dax = 0L, day = 0L;
                   1276:        for( s=startwall; s<=endwall; s++ ) {
                   1277:                dax += wall[s].x, day += wall[s].y;
                   1278:                if( wall[s].nextsector >= 0 ) {
                   1279:                     i = s;
                   1280:           }
                   1281:        }
                   1282:        *x = dax / (endwall-startwall+1);
                   1283:        *y = day / (endwall-startwall+1);
                   1284:        *z = sector[*dasector].floorz-(42<<8);  
                   1285: 
                   1286:        updatesector(*x,*y,dasector);
                   1287: }
                   1288: 
                   1289: tekwarp(long *x, long *y, long *z, short *dasector)
                   1290: {
                   1291:        short          startwall, endwall, s;
                   1292:        long           i, j, dax, day;
                   1293: 
                   1294:        // find center of sector
                   1295:        startwall = sector[*dasector].wallptr;
                   1296:        endwall = startwall+sector[*dasector].wallnum-1;
                   1297:        dax = 0L, day = 0L;
                   1298:        for( s=startwall; s<=endwall; s++ ) {
                   1299:                dax += wall[s].x, day += wall[s].y;
                   1300:                if( wall[s].nextsector >= 0 ) {
                   1301:                     i = s;
                   1302:           }
                   1303:        }
                   1304:        *x = dax / (endwall-startwall+1);
                   1305:        *y = day / (endwall-startwall+1);
                   1306:        *z = sector[*dasector].floorz-(42<<8);  
                   1307: 
                   1308:        updatesector(*x,*y,dasector);
                   1309: }
                   1310: 
                   1311: warpsprite(short spritenum)
                   1312: {
                   1313:        short dasectnum;
                   1314: 
                   1315:        dasectnum = sprite[spritenum].sectnum;
                   1316:        warp(&sprite[spritenum].x,&sprite[spritenum].y,&sprite[spritenum].z,
                   1317:                &sprite[spritenum].ang,&dasectnum);
                   1318:        copybuf(&sprite[spritenum].x,&osprite[spritenum].x,3);
                   1319:        changespritesect(spritenum,dasectnum);
                   1320: }
                   1321: 
                   1322: teknewsector(short p)
                   1323: {
                   1324:      long           i,n,nexti,s;
                   1325:      int            sound,sn;
                   1326:      struct    sectoreffect   *septr;
                   1327: 
                   1328:      s=cursectnum[p];
                   1329:      septr=septrlist[s];
                   1330: 
                   1331:      #define NEWMAPLOTAG 25
                   1332:      if( (sector[s].lotag == NEWMAPLOTAG) && (option[4] == 0) ) {
                   1333:           newmap(sector[s].hitag);
                   1334:           return;
                   1335:      }
                   1336: 
                   1337:      if( sectptr[cursectnum[p]]->lotag == 4 ) {
                   1338:           playsound(S_SPLASH,posx[p],posy[p],0,ST_UPDATE);
                   1339:      }
                   1340: 
                   1341:      if( septr != NULL ) {
                   1342:           if( septr->warpto >= 0 ) {
                   1343:                sn=playersprite[p];
                   1344:                  tekwarp(&sprite[sn].x,&sprite[sn].y,&sprite[sn].z,( short *)&(septr->warpto));
                   1345:                  copybuf(&sprite[sn].x,&osprite[sn].x,3);
                   1346:                  changespritesect(sn,septr->warpto);
                   1347:                        posx[p] = sprite[playersprite[p]].x;
                   1348:                        posy[p] = sprite[playersprite[p]].y;
                   1349:                        posz[p] = sprite[playersprite[p]].z;
                   1350:                        ang[p] = sprite[playersprite[p]].ang;
                   1351:                        cursectnum[p] = sprite[playersprite[p]].sectnum;
                   1352:                        sprite[playersprite[p]].z += (KENSPLAYERHEIGHT<<8);
                   1353:           }
                   1354:      }
                   1355:  
                   1356:      for( n=connecthead; n >= 0; n=connectpoint2[n] ) {
                   1357:             if( (sectptr[cursectnum[n]]->lotag == 1) || (sectptr[cursectnum[n]]->lotag == 2) ) {
                   1358:                  for( i=0; i < numsectors; i++ ) {
                   1359:                          if( sectptr[i]->hitag == sectptr[cursectnum[n]]->hitag ) {
                   1360:                                  if( (sectptr[i]->lotag != 1) && (sectptr[i]->lotag != 2) ) {
                   1361:                                       operatesector(i);
                   1362:                                 }
                   1363:                         }
                   1364:                  }
                   1365:                  i=headspritestat[0];
                   1366:                  while( i != -1 ) {
                   1367:                          nexti=nextspritestat[i];
                   1368:                          if( sprptr[i]->hitag == sectptr[cursectnum[n]]->hitag ) {
                   1369:                             operatesprite(i);
                   1370:                          }
                   1371:                     i=nexti;
                   1372:                  }
                   1373:             }
                   1374:      }
                   1375: 
                   1376:      checkmapsndfx(p);
                   1377:      sectortriggersprites(p);
                   1378: }
                   1379: 
                   1380: 
                   1381: extern    int       mission;
                   1382: 
                   1383: tektagcode(void)
                   1384: {
                   1385:      int            floorz,hi,i,j,k,lo,oldang,p,r,s,tics;
                   1386:      long           dax,dax2,day,day2,endwall,startwall;
                   1387:      unsigned long  effect;
                   1388:      sectortype     *sect;
                   1389:      struct    sectoreffect   *septr;
                   1390: 
                   1391:      for( p=connecthead; p >= 0; p=connectpoint2[p] ) {    
                   1392:             tekanimweap((syncbits[p]>>13)&15,p);
                   1393:             tekhealstun(p);
                   1394:      }   
                   1395: 
                   1396:      for( i=0; i < numdoors; i++ ) {
                   1397:             movedoors(i);
                   1398:      }
                   1399: 
                   1400:      if( option[4] == 0 ) {
                   1401:           for( i=0; i < secnt; i++ ) {
                   1402:                  s=sexref[i];
                   1403:               if (s < 0 || s >= numsectors) {
                   1404:                    crash("tag1402: Invalid sector effect index (%d,e=%d)",s,i);
                   1405:               }
                   1406:                  sect=sectptr[s];
                   1407:                  septr=septrlist[s];
                   1408:                  if( septr->triggerable != 0 ) {
                   1409:                       continue;
                   1410:                  }
                   1411:                  effect=septr->sectorflags;
                   1412:                  if( (effect&flags32[WPANNING]) != 0 ) {
                   1413:                       oldang=septr->ang;
                   1414:                       tics=TICSPERFRAME;
                   1415:                       startwall=sect->wallptr;
                   1416:                       endwall=startwall+sect->wallnum-1;
                   1417:                       dax=(tics*septr->cos)>>15;
                   1418:                       day=(tics*septr->sin)>>13;
                   1419:                       for( j=startwall; j <= endwall; j++ ) {
                   1420:                          wallptr[j]->xpanning+=(char)dax;
                   1421:                          wallptr[j]->ypanning-=(char)day;
                   1422:                       }
                   1423:                  }
                   1424:                  if( (effect&flags32[FPANNING]) != 0 ) {
                   1425:                       tics=TICSPERFRAME;
                   1426:                       dax=(tics*septr->cos);
                   1427:                       day=(tics*septr->sin);
                   1428:                       j=headspritesect[s];
                   1429:                       while( j != -1 ) {
                   1430:                          k=nextspritesect[j];
                   1431:                          if( sprptr[j]->owner < MAXSPRITES ) {
                   1432:                                  dax2=dax>>10;
                   1433:                                  day2=day>>10;
                   1434:                                  movesprite(j,dax2,day2,0,4<<8,4<<8,0,TICSPERFRAME);
                   1435:                          }
                   1436:                          j=k;
                   1437:                       }
                   1438:                       for( p=connecthead; p >= 0; p=connectpoint2[p] ) {
                   1439:                          if( cursectnum[p] == s ) {
                   1440:                                  if( posz[p] >= (sect->floorz-(42<<8)) ) {
                   1441:                                       clipmove(&posx[p],&posy[p],&posz[p],
                   1442:                                                   &cursectnum[p],dax<<4,day<<4,128L,4<<8,4<<8,0);
                   1443:                                       setsprite(playersprite[p],posx[p],posy[p],posz[p]+(42<<8));
                   1444:                                       revolvedoorstat[p]=1;
                   1445:                                  }
                   1446:                          }
                   1447:                       }
                   1448:                       dax>>=12;
                   1449:                       day>>=12;
                   1450:                       sect->floorxpanning-=(char)dax;
                   1451:                       sect->floorypanning+=(char)day;
                   1452:                  }
                   1453:                  if( (effect&flags32[CPANNING]) != 0 ) {
                   1454:                       tics=TICSPERFRAME;
                   1455:                       dax=(tics*septr->cos)>>12;
                   1456:                       day=(tics*septr->sin)>>12;
                   1457:                       sect->ceilingxpanning-=(char)dax;
                   1458:                       sect->ceilingypanning+=(char)day;
                   1459:                  }
                   1460:                  if( (septr->delay-=TICSPERFRAME) > 0 ) {
                   1461:                       continue;
                   1462:                  }
                   1463:                // negative overflow here without this - jeffy
                   1464:                if( septr->delay < 0 ) {
                   1465:                     septr->delay=0;
                   1466:                }
                   1467:                  septr->delay+=septr->delayreset;
                   1468:                  if( (effect&flags32[PULSELIGHT]) != 0 ) {
                   1469:                       sect->ceilingshade+=septr->animate;
                   1470:                       if( septr->hi > septr->lo ) {
                   1471:                          hi=septr->hi;
                   1472:                          lo=septr->lo;
                   1473:                       }
                   1474:                       else {
                   1475:                          hi=septr->lo;
                   1476:                          lo=septr->hi;
                   1477:                       }
                   1478:                       if( septr->animate < 0 ) {
                   1479:                          if( sect->ceilingshade <= lo ) {
                   1480:                                  septr->animate=abs(septr->animate);
                   1481:                          }
                   1482:                       }
                   1483:                       else {
                   1484:                          if( sect->ceilingshade >= hi ) {
                   1485:                                  septr->animate=-septr->animate;
                   1486:                          }
                   1487:                       }
                   1488:                       sect->floorshade=sect->ceilingshade;
                   1489:                       startwall=sect->wallptr;
                   1490:                       endwall=startwall+sect->wallnum-1;
                   1491:                       for( j=startwall; j <= endwall; j++ ) {
                   1492:                          wallptr[j]->shade=sect->ceilingshade;
                   1493:                       }
                   1494:                  }
                   1495:                  else if( (effect&flags32[FLICKERLIGHT]) != 0 ) {
                   1496:                    r=krand_intercept("TAG 1491");
                   1497:                       if( r < 16384 ) {
                   1498:                          sect->ceilingshade=septr->hi;
                   1499:                       }
                   1500:                       else if( r > 16384 ) {
                   1501:                          sect->ceilingshade=septr->lo;
                   1502:                       }
                   1503:                       sect->floorshade=sect->ceilingshade;
                   1504:                       startwall=sect->wallptr;
                   1505:                       endwall=startwall+sect->wallnum-1;
                   1506:                       for( j=startwall; j <= endwall; j++ ) {
                   1507:                          wallptr[j]->shade=sect->ceilingshade;
                   1508:                       }
                   1509:                  }
                   1510:                  else if( (effect&flags32[FLICKERDELAY]) != 0 ) {
                   1511:                       if( sect->ceilingshade == septr->lo ) {
                   1512:                          sect->ceilingshade=septr->hi;
                   1513:                       }
                   1514:                       else {
                   1515:                          sect->ceilingshade=septr->lo;
                   1516:                          septr->delay>>=2;
                   1517:                       }
                   1518:                       sect->floorshade=sect->ceilingshade;
                   1519:                       startwall=sect->wallptr;
                   1520:                       endwall=startwall+sect->wallnum-1;
                   1521:                       for( j=startwall; j <= endwall; j++ ) {
                   1522:                          wallptr[j]->shade=sect->ceilingshade;
                   1523:                       }
                   1524:                  }
                   1525:                  else if( (effect&flags32[BLINKDELAY]) != 0 ) {
                   1526:                       if( sect->ceilingshade == septr->lo ) {
                   1527:                          sect->ceilingshade=septr->hi;
                   1528:                       }
                   1529:                       else {
                   1530:                          sect->ceilingshade=septr->lo;
                   1531:                       }
                   1532:                       sect->floorshade=sect->ceilingshade;
                   1533:                       startwall=sect->wallptr;
                   1534:                       endwall=startwall+sect->wallnum-1;
                   1535:                       for( j=startwall; j <= endwall; j++ ) {
                   1536:                          wallptr[j]->shade=sect->ceilingshade;
                   1537:                       }
                   1538:                }
                   1539:                  if( (effect&flags32[KILLSECTOR]) != 0 ) {
                   1540:                       floorz=sectptr[s]->floorz;
                   1541:                       for( p=connecthead ; p >= 0 ; p=connectpoint2[p] ) {
                   1542:                          if( cursectnum[p] == s ) {
                   1543:                               // matrix specific check here
                   1544:                                  if( (klabs(posz[p] - floorz) < 10240) || (mission == 7) ) {
                   1545:                                       if( (k=fdxref[s]) != -1 ) {
                   1546:                                               if( floordoorptr[k]->state != DOORCLOSED ) {
                   1547:                                                       changehealth(p,-septr->damage);
                   1548:                                              changescore(p,-10);
                   1549:                                               }
                   1550:                                       }
                   1551:                                       else {
                   1552:                                         if( septr->delay == septr->delayreset ) {
                   1553:                                                    changehealth(p,-septr->damage);
                   1554:                                              changescore(p,-10);
                   1555:                                         }
                   1556:                                       }
                   1557:                                  }
                   1558:                          }
                   1559:                       }
                   1560:                  }
                   1561:           }
                   1562:      }
                   1563: 
                   1564:      if( option[4] == 0 ) {
                   1565:           for( i=0; i < sprelevcnt; i++ ) {
                   1566:                  movesprelevs(i);
                   1567:           }
                   1568:           for( i=0; i < numfloordoors; i++ ) {
                   1569:                  movefloordoor(i);
                   1570:           }
                   1571:           for( i=0; i < numvehicles; i++ ) {
                   1572:                movevehicles(i);
                   1573:           }
                   1574:      }  
                   1575: 
                   1576:      tekdoanimpic();
                   1577:      tekdodelayfuncs();
                   1578:      if( (lockclock-ambupdateclock) > 120 ) {
                   1579:           checkmapsndfx(screenpeek);
                   1580:      }
                   1581: }
                   1582: 
                   1583: long
                   1584: stepdoor(long z,long z2,struct doortype *door,int newstate)
                   1585: {
                   1586:      if (z < z2) {
                   1587:          z+=(door->step*TICSPERFRAME);
                   1588:          if (z >= z2) {
                   1589:               door->delay=DOORDELAY;
                   1590:               door->state=newstate;
                   1591:               z=z2;
                   1592:          }
                   1593:      }
                   1594:      else if (z > z2) {
                   1595:          z-=(door->step*TICSPERFRAME);
                   1596:          if (z <= z2) {
                   1597:               door->delay=DOORDELAY;
                   1598:               door->state=newstate;
                   1599:               z=z2;
                   1600:          }
                   1601:      }
                   1602:      return(z);
                   1603: }
                   1604: 
                   1605: showwall2d(int w,int onoff)
                   1606: {
                   1607:      if (onoff) {
                   1608:          show2dwall[w>>3]|=(1<<(w&7));
                   1609:      }
                   1610:      else {
                   1611:          show2dwall[w>>3]&=~(1<<(w&7));
                   1612:      }
                   1613: }
                   1614: 
                   1615: showsect2d(int s,int z)
                   1616: {
                   1617:      int  endwall,i,startwall;
                   1618: 
                   1619:      startwall=sectptr[s]->wallptr;
                   1620:      endwall=startwall+sectptr[s]->wallnum-1;
                   1621:      for (i=startwall ; i <= endwall ; i++) {
                   1622:          if (wallptr[i]->nextwall != -1) {
                   1623:               if (sectptr[wallptr[i]->nextsector]->floorz == z) {
                   1624:                    showwall2d(i,0);
                   1625:                    showwall2d(wallptr[i]->nextwall,0);
                   1626:               }
                   1627:               else {
                   1628:                    showwall2d(i,1);
                   1629:                    showwall2d(wallptr[i]->nextwall,1);
                   1630:               }
                   1631:          }
                   1632:      }
                   1633: }
                   1634: 
                   1635: showsect2dtoggle(int s,int onoff)
                   1636: {
                   1637:      int  endwall,i,startwall;
                   1638: 
                   1639:      startwall=sectptr[s]->wallptr;
                   1640:      endwall=startwall+sectptr[s]->wallnum-1;
                   1641:      for (i=startwall ; i <= endwall ; i++) {
                   1642:          if (wallptr[i]->nextwall != -1) {
                   1643:               showwall2d(i,onoff);
                   1644:               showwall2d(wallptr[i]->nextwall,onoff);
                   1645:          }
                   1646:      }
                   1647: }
                   1648: 
                   1649: int
                   1650: sectorblocked(int   s)
                   1651: {
                   1652:      int       i,rv;
                   1653: 
                   1654:      rv=0;
                   1655: 
                   1656:      for( i=connecthead ; i >= 0 ; i=connectpoint2[i] ) {
                   1657:           if( cursectnum[i] == s )
                   1658:                rv=1;
                   1659:           if( testneighborsectors(cursectnum[i], s) == 1 ) 
                   1660:                rv=1;
                   1661:      }
                   1662:      if( headspritesect[s] != -1 )
                   1663:           rv=1;
                   1664: 
                   1665:      return(rv);
                   1666: }
                   1667: 
                   1668: movedoors(int d)
                   1669: {
                   1670:      int            hitag,i,j,s,sx;
                   1671:      long           size,z;
                   1672:      struct    doortype       *door;
                   1673:      spritetype     *spr;
                   1674:      walltype       *wall;
                   1675:      char           stayopen;
                   1676: 
                   1677:      door=doorptr[d];
                   1678:      s=door->sector;
                   1679: 
                   1680:      switch (door->state) {
                   1681: 
                   1682:      case D_NOTHING:
                   1683:             break;
                   1684: 
                   1685:      case D_WAITING:
                   1686:           stayopen=0;
                   1687:           for( i=0 ; i < secnt ; i++ ) {
                   1688:                sx=sexref[i];
                   1689:                if( sx == door->sector ) {
                   1690:                     if( ((septrlist[sx]->sectorflags)&flags32[QUICKCLOSE]) != 0) {   
                   1691:                          if( mission == 7 ) {
                   1692:                               stayopen=1;
                   1693:                          }
                   1694:                          else {
                   1695:                               door->delay=0;
                   1696:                          }
                   1697:                     }
                   1698:                }
                   1699:           }
                   1700:           if( stayopen == 0 ) {
                   1701:                  door->delay-=TICSPERFRAME;
                   1702:           }
                   1703:             if( door->delay <= 0 ) {
                   1704:                  door->delay=0;
                   1705:                  if( door->type < PLATFORMELEVTAG ) {
                   1706:                          for( i=connecthead ; i >= 0 ; i=connectpoint2[i] ) {
                   1707:                                  if( cursectnum[i] == s ) {
                   1708:                                       door->delay=DOORDELAY;
                   1709:                                       break;
                   1710:                                  }
                   1711:                          }
                   1712:                  }
                   1713:                  if( door->delay == 0 ) {
                   1714:                          door->state=D_CLOSEDOOR;
                   1715:                  }
                   1716:             }
                   1717:             break;
                   1718: 
                   1719:      case D_OPENDOOR:
                   1720:             switch (door->type) {
                   1721:             case DOORUPTAG:
                   1722:                     switch( door->subtype ) {
                   1723:                        case DST_BAYDOOR:
                   1724:                             playsound(S_BAYDOOR_OPEN,door->centx,door->centy,0,ST_UPDATE);
                   1725:                                if( baydoorloop == -1 ) {
                   1726:                                     baydoorloop=playsound(S_BAYDOORLOOP,door->centx,door->centy,20,ST_UNIQUE);
                   1727:                     }                   
                   1728:                                break;
                   1729:                case DST_HYDRAULICDOOR:
                   1730:                             playsound(S_AIRDOOR_OPEN,door->centx,door->centy,0,ST_UPDATE);
                   1731:                             playsound(S_AIRDOOR,door->centx,door->centy,0,ST_UPDATE);
                   1732:                     break;
                   1733:                     
                   1734:                case DST_ELEVATORDOOR:
                   1735:                             playsound(S_ELEVATOR_DOOR,door->centx,door->centy,0,ST_UPDATE);
                   1736:                     break;
                   1737: 
                   1738:                case DST_MATRIXDOOR1:
                   1739:                             playsound(S_MATRIX1,door->centx,door->centy,0,ST_UPDATE);
                   1740:                     break;
                   1741: 
                   1742:                case DST_MATRIXDOOR2:
                   1743:                             playsound(S_MATRIX2,door->centx,door->centy,0,ST_UPDATE);
                   1744:                     break;
                   1745:                case DST_MATRIXDOOR3:
                   1746:                             playsound(S_MATRIX3,door->centx,door->centy,0,ST_UPDATE);
                   1747:                     break;
                   1748:                case DST_MATRIXDOOR4:
                   1749:                             playsound(S_MATRIX4,door->centx,door->centy,0,ST_UPDATE);
                   1750:                     break;
                   1751: 
                   1752:                default:
                   1753:                     if( mission == 7 ) {
                   1754:                             playsound(S_MATRIXDOOR2,door->centx,door->centy,0,ST_UPDATE);
                   1755:                     }
                   1756:                     else {
                   1757:                                  playsound(S_UPDOWNDR2_OP,door->centx,door->centy,0,ST_UPDATE);
                   1758:                     }
                   1759:                             break;
                   1760:                        }
                   1761:                  door->goalz[0]=sectptr[nextsectorneighborz(s,sectptr[s]->floorz,-1,-1)]->ceilingz;
                   1762:                  break;
                   1763:           case DOORDOWNTAG:
                   1764:                        playsound(S_BIGSWINGOP,door->centx,door->centy,0,ST_UPDATE);
                   1765:                
                   1766:                  door->goalz[0]=sectptr[nextsectorneighborz(s,sectptr[s]->ceilingz,1,1)]->floorz;
                   1767:                
                   1768:                break;
                   1769: 
                   1770: 
                   1771:             case PLATFORMDROPTAG:
                   1772:                  door->goalz[0]=sectptr[nextsectorneighborz(s,sectptr[s]->ceilingz,1,1)]->floorz;
                   1773:                  break;
                   1774:             case DOORSPLITHOR:
                   1775:                if( mission == 7 ) {
                   1776:                        playsound(S_MATRIXDOOR1,door->centx,door->centy,0,ST_UPDATE);
                   1777:                }
                   1778:                else {
                   1779:                        playsound(S_WH_7,door->centx,door->centy,0,ST_UPDATE);
                   1780:                }
                   1781:                  door->goalz[0]=sectptr[nextsectorneighborz(s,sectptr[s]->ceilingz,-1,-1)]->ceilingz;
                   1782:                  door->goalz[2]=sectptr[nextsectorneighborz(s,sectptr[s]->floorz,1,1)]->floorz;
                   1783:                  break;
                   1784:             case DOORSPLITVER:
                   1785:                     playsound(S_SIDEDOOR1,door->centx,door->centy,0,ST_UPDATE);
                   1786:                  door->goalz[0]=door->points[0];
                   1787:                  door->goalz[1]=door->points[1];
                   1788:                  door->goalz[2]=door->points[2];
                   1789:                  door->goalz[3]=door->points[3];
                   1790:                  break;
                   1791:           case BOXDELAYTAG:
                   1792:             case PLATFORMDELAYTAG:
                   1793:                  playsound(S_PLATFORMSTART,door->centx,door->centy,0,ST_UPDATE);
                   1794:                     if( loopinsound == -1 ) {
                   1795:                          loopinsound=playsound(S_PLATFORMLOOP,door->centx,door->centy,20,ST_UNIQUE);
                   1796:                }
                   1797:                  door->goalz[0]=evptrlist[s]->lolevel;
                   1798:                  break;
                   1799:           default:
                   1800:                break;
                   1801:             }
                   1802:             door->state=D_OPENING;
                   1803:             break;
                   1804: 
                   1805:      case D_CLOSEDOOR:
                   1806:             switch (door->type) {
                   1807:             case DOORUPTAG:
                   1808:                     switch( door->subtype ) {
                   1809:                        case DST_BAYDOOR:
                   1810:                             playsound(S_BAYDOOR_OPEN,door->centx,door->centy,0,ST_UPDATE);
                   1811:                                if( baydoorloop == -1 ) {
                   1812:                                     baydoorloop = playsound(S_BAYDOORLOOP,door->centx,door->centy,20,ST_UNIQUE);
                   1813:                     }
                   1814:                                break;
                   1815: 
                   1816:                case DST_HYDRAULICDOOR:
                   1817:                             playsound(S_AIRDOOR_OPEN,door->centx,door->centy,0,ST_UPDATE);
                   1818:                             playsound(S_AIRDOOR,door->centx,door->centy,0,ST_UPDATE);
                   1819:                     break;
                   1820:                     
                   1821:                case DST_ELEVATORDOOR:
                   1822:                             playsound(S_ELEVATOR_DOOR,door->centx,door->centy,0,ST_UPDATE);
                   1823:                     break;
                   1824: 
                   1825:                case DST_MATRIXDOOR1:
                   1826:                             playsound(S_MATRIX1,door->centx,door->centy,0,ST_UPDATE);
                   1827:                     break;
                   1828: 
                   1829:                case DST_MATRIXDOOR2:
                   1830:                             playsound(S_MATRIX2,door->centx,door->centy,0,ST_UPDATE);
                   1831:                     break;
                   1832:                case DST_MATRIXDOOR3:
                   1833:                             playsound(S_MATRIX3,door->centx,door->centy,0,ST_UPDATE);
                   1834:                     break;
                   1835:                case DST_MATRIXDOOR4:
                   1836:                             playsound(S_MATRIX4,door->centx,door->centy,0,ST_UPDATE);
                   1837:                     break;
                   1838: 
                   1839:                        default:
                   1840:                     if( mission == 7 ) {
                   1841:                        playsound(S_MATRIXDOOR2,door->centx,door->centy,0,ST_UPDATE);
                   1842:                     }
                   1843:                     else {
                   1844:                                  playsound(S_UPDOWNDR2_CL,door->centx,door->centy,0,ST_UPDATE);
                   1845:                     }
                   1846:                                break;
                   1847:                        }
                   1848:                  door->goalz[0]=sectptr[nextsectorneighborz(s,sectptr[s]->ceilingz,1,1)]->floorz;
                   1849:                  break;
                   1850:             case DOORDOWNTAG:
                   1851:                        playsound(S_BIGSWINGOP,door->centx,door->centy,0,ST_UPDATE);
                   1852:                  door->goalz[0]=sectptr[s]->ceilingz;
                   1853:                  break;
                   1854:             case DOORSPLITHOR:
                   1855:                if( mission == 7 ) {
                   1856:                        playsound(S_MATRIXDOOR1,door->centx,door->centy,0,ST_UPDATE);
                   1857:                }
                   1858:                else {
                   1859:                             playsound(S_WH_7,door->centx,door->centy,0,ST_UPDATE);
                   1860:                }
                   1861:                  door->goalz[0]=door->centz;
                   1862:                  door->goalz[2]=door->centz;
                   1863:                  break;
                   1864:             case DOORSPLITVER:
                   1865:                     playsound(S_SIDEDOOR2,door->centx,door->centy,0,ST_UPDATE);
                   1866:                  if( wallptr[door->walls[0]]->x == wallptr[door->walls[3]]->x ) {
                   1867:                          door->goalz[0]=door->centy;
                   1868:                          door->goalz[2]=door->centy;
                   1869:                  }
                   1870:                  else {
                   1871:                          door->goalz[0]=door->centx;
                   1872:                          door->goalz[2]=door->centx;
                   1873:                  }
                   1874:                  door->goalz[1]=door->points[0];
                   1875:                  door->goalz[3]=door->points[2];
                   1876:                  break;
                   1877:             case BOXELEVTAG:
                   1878:             case PLATFORMELEVTAG:
                   1879:                  door->state=D_NOTHING;
                   1880:                  break;
                   1881:             case BOXDELAYTAG:
                   1882:             case PLATFORMDELAYTAG:
                   1883:                     playsound(S_PLATFORMSTART,door->centx,door->centy,0,ST_UPDATE);
                   1884:                        if( loopinsound == -1 ) {
                   1885:                             loopinsound=playsound(S_PLATFORMLOOP,door->centx,door->centy,20,ST_UNIQUE);
                   1886:                }
                   1887:                  door->goalz[0]=evptrlist[s]->hilevel;
                   1888:                  break;
                   1889:           default:
                   1890:                break;
                   1891:             }
                   1892:             door->state=D_CLOSING;
                   1893:             if( (hitag=sectptr[s]->hitag) > 0 ) {
                   1894:                  for( i=0 ; i < MAXSPRITES ; i++ ) {
                   1895:                          spr=sprptr[i];
                   1896:                          if( spr->hitag == hitag ) {
                   1897:                             switch (spr->picnum) {
                   1898:                             case SWITCH2ON:
                   1899:                                  spr->picnum=SWITCH2OFF;
                   1900:                                  break;
                   1901:                             case SWITCH3ON:
                   1902:                                  spr->picnum=SWITCH3OFF;
                   1903:                                  break;
                   1904:                             }
                   1905:                          }
                   1906:                  }
                   1907:                  for( i=0 ; i < numwalls ; i++ ) {
                   1908:                          wall=wallptr[i];
                   1909:                          if( wall->hitag == hitag ) {
                   1910:                             switch (wall->picnum) {
                   1911:                             case SWITCH2ON:
                   1912:                                  wall->picnum=SWITCH2OFF;
                   1913:                                  break;
                   1914:                             case SWITCH3ON:
                   1915:                                  wall->picnum=SWITCH3OFF;
                   1916:                                  break;
                   1917:                             }
                   1918:                          }
                   1919:                  }
                   1920:             }
                   1921:             break;
                   1922: 
                   1923:      case D_OPENING:
                   1924:           switch (door->type) {
                   1925:             case DOORUPTAG:
                   1926:             case DOORDOWNTAG:
                   1927:             case PLATFORMDROPTAG:
                   1928:                  if( door->type == DOORUPTAG ) {
                   1929:                          z=sectptr[s]->ceilingz;
                   1930:                  }
                   1931:                  else {
                   1932:                          z=sectptr[s]->floorz;
                   1933:                  }
                   1934:                  z=stepdoor(z,door->goalz[0],door,D_OPENSOUND);
                   1935:                  if( door->type == DOORUPTAG ) {
                   1936:                          sectptr[s]->ceilingz=z;
                   1937:                  }
                   1938:                  else {
                   1939:                          sectptr[s]->floorz=z;
                   1940:                  }
                   1941:                  break;
                   1942:             case DOORSPLITHOR:
                   1943:                  z=sectptr[s]->ceilingz;
                   1944:                  z=stepdoor(z,door->goalz[0],door,D_OPENSOUND);
                   1945:                  sectptr[s]->ceilingz=z;
                   1946:                  z=sectptr[s]->floorz;
                   1947:                  z=stepdoor(z,door->goalz[2],door,D_OPENSOUND);
                   1948:                  sectptr[s]->floorz=z;
                   1949:                  break;
                   1950:             case DOORSPLITVER:
                   1951:                  if( wallptr[door->walls[0]]->x == wallptr[door->walls[3]]->x ) {
                   1952:                          for( i=0 ; i < 8 ; i++ ) {
                   1953:                                  j=door->walls[i];
                   1954:                                  z=wallptr[j]->y;
                   1955:                                  z=stepdoor(z,door->goalz[i>>1],door,D_OPENSOUND);
                   1956:                                  dragpoint(j,wallptr[j]->x,z);
                   1957:                          }
                   1958:                  }
                   1959:                  else {
                   1960:                          for( i=0 ; i < 8 ; i++ ) {
                   1961:                                  j=door->walls[i];
                   1962:                                  z=wallptr[j]->x;
                   1963:                                  z=stepdoor(z,door->goalz[i>>1],door,D_OPENSOUND);
                   1964:                                  dragpoint(j,z,wallptr[j]->y);
                   1965:                          }
                   1966:                  }
                   1967:                  break;
                   1968:             case BOXELEVTAG:
                   1969:             case PLATFORMELEVTAG:
                   1970:             case BOXDELAYTAG:
                   1971:             case PLATFORMDELAYTAG:
                   1972:                  size=sectptr[s]->ceilingz-sectptr[s]->floorz;
                   1973:                  z=sectptr[s]->floorz;
                   1974:                  z=stepdoor(z,door->goalz[0],door,D_OPENSOUND);
                   1975:                  sectptr[s]->floorz=z;
                   1976:                  if( door->type == BOXDELAYTAG || door->type == BOXELEVTAG ) {
                   1977:                          sectptr[s]->ceilingz=sectptr[s]->floorz+size;
                   1978:                  }
                   1979:                  break;
                   1980:           default:
                   1981:                break;
                   1982:             }
                   1983:             break;
                   1984: 
                   1985:      case D_CLOSING:
                   1986:             switch (door->type) {
                   1987:             case DOORUPTAG:
                   1988:             case DOORDOWNTAG:
                   1989:                  if( door->type == DOORUPTAG ) {
                   1990:                          z=sectptr[s]->ceilingz;
                   1991:                  }
                   1992:                  else {
                   1993:                          z=sectptr[s]->floorz;
                   1994:                  }  
                   1995:                  z=stepdoor(z,door->goalz[0],door,D_SHUTSOUND);
                   1996:                  if( door->type == DOORUPTAG ) {
                   1997:                          sectptr[s]->ceilingz=z;
                   1998:                  }
                   1999:                  else {
                   2000:                          sectptr[s]->floorz=z;
                   2001:                  }
                   2002:                  break;
                   2003:             case DOORSPLITHOR:
                   2004:                  z=sectptr[s]->ceilingz;
                   2005:                  z=stepdoor(z,door->goalz[0],door,D_SHUTSOUND);
                   2006:                  sectptr[s]->ceilingz=z;
                   2007:                  z=sectptr[s]->floorz;
                   2008:                  z=stepdoor(z,door->goalz[2],door,D_SHUTSOUND);
                   2009:                  sectptr[s]->floorz=z;
                   2010:                  break;
                   2011:             case DOORSPLITVER:
                   2012:               i=headspritesect[s];
                   2013:               if (i != -1) {
                   2014:                    door->state=D_OPENDOOR;
                   2015:               }
                   2016:               for (i=connecthead ; i >= 0 ; i=connectpoint2[i]) {
                   2017:                    if (inside(posx[i],posy[i],s)) {
                   2018:                        door->state=D_OPENDOOR;
                   2019:                    }
                   2020:               }
                   2021:                  if( wallptr[door->walls[0]]->x == wallptr[door->walls[3]]->x ) {
                   2022:                          for( i=0 ; i < 8 ; i++ ) {
                   2023:                                  j=door->walls[i];
                   2024:                                  z=wallptr[j]->y;
                   2025:                                  z=stepdoor(z,door->goalz[i>>1],door,D_SHUTSOUND);
                   2026:                                  dragpoint(j,wallptr[j]->x,z);
                   2027:                          }
                   2028:                  }
                   2029:                  else {
                   2030:                          for( i=0 ; i < 8 ; i++ ) {
                   2031:                                  j=door->walls[i];
                   2032:                                  z=wallptr[j]->x;
                   2033:                                  z=stepdoor(z,door->goalz[i>>1],door,D_SHUTSOUND);
                   2034:                                  dragpoint(j,z,wallptr[j]->y);
                   2035:                          }
                   2036:                  }
                   2037:                  break;
                   2038:             case BOXDELAYTAG:
                   2039:             case PLATFORMDELAYTAG:
                   2040:                  size=sectptr[s]->ceilingz-sectptr[s]->floorz;
                   2041:                  z=sectptr[s]->floorz;
                   2042:                  z=stepdoor(z,door->goalz[0],door,D_SHUTSOUND);
                   2043:                  sectptr[s]->floorz=z;
                   2044:                  if( door->type == BOXDELAYTAG ) {
                   2045:                          sectptr[s]->ceilingz=sectptr[s]->floorz+size;
                   2046:                  }
                   2047:                  break;
                   2048:           default:
                   2049:                break;
                   2050:             }
                   2051:             break;
                   2052: 
                   2053:      case D_OPENSOUND:
                   2054:             switch (door->type) {
                   2055:             case DOORUPTAG:
                   2056:                     switch( door->subtype ) {
                   2057:                        case DST_BAYDOOR:
                   2058:                             playsound(S_BAYDOOR_CLOSE,door->centx,door->centy,0,ST_UPDATE);
                   2059:                                if( baydoorloop>=0 ) {  
                   2060:                                     stopsound(baydoorloop);
                   2061:                                        baydoorloop=-1;
                   2062:                                }             
                   2063:                             break;
                   2064:                case DST_HYDRAULICDOOR:
                   2065:                             playsound(S_AIRDOOR_CLOSE,door->centx,door->centy,0,ST_UPDATE);
                   2066:                     break;
                   2067: 
                   2068: 
                   2069:                case DST_ELEVATORDOOR:
                   2070:                case DST_MATRIXDOOR1:
                   2071:                case DST_MATRIXDOOR2:
                   2072:                case DST_MATRIXDOOR3:
                   2073:                case DST_MATRIXDOOR4:
                   2074:                     break;
                   2075:                        default:
                   2076:                     if( mission != 7 ) {
                   2077:                             playsound(S_DOORKLUNK,door->centx,door->centy,0,ST_UPDATE);
                   2078:                     }
                   2079:                                break;
                   2080:                }
                   2081:                  door->state=D_WAITING;
                   2082:                  showsect2d(door->sector,door->goalz[0]);
                   2083:                  break;
                   2084: 
                   2085:           case DOORDOWNTAG:
                   2086:                playsound(S_WH_6,door->centx,door->centy,0,ST_UPDATE);
                   2087:                     showsect2dtoggle(door->sector,0);
                   2088:                  door->state=D_WAITING;
                   2089:                  break;
                   2090: 
                   2091:             case BOXELEVTAG:
                   2092:             case PLATFORMELEVTAG:
                   2093:             case PLATFORMDROPTAG:
                   2094:                  door->state=D_WAITING;
                   2095:                  showsect2d(door->sector,door->goalz[0]);
                   2096:                  break;
                   2097:             case PLATFORMDELAYTAG:
                   2098:             default:
                   2099:                  if( door->type == BOXDELAYTAG || door->type == PLATFORMDELAYTAG ) {
                   2100:                             playsound(S_PLATFORMSTOP,door->centx,door->centy,0,ST_UPDATE);
                   2101:                                if( loopinsound >= 0 ) {  
                   2102:                                     stopsound(loopinsound);
                   2103:                                        loopinsound=-1;
                   2104:                                }             
                   2105:                          showsect2d(door->sector,door->goalz[0]);
                   2106:                  }
                   2107:                  else {
                   2108:                          showsect2dtoggle(door->sector,0);
                   2109:                  }
                   2110:                  door->state=D_WAITING;
                   2111:                  break;
                   2112:             }
                   2113:             break;
                   2114: 
                   2115:      case D_SHUTSOUND:
                   2116:             switch (door->type) {
                   2117:             case DOORUPTAG:
                   2118:                     switch( door->subtype ) {
                   2119:                        case DST_BAYDOOR:
                   2120:                             playsound(S_BAYDOOR_CLOSE,door->centx,door->centy,0,ST_UPDATE);
                   2121:                                if( baydoorloop>=0 ) {  
                   2122:                                     stopsound(baydoorloop);
                   2123:                                        baydoorloop=-1;
                   2124:                                }             
                   2125:                             break;
                   2126: 
                   2127:                case DST_HYDRAULICDOOR:
                   2128:                             playsound(S_AIRDOOR_CLOSE,door->centx,door->centy,0,ST_UPDATE);
                   2129:                     break;
                   2130: 
                   2131:                case DST_ELEVATORDOOR:
                   2132:                case DST_MATRIXDOOR1:
                   2133:                case DST_MATRIXDOOR2:
                   2134:                case DST_MATRIXDOOR3:
                   2135:                case DST_MATRIXDOOR4:
                   2136:                     break;
                   2137:                        default:
                   2138:                     if( mission != 7 ) {
                   2139:                             playsound(S_DOORKLUNK,door->centx,door->centy,0,ST_UPDATE);
                   2140:                     }
                   2141:                                break;
                   2142:                        }
                   2143:                  door->state=D_NOTHING;
                   2144:                  showsect2d(door->sector,door->goalz[0]);
                   2145:                  break;
                   2146: 
                   2147:           case DOORDOWNTAG:
                   2148:                  showsect2dtoggle(door->sector,1);
                   2149:                        playsound(S_WH_6,door->centx,door->centy,0,ST_UPDATE);
                   2150:                break;
                   2151: 
                   2152:             case BOXELEVTAG:
                   2153:             case PLATFORMELEVTAG:
                   2154:             case BOXDELAYTAG:
                   2155:             case PLATFORMDELAYTAG:
                   2156:                        playsound(S_PLATFORMSTOP,door->centx,door->centy,0,ST_UPDATE);
                   2157:                        if( loopinsound>=0 ) {
                   2158:                             stopsound(loopinsound);
                   2159:                                loopinsound=-1;
                   2160:                        }
                   2161:                  showsect2d(door->sector,door->goalz[0]);
                   2162:                  break;
                   2163:             default:
                   2164:                  showsect2dtoggle(door->sector,1);
                   2165:                  break;
                   2166:             }
                   2167:             door->state=D_NOTHING;
                   2168:             break;
                   2169:      }
                   2170: 
                   2171: }
                   2172: 
                   2173: movesprelevs(int e)
                   2174: {
                   2175:      int            i,j,n,tics;
                   2176:      long           goalz;
                   2177:      struct    spriteelev     *s;
                   2178:      spritetype     *spr;
                   2179: 
                   2180:      s=sprelevptr[e];
                   2181:      tics=TICSPERFRAME<<6;
                   2182:      switch (s->state) {
                   2183:      case E_WAITING:
                   2184:          s->delay-=TICSPERFRAME;
                   2185:          if (s->delay <= 0) {
                   2186:               s->state=E_CLOSINGDOOR;
                   2187:          }
                   2188:          return;
                   2189:      case E_CLOSINGDOOR:
                   2190:          s->doorpos-=tics;
                   2191:          if (s->doorpos <= 0) {
                   2192:               s->doorpos=0;
                   2193:               s->state=E_NEXTFLOOR;
                   2194:          }
                   2195:          break;
                   2196:      case E_OPENINGDOOR:
                   2197:          s->doorpos+=tics;
                   2198:          if (s->doorpos >= E_DOOROPENPOS) {
                   2199:               s->doorpos=E_DOOROPENPOS;
                   2200:               s->state=E_WAITING;
                   2201:               s->delay=E_WAITDELAY;
                   2202:          }
                   2203:          break;
                   2204:      case E_MOVING:
                   2205:          goalz=s->floorz[s->curfloor];
                   2206:          if (s->curdir == E_GOINGUP) {
                   2207:               s->floorpos-=tics;
                   2208:               if (s->floorpos <= goalz) {
                   2209:                    s->floorpos+=labs(s->floorpos-goalz);
                   2210:                    s->state=E_OPENINGDOOR;
                   2211:               }
                   2212:          }
                   2213:          else {
                   2214:               s->floorpos+=tics;
                   2215:               if (s->floorpos >= goalz) {
                   2216:                    s->floorpos-=labs(s->floorpos-goalz);
                   2217:                    s->state=E_OPENINGDOOR;
                   2218:               }
                   2219:          }
                   2220:          break;
                   2221:      case E_NEXTFLOOR:
                   2222:          if (s->curdir == E_GOINGUP) {
                   2223:               s->curfloor++;
                   2224:               if (s->curfloor > s->floors) {
                   2225:                    s->curfloor-=2;
                   2226:                    s->curdir=E_GOINGDOWN;
                   2227:                                //playsound(S_COPSEE1,sprptr[s->sprnum[0]]->x,sprptr[s->sprnum[0]]->y,0,ST_UNIQUE);
                   2228:               }
                   2229:          }
                   2230:          else if (s->curdir == E_GOINGDOWN) {
                   2231:               s->curfloor--;
                   2232:               if (s->curfloor < 0) {
                   2233:                    s->curfloor+=2;
                   2234:                    s->curdir=E_GOINGUP;
                   2235:                                //playsound(S_COPSEE2,sprptr[s->sprnum[0]]->x,sprptr[s->sprnum[0]]->y,0,ST_UNIQUE);
                   2236:               }
                   2237:          }
                   2238:          s->state=E_MOVING;
                   2239:          break;
                   2240:      }
                   2241:      for (i=0 ; i < s->parts ; i++) {
                   2242:          j=s->sprnum[i];
                   2243:          spr=sprptr[j];
                   2244:          spr->z=s->startz[i]+s->floorpos-s->floorz[0];
                   2245:          for (n=0 ; n < s->doors ; n++) {
                   2246:               if (j == s->door[n]) {
                   2247:                    spr->z-=s->doorpos;
                   2248:               }
                   2249:          }
                   2250:      }
                   2251: }
                   2252: 
                   2253: movefloordoor(int d)
                   2254: {
                   2255:      int  i,j,s,tics;
                   2256:      struct floordoor *dptr;
                   2257: 
                   2258:      tics=TICSPERFRAME<<2;
                   2259:      dptr=floordoorptr[d];
                   2260:      switch (dptr->state) {
                   2261:      case DOOROPENING:
                   2262:          if (dptr->dist1 > 0) {
                   2263:               s=tics;
                   2264:               dptr->dist1-=s;
                   2265:               if (dptr->dist1 < 0) {
                   2266:                    s+=dptr->dist1;
                   2267:                    dptr->dist1=0;
                   2268:               }
                   2269:               switch (dptr->dir) {
                   2270:               case 0:
                   2271:                    j=dptr->wall1;
                   2272:                    dragpoint(j,wallptr[j]->x,wallptr[j]->y-s);
                   2273:                    j=wallptr[j]->point2;
                   2274:                    dragpoint(j,wallptr[j]->x,wallptr[j]->y-s);
                   2275:                    break;
                   2276:               case 1:
                   2277:                    j=dptr->wall1;
                   2278:                    dragpoint(j,wallptr[j]->x+s,wallptr[j]->y);
                   2279:                    j=wallptr[j]->point2;
                   2280:                    dragpoint(j,wallptr[j]->x+s,wallptr[j]->y);
                   2281:                    break;
                   2282:               case 2:
                   2283:                    j=dptr->wall1;
                   2284:                    dragpoint(j,wallptr[j]->x,wallptr[j]->y+s);
                   2285:                    j=wallptr[j]->point2;
                   2286:                    dragpoint(j,wallptr[j]->x,wallptr[j]->y+s);
                   2287:                    break;
                   2288:               case 3:
                   2289:                    j=dptr->wall1;
                   2290:                    dragpoint(j,wallptr[j]->x-s,wallptr[j]->y);
                   2291:                    j=wallptr[j]->point2;
                   2292:                    dragpoint(j,wallptr[j]->x-s,wallptr[j]->y);
                   2293:                    break;
                   2294:               }
                   2295:          }
                   2296:          if (dptr->dist2 > 0) {
                   2297:               s=tics;
                   2298:               dptr->dist2-=s;
                   2299:               if (dptr->dist2 < 0) {
                   2300:                    s+=dptr->dist2;
                   2301:                    dptr->dist2=0;
                   2302:               }
                   2303:               switch (dptr->dir) {
                   2304:               case 0:
                   2305:                    j=dptr->wall2;
                   2306:                    dragpoint(j,wallptr[j]->x,wallptr[j]->y+s);
                   2307:                    j=wallptr[j]->point2;
                   2308:                    dragpoint(j,wallptr[j]->x,wallptr[j]->y+s);
                   2309:                    break;
                   2310:               case 1:
                   2311:                    j=dptr->wall2;
                   2312:                    dragpoint(j,wallptr[j]->x-s,wallptr[j]->y);
                   2313:                    j=wallptr[j]->point2;
                   2314:                    dragpoint(j,wallptr[j]->x-s,wallptr[j]->y);
                   2315:                    break;
                   2316:               case 2:
                   2317:                    j=dptr->wall2;
                   2318:                    dragpoint(j,wallptr[j]->x,wallptr[j]->y-s);
                   2319:                    j=wallptr[j]->point2;
                   2320:                    dragpoint(j,wallptr[j]->x,wallptr[j]->y-s);
                   2321:                    break;
                   2322:               case 3:
                   2323:                    j=dptr->wall2;
                   2324:                    dragpoint(j,wallptr[j]->x+s,wallptr[j]->y);
                   2325:                    j=wallptr[j]->point2;
                   2326:                    dragpoint(j,wallptr[j]->x+s,wallptr[j]->y);
                   2327:                    break;
                   2328:               }
                   2329:          }
                   2330:          if (dptr->dist1 <= 0 && dptr->dist2 <= 0) {
                   2331:               dptr->state=DOOROPENED;
                   2332:          }
                   2333:          break;
                   2334:      case DOORCLOSING:
                   2335:      case DOOROPENED:
                   2336:      case DOORCLOSED:
                   2337:          break;
                   2338:      }
                   2339: }
                   2340: 
                   2341: clearvehiclesoundindexes()
                   2342: {
                   2343:      int       i;
                   2344: 
                   2345:      for( i=0; i < MAXSECTORVEHICLES; i++ ) {
                   2346:           sectvehptr[i]->soundindex=-1;
                   2347:      }
                   2348: }
                   2349: 
                   2350: movevehicles(int v)
                   2351: {
                   2352:      short     a,angv,ato,angto,curang,i,n,p,rotang,s,sto,stoptrack,track;
                   2353:      long      distx,disty,px,py,x,y;
                   2354:      long      xvect,xvect2,yvect,yvect2;
                   2355:      long      lox,loy,hix,hiy;
                   2356:      short     onveh[MAXPLAYERS];
                   2357:      struct    sectorvehicle  *vptr;
                   2358: 
                   2359:      vptr=sectvehptr[v];
                   2360: 
                   2361:      if( vptr->soundindex == -1 ) {
                   2362:                                         
                   2363:           for( i=0; i<32; i++) {        //find mapno using names array
                   2364:                if( !(strcmp(strupr(boardfilename),strupr(mapnames[i])) ) )
                   2365:                     break;
                   2366:           }
                   2367:           switch( v ) {
                   2368:             case 0:      
                   2369:                switch( i ) {
                   2370:                     case 4:   //level1.map
                   2371:                               vptr->soundindex=playsound(S_TRAMBUSLOOP,vptr->pivotx,vptr->pivoty,-1,ST_VEHUPDATE);             
                   2372:                          break;
                   2373:                     case 8:   //city1.map
                   2374:                          vptr->soundindex=playsound(S_TRUCKLOOP,vptr->pivotx,vptr->pivoty,-1,ST_VEHUPDATE);            
                   2375:                          break;
                   2376:                     case 11:  //beach1.map
                   2377:                          vptr->soundindex=playsound(S_FORKLIFTLOOP,vptr->pivotx,vptr->pivoty,-1,ST_VEHUPDATE);         
                   2378:                          break;
                   2379:                     case 17:  //mid3.map
                   2380:                          vptr->soundindex=playsound(S_TRAMBUSLOOP,vptr->pivotx,vptr->pivoty,-1,ST_VEHUPDATE);          
                   2381:                          break;
                   2382:                     case 19:  //sewer2.map
                   2383:                          vptr->soundindex=playsound(S_FORKLIFTLOOP,vptr->pivotx,vptr->pivoty,-1,ST_VEHUPDATE);         
                   2384:                          break;
                   2385:                     case 20:   //inds1.map
                   2386:                          vptr->soundindex=playsound(S_FORKLIFTLOOP,vptr->pivotx,vptr->pivoty,-1,ST_VEHUPDATE);         
                   2387:                          break;
                   2388:                     case 25:  //ware1.map
                   2389:                          vptr->soundindex=playsound(S_FORKLIFTLOOP,vptr->pivotx,vptr->pivoty,-1,ST_VEHUPDATE);         
                   2390:                          break;
                   2391:                     case 26:   //ware2.map
                   2392:                          vptr->soundindex=playsound(S_TRUCKLOOP,vptr->pivotx,vptr->pivoty,-1,ST_VEHUPDATE);            
                   2393:                          break;
                   2394:                     default:
                   2395:                          break;
                   2396:                }
                   2397:                break;
                   2398:           case 1:
                   2399:                switch( i ) {
                   2400:                     case 4:   //level1.map
                   2401:                          vptr->soundindex=playsound(S_TRAMBUSLOOP,vptr->pivotx,vptr->pivoty,-1,ST_VEHUPDATE);          
                   2402:                          break;
                   2403:                     case 11:   //beach1.map
                   2404:                          vptr->soundindex=playsound(S_BOATLOOP,vptr->pivotx,vptr->pivoty,-1,ST_VEHUPDATE);             
                   2405:                          break;
                   2406:                     case 26:   //ware2.map
                   2407:                          vptr->soundindex=playsound(S_CARTLOOP,vptr->pivotx,vptr->pivoty,-1,ST_VEHUPDATE);             
                   2408:                          break;
                   2409:                     default:
                   2410:                          break;
                   2411:                }
                   2412:                break;
                   2413:           default:
                   2414:                break;
                   2415:           }
                   2416:      }
                   2417:      
                   2418:      if( vptr->waittics > 0 ) {
                   2419:             vptr->waittics-=TICSPERFRAME;
                   2420:           if( vptr->soundindex != -1 ) {
                   2421:                  updatevehiclesnds(vptr->soundindex, vptr->pivotx, vptr->pivoty);
                   2422:           }
                   2423:             return;
                   2424:      }
                   2425: 
                   2426:      px=vptr->pivotx;
                   2427:      py=vptr->pivoty;
                   2428: 
                   2429:      track=vptr->track;
                   2430:      distx=vptr->distx;
                   2431:      disty=vptr->disty;
                   2432:      stoptrack=vptr->stoptrack;
                   2433:      if( vptr->stop[track] && (x=distx+disty) > 0L && x < 8192L ) {
                   2434:             vptr->accelto=2;
                   2435:             vptr->speedto=32;
                   2436:      }
                   2437:      else if( vptr->accelto != 8 ) {
                   2438:             vptr->accelto=8;
                   2439:             vptr->speedto=vptr->movespeed;
                   2440:      }
                   2441:      if( distx == 0L && disty == 0L ) {
                   2442:             if( vptr->stop[stoptrack] ) {
                   2443:                  for( i=0 ; i < vptr->numsectors ; i++ ) {
                   2444:                          s=vptr->sector[i];
                   2445:                          if( sectptr[s]->lotag != 0 ) {
                   2446:                                  operatesector(s);
                   2447:                          }
                   2448:                  }
                   2449:                  vptr->waittics=vptr->waitdelay;
                   2450:                  vptr->acceleration=0;
                   2451:                  vptr->speed=0;
                   2452: 
                   2453:             }
                   2454:             distx=vptr->trackx[track]-px;
                   2455:             disty=vptr->tracky[track]-py;
                   2456:             vptr->angleto=getangle(distx,disty);
                   2457:             vptr->accelto=8;
                   2458:             vptr->distx=labs(distx);
                   2459:             vptr->disty=labs(disty);
                   2460:             distx=vptr->distx;
                   2461:             disty=vptr->disty;
                   2462:      }
                   2463:      a=vptr->acceleration;
                   2464:      ato=vptr->accelto;
                   2465:      if( a < ato ) {
                   2466:             a+=TICSPERFRAME;
                   2467:             if( a > ato ) {
                   2468:                  a=ato;
                   2469:             }
                   2470:             vptr->acceleration=a;
                   2471:      }
                   2472:      else if( a > ato ) {
                   2473:             a-=TICSPERFRAME;
                   2474:             if( a < ato ) {
                   2475:                  a=ato;
                   2476:             }
                   2477:             vptr->acceleration=a;
                   2478:      }
                   2479:      s=vptr->speed;
                   2480:      sto=vptr->speedto;
                   2481:      if( s > sto ) {
                   2482:             s-=a;
                   2483:             if( s <= sto ) {
                   2484:                  s=sto;
                   2485:             }
                   2486:             vptr->speed=s;
                   2487:      }
                   2488:      else if( s < sto ) {
                   2489:             s+=a;
                   2490:             if( s > sto ) {
                   2491:                  s=sto;
                   2492:             }
                   2493:             vptr->speed=s;
                   2494:      }
                   2495:      rotang=curang=vptr->angle;                                 
                   2496:      if( curang != vptr->angleto ) {
                   2497:             vptr->angle=vptr->angleto;
                   2498:             curang=vptr->angle;
                   2499:      }
                   2500:      xvect=(s*(long)TICSPERFRAME*(long)sintable[((curang+2560)&2047)])>>3;
                   2501:      xvect2=xvect>>13;
                   2502:      yvect=(s*(long)TICSPERFRAME*(long)sintable[((curang+2048)&2047)])>>3;
                   2503:      yvect2=yvect>>13;
                   2504:      distx-=labs(xvect2);
                   2505:      if( distx < 0L ) {
                   2506:             if( xvect2 < 0L ) {
                   2507:                  xvect2-=distx;
                   2508:             }
                   2509:             else {
                   2510:                  xvect2+=distx;
                   2511:             }
                   2512:             distx=0L;
                   2513:             vptr->angleto=getangle(vptr->trackx[track]-px,vptr->tracky[track]-py);
                   2514:      }
                   2515:      disty-=labs(yvect2);
                   2516:      if( disty < 0L ) {
                   2517:             if( yvect2 < 0L ) {
                   2518:                  yvect2-=disty;
                   2519:             }
                   2520:             else {
                   2521:                  yvect2+=disty;
                   2522:             }
                   2523:             disty=0L;
                   2524:             vptr->angleto=getangle(vptr->trackx[track]-px,vptr->tracky[track]-py);
                   2525:      }
                   2526:      if( distx == 0L && disty == 0L ) {
                   2527:             vptr->stoptrack=track;
                   2528:             track=(track+1)%vptr->tracknum;
                   2529:             vptr->track=track;
                   2530:           switch( v ) {
                   2531:           //jsa vehicles
                   2532:             case 0:
                   2533:                if( !(strcmp(strupr(boardfilename),"CITY1.MAP")) || !(strcmp(strupr(boardfilename),"WARE2.MAP")))
                   2534:                          playsound(S_TRUCKSTOP,vptr->pivotx,vptr->pivoty,0,ST_AMBUPDATE);              
                   2535:                break;
                   2536:           default:
                   2537:                break;
                   2538:           }
                   2539:      }
                   2540:      vptr->distx=distx;
                   2541:      vptr->disty=disty;
                   2542:      px+=xvect2;
                   2543:      py+=yvect2;
                   2544:      n=vptr->numpoints;
                   2545:      for( i=0 ; i < n ; i++ ) {
                   2546:             p=vptr->point[i];
                   2547:             x=vptr->pointx[i];
                   2548:             y=vptr->pointy[i];
                   2549:             rotatepoint(px,py,px-x,py-y,curang,&x,&y);
                   2550:             dragpoint(p,x,y);
                   2551:      }
                   2552:      vptr->pivotx=px;
                   2553:      vptr->pivoty=py;
                   2554:      rotang=((curang-rotang)+2048)&2047;
                   2555:      n=vptr->numsectors;
                   2556:      lox=loy=0x7FFFFFFF;
                   2557:      hix=hiy=-(0x7FFFFFFF);
                   2558:      for( i=0 ; i < 4 ; i++ ) {
                   2559:             a=vptr->killw[i];
                   2560:             if( wallptr[a]->x < lox ) {
                   2561:                  lox=wallptr[a]->x;
                   2562:             }
                   2563:             else if( wallptr[a]->x > hix ) {
                   2564:                  hix=wallptr[a]->x;
                   2565:             }
                   2566:             if( wallptr[a]->y < loy ) {
                   2567:                  loy=wallptr[a]->y;
                   2568:             }
                   2569:             else if (wallptr[a]->y > hiy) {
                   2570:                  hiy=wallptr[a]->y;
                   2571:             }
                   2572:      }
                   2573:      memset(onveh,0,sizeof(short)*MAXPLAYERS);
                   2574:      for( i=0 ; i < n ; i++ ) {
                   2575:             p=headspritesect[vptr->sector[i]];
                   2576:             while (p >= 0) {
                   2577:                  s=nextspritesect[p];
                   2578:                  x=sprptr[p]->x;
                   2579:                  y=sprptr[p]->y;
                   2580:                  x+=xvect2;
                   2581:                  y+=yvect2;
                   2582:                  rotatepoint(px,py,x,y,rotang,&sprptr[p]->x,&sprptr[p]->y);
                   2583:                  sprptr[p]->ang+=rotang;
                   2584:                  p=s;
                   2585:             }
                   2586:             for( p=connecthead ; p >= 0 ; p=connectpoint2[p] ) {
                   2587:                  x=posx[p];
                   2588:                  y=posy[p];
                   2589:                  if( cursectnum[p] == vptr->sector[i] ) {
                   2590:                          x+=xvect2;
                   2591:                          y+=yvect2;
                   2592:                          rotatepoint(px,py,x,y,rotang,&posx[p],&posy[p]);
                   2593:                          ang[p]+=rotang;
                   2594:                          onveh[p]=1;
                   2595:                  }
                   2596:             }
                   2597:      }
                   2598:      for( p=connecthead ; p >= 0 ; p=connectpoint2[p] ) {
                   2599:             if( onveh[p] ) { 
                   2600:                  continue;
                   2601:             }
                   2602:             x=posx[p];
                   2603:             y=posy[p];
                   2604:             if( x > lox && x < hix && y > loy && y < hiy ) {
                   2605:                  if( (health[p] > 0) &&  (posz[p] > VEHICLEHEIGHT) ) {
                   2606:                          changehealth(p,-9999);
                   2607:                     changescore(p,-100);
                   2608:                          if( goreflag ) {
                   2609:                                  tekexplodebody(playersprite[p]);
                   2610:                          }
                   2611:                  }
                   2612:             }
                   2613:      }
                   2614:      if( vptr->soundindex != -1 ) {
                   2615:             updatevehiclesnds(vptr->soundindex, vptr->pivotx, vptr->pivoty);
                   2616:      }
                   2617: }
                   2618: 
                   2619: void                          // kick off function after specified tics elapse
                   2620: teksetdelayfunc(void (*delayfunc)(short),int tics,short parm)
                   2621: {
                   2622:      int  i,n;
                   2623:      struct delayfunc *dfptr;
                   2624: 
                   2625:      if (delayfunc == NULL) {
                   2626:          return;
                   2627:      }
                   2628:      n=numdelayfuncs;
                   2629:      for (i=0 ; i < n ; i++) {
                   2630:          if (delayfuncptr[i]->func == delayfunc) {
                   2631:               if (tics == 0) {
                   2632:                    memmove(delayfuncptr[i],delayfuncptr[numdelayfuncs-1],
                   2633:                         sizeof(struct delayfunc));
                   2634:                    memset(delayfuncptr[numdelayfuncs-1],0,
                   2635:                         sizeof(struct delayfunc));
                   2636:                    numdelayfuncs--;
                   2637:                    return;
                   2638:               }
                   2639:               else {
                   2640:                    delayfuncptr[i]->tics=tics;
                   2641:                    delayfuncptr[i]->parm=parm;
                   2642:                    return;
                   2643:               }
                   2644:          }
                   2645:      }
                   2646:      delayfuncptr[numdelayfuncs]->func=delayfunc;
                   2647:      delayfuncptr[numdelayfuncs]->tics=tics;
                   2648:      delayfuncptr[numdelayfuncs]->parm=parm;
                   2649:      numdelayfuncs++;
                   2650: }
                   2651: 
                   2652: void
                   2653: tekdodelayfuncs(void)
                   2654: {
                   2655:      int  i,n,p;
                   2656: 
                   2657:      n=numdelayfuncs;
                   2658:      for (i=0 ; i < n ; i++) {
                   2659:          if (delayfuncptr[i]->func == NULL) {
                   2660:               continue;
                   2661:          }
                   2662:          delayfuncptr[i]->tics-=TICSPERFRAME;
                   2663:          if (delayfuncptr[i]->tics <= 0) {
                   2664:               p=delayfuncptr[i]->parm;
                   2665:               (*delayfuncptr[i]->func)(p);
                   2666:               memmove(delayfuncptr[i],delayfuncptr[numdelayfuncs-1],
                   2667:                    sizeof(struct delayfunc));
                   2668:               memset(delayfuncptr[numdelayfuncs-1],0,
                   2669:                    sizeof(struct delayfunc));
                   2670:               numdelayfuncs--;
                   2671:          }
                   2672:      }
                   2673: }
                   2674: 
                   2675: void
                   2676: setanimpic(short *pic,short tics,short frames)
                   2677: {
                   2678:      int  i;
                   2679: 
                   2680:      for (i=0 ; i < numanimates ; i++) {
                   2681:          if (animpicptr[i]->pic == pic) {
                   2682:               return;
                   2683:          }
                   2684:      }
                   2685:      if (numanimates+1 < MAXANIMPICS) {
                   2686:          animpicptr[numanimates]->pic=pic;
                   2687:          animpicptr[numanimates]->tics=tics;
                   2688:          animpicptr[numanimates]->frames=frames;
                   2689:          animpicptr[numanimates]->nextclock=lockclock+tics;
                   2690:          numanimates++;
                   2691:      }
                   2692: }
                   2693: 
                   2694: void
                   2695: tekdoanimpic(void)
                   2696: {
                   2697:      short pic;
                   2698:      int  i,n;
                   2699: 
                   2700:      n=numanimates;
                   2701:      for (i=0 ; i < n ; i++) {
                   2702:          if (lockclock < animpicptr[i]->nextclock) {
                   2703:               continue;
                   2704:          }
                   2705:          if (animpicptr[i]->frames > 0) {
                   2706:               if (--animpicptr[i]->frames > 0) {
                   2707:                    pic=*animpicptr[i]->pic;
                   2708:                    pic++;
                   2709:                    *animpicptr[i]->pic=pic;
                   2710:                    animpicptr[i]->nextclock=lockclock+animpicptr[i]->tics;
                   2711:               }
                   2712:          }
                   2713:          else if (animpicptr[i]->frames < 0) {
                   2714:               if (++animpicptr[i]->frames < 0) {
                   2715:                    pic=*animpicptr[i]->pic;
                   2716:                    pic--;
                   2717:                    *animpicptr[i]->pic=pic;
                   2718:                    animpicptr[i]->nextclock=lockclock+animpicptr[i]->tics;
                   2719:               }
                   2720:          }
                   2721:          else {
                   2722:               numanimates--;
                   2723:               if (numanimates > 0) {
                   2724:                    memmove(animpicptr[i],animpicptr[numanimates],
                   2725:                         sizeof(struct animpic));
                   2726:                    memset(animpicptr[numanimates],0,sizeof(struct animpic));
                   2727:               }
                   2728:          }
                   2729:      }
                   2730: }
                   2731: 
                   2732: void 
                   2733: checkmapsndfx(short p)
                   2734: {
                   2735: 
                   2736:        int       i,j,s;
                   2737:        long            dist,px,py;
                   2738:      char      insubway;
                   2739:      unsigned  long      effect;
                   2740:      struct    sectoreffect   *septr;
                   2741: 
                   2742:      s=cursectnum[p];
                   2743:      septr=septrlist[s];
                   2744: 
                   2745:      for( i=0; i<totalmapsndfx; i++ ) {
                   2746:                switch(mapsndfxptr[i]->type) {
                   2747:                case MAP_SFX_AMBIENT:
                   2748:                     dist=labs(posx[p]-mapsndfxptr[i]->x)+labs(posy[p]-mapsndfxptr[i]->y);
                   2749:                        if( (dist > AMBUPDATEDIST) && (mapsndfxptr[i]->id!=-1) ) {
                   2750:                                stopsound(mapsndfxptr[i]->id);
                   2751:                                mapsndfxptr[i]->id=-1;
                   2752:                        }
                   2753:                        else if( (dist < AMBUPDATEDIST) && (mapsndfxptr[i]->id==-1) )  {
                   2754:                        mapsndfxptr[i]->id=playsound(mapsndfxptr[i]->snum, mapsndfxptr[i]->x,mapsndfxptr[i]->y, mapsndfxptr[i]->loops, ST_AMBUPDATE);
                   2755:                }
                   2756:                     break;
                   2757:           case MAP_SFX_SECTOR:
                   2758:                if((cursectnum[p] != ocursectnum[p]) && (cursectnum[p] == mapsndfxptr[i]->sector) ) {
                   2759:                    mapsndfxptr[i]->id=playsound(mapsndfxptr[i]->snum, mapsndfxptr[i]->x,mapsndfxptr[i]->y, mapsndfxptr[i]->loops, ST_UNIQUE);
                   2760:                }                    
                   2761:                break;
                   2762:           default:
                   2763:                break;
                   2764:                }
                   2765:        }
                   2766: 
                   2767:        if( !strncmp("SUBWAY",strupr(boardfilename),6) ) {
                   2768:                if( ambsubloop == -1 ) {
                   2769:                     ambsubloop=playsound(S_SUBSTATIONLOOP, 0, 0, -1, ST_IMMEDIATE);
                   2770:           }
                   2771:      }
                   2772:      else {
                   2773:           if( ambsubloop != -1 ) {
                   2774:                     stopsound(ambsubloop);
                   2775:                ambsubloop=-1;
                   2776:           }
                   2777:      }
                   2778: 
                   2779:      if( septr != NULL ) {
                   2780:           effect=septr->sectorflags;
                   2781:           if( (effect&flags32[SOUNDON]) != 0 ) {
                   2782:                for( i=0; i<totalmapsndfx; i++ ) {
                   2783:                     if( mapsndfxptr[i]->type == MAP_SFX_TOGGLED ) {
                   2784:                          if( sectptr[mapsndfxptr[i]->sector]->hitag == septr->hi ) {
                   2785:                               if( mapsndfxptr[i]->id == -1 ) {
                   2786:                                  mapsndfxptr[i]->id=playsound(mapsndfxptr[i]->snum, mapsndfxptr[i]->x,mapsndfxptr[i]->y, mapsndfxptr[i]->loops,ST_UNIQUE | ST_IMMEDIATE);;
                   2787:                               }
                   2788:                          }
                   2789:                     }
                   2790:                }
                   2791:           }
                   2792:           if( (effect&flags32[SOUNDOFF]) != 0 ) {
                   2793:                for( i=0; i<totalmapsndfx; i++ ) {
                   2794:                     if( mapsndfxptr[i]->type == MAP_SFX_TOGGLED ) {
                   2795:                          if( sectptr[mapsndfxptr[i]->sector]->hitag == septr->hi ) {
                   2796:                               if( mapsndfxptr[i]->id != -1 ) {
                   2797:                                    stopsound(mapsndfxptr[i]->id);
                   2798:                                  mapsndfxptr[i]->id=-1;
                   2799:                               }
                   2800:                          }
                   2801:                     }
                   2802:                }
                   2803:           }
                   2804:      }
                   2805: 
                   2806: //     ambupdateclock=totalclock;
                   2807:      ambupdateclock=lockclock;
                   2808: }
                   2809: 
                   2810: void
                   2811: tektagsave(int fil)
                   2812: {
                   2813:      int  i,rv;
                   2814: 
                   2815:      rv=write(fil,&numanimates,sizeof(int));
                   2816:      for (i=0 ; i < numanimates ; i++) {
                   2817:             write(fil,&animpic[i],sizeof(struct animpic));
                   2818:      }
                   2819:      rv=write(fil,&numdelayfuncs,sizeof(short));
                   2820:      for (i=0 ; i < numdelayfuncs ; i++) {
                   2821:             write(fil,&delayfunc[i],sizeof(struct delayfunc));
                   2822:      }
                   2823:      rv=write(fil,onelev,MAXPLAYERS);
                   2824:      rv=write(fil,&secnt,sizeof(int));
                   2825:      for (i=0 ; i < secnt ; i++) {
                   2826:             write(fil,&sectoreffect[i],sizeof(struct sectoreffect));
                   2827:      }
                   2828:      rv=write(fil,sexref,MAXSECTORS*sizeof(int));
                   2829:      rv=write(fil,&numdoors,sizeof(int));
                   2830:      for (i=0 ; i < numdoors ; i++) {
                   2831:             write(fil,&doortype[i],sizeof(struct doortype));
                   2832:      }
                   2833:      write(fil,&numfloordoors,sizeof(int));
                   2834:      for (i=0 ; i < numfloordoors ; i++) {
                   2835:             write(fil,&floordoor[i],sizeof(struct floordoor));
                   2836:      }
                   2837:      write(fil,fdxref,MAXSECTORS*sizeof(int));
                   2838:      write(fil,&numvehicles,sizeof(int));
                   2839:      for (i=0 ; i < numvehicles ; i++) {
                   2840:             write(fil,&sectorvehicle[i],sizeof(struct sectorvehicle));
                   2841:      }
                   2842:      write(fil,elevator,MAXSECTORS*sizeof(struct elevatortype));
                   2843:      write(fil,&sprelevcnt,sizeof(int));
                   2844:      for (i=0 ; i < sprelevcnt ; i++) {
                   2845:             write(fil,&spriteelev[i],sizeof(struct spriteelev));
                   2846:      }
                   2847:      write(fil,&totalmapsndfx,sizeof(int));
                   2848:      for (i=0 ; i < totalmapsndfx ; i++) {
                   2849:             write(fil,&mapsndfx[i],sizeof(struct mapsndfxtype));
                   2850:      }
                   2851: }
                   2852: 
                   2853: void
                   2854: tektagload(int fil)
                   2855: {
                   2856:      int  i,rv;
                   2857: 
                   2858:      rv=read(fil,&numanimates,sizeof(int));
                   2859:      for (i=0 ; i < numanimates ; i++) {
                   2860:             read(fil,&animpic[i],sizeof(struct animpic));
                   2861:      }
                   2862:      rv=read(fil,&numdelayfuncs,sizeof(short));
                   2863:      for (i=0 ; i < numdelayfuncs ; i++) {
                   2864:             read(fil,&delayfunc[i],sizeof(struct delayfunc));
                   2865:      }
                   2866:      rv=read(fil,onelev,MAXPLAYERS);
                   2867:      rv=read(fil,&secnt,sizeof(int));
                   2868:      for (i=0 ; i < secnt ; i++) {
                   2869:             read(fil,&sectoreffect[i],sizeof(struct sectoreffect));
                   2870:      }
                   2871:      rv=read(fil,sexref,MAXSECTORS*sizeof(int));
                   2872:      rv=read(fil,&numdoors,sizeof(int));
                   2873:      for (i=0 ; i < numdoors ; i++) {
                   2874:             read(fil,&doortype[i],sizeof(struct doortype));
                   2875:      }
                   2876:      read(fil,&numfloordoors,sizeof(int));
                   2877:      for (i=0 ; i < numfloordoors ; i++) {
                   2878:             read(fil,&floordoor[i],sizeof(struct floordoor));
                   2879:      }
                   2880:      read(fil,fdxref,MAXSECTORS*sizeof(int));
                   2881:      read(fil,&numvehicles,sizeof(int));
                   2882:      for (i=0 ; i < numvehicles ; i++) {
                   2883:             read(fil,&sectorvehicle[i],sizeof(struct sectorvehicle));
                   2884:      }
                   2885: 
                   2886:      // must reinvoke vehicle sounds since all sounds were stopped
                   2887:      // else updatevehiclesounds will update whatever is using
                   2888:      // dsoundptr[vptr->soundindex]
                   2889:      clearvehiclesoundindexes();
                   2890: 
                   2891:      read(fil,elevator,MAXSECTORS*sizeof(struct elevatortype));
                   2892:      read(fil,&sprelevcnt,sizeof(int));
                   2893:      for (i=0 ; i < sprelevcnt ; i++) {
                   2894:             read(fil,&spriteelev[i],sizeof(struct spriteelev));
                   2895:      }
                   2896:      read(fil,&totalmapsndfx,sizeof(int));
                   2897:      for (i=0 ; i < totalmapsndfx ; i++) {
                   2898:             read(fil,&mapsndfx[i],sizeof(struct mapsndfxtype));
                   2899:           // did we leave with a TOGGLED sound playong ?
                   2900:           if( (mapsndfx[i].type == MAP_SFX_TOGGLED) && (mapsndfx[i].id != -1) ) {
                   2901:                mapsndfxptr[i]->id=playsound(mapsndfxptr[i]->snum, mapsndfxptr[i]->x,mapsndfxptr[i]->y, mapsndfxptr[i]->loops, ST_UNIQUE);
                   2902:           }
                   2903:      }
                   2904: }
                   2905: 
                   2906: void
                   2907: tekheadbob(void)
                   2908: {
                   2909:      if( headbobon && (activemenu == 0) ) {
                   2910:             headbob+=bobstep;
                   2911:             if( headbob < -BOBBMAX || headbob > BOBBMAX ) {
                   2912:                  bobstep=-bobstep;
                   2913:             }
                   2914:      }
                   2915: }
                   2916: 
                   2917: tekswitchtrigger(short snum)
                   2918: {
                   2919:      int       i,j;
                   2920:        long      nexti;
                   2921:        long      dax,day;
                   2922: 
                   2923:      j=sprite[neartagsprite].picnum;
                   2924: 
                   2925:        switch( j ) {
                   2926:      case SWITCH2OFF:
                   2927:          if( invredcards[snum] == 0 ) {
                   2928:               showmessage("PASSAGE REQUIRES RED KEYCARD");
                   2929:               return;
                   2930:          }
                   2931:          break;
                   2932:      case SWITCH4OFF:
                   2933:          if( invbluecards[snum] == 0 ) {
                   2934:               showmessage("PASSAGE REQUIRES BLUE KEYCARD");
                   2935:               return;
                   2936:          }
                   2937:          break;
                   2938:      }
                   2939: 
                   2940:      switch( j ) {
                   2941:      case SWITCH2ON:
                   2942:      case SWITCH2OFF:
                   2943:      case SWITCH3ON:
                   2944:      case SWITCH3OFF:
                   2945:      case SWITCH4ON:
                   2946:      case SWITCH4OFF:
                   2947:           dax = sprite[neartagsprite].x;
                   2948:             day = sprite[neartagsprite].y;
                   2949:             playsound(S_KEYCARDBLIP, dax,day,0, ST_UPDATE);
                   2950:           break;
                   2951:      default:
                   2952:           break;
                   2953:      }
                   2954: 
                   2955:        if (j == SWITCH2ON) sprite[neartagsprite].picnum = SWITCH2OFF;
                   2956:        if (j == SWITCH2OFF) sprite[neartagsprite].picnum = SWITCH2ON;
                   2957:        if (j == SWITCH3ON) sprite[neartagsprite].picnum = SWITCH3OFF;
                   2958:        if (j == SWITCH3OFF) sprite[neartagsprite].picnum = SWITCH3ON;
                   2959:        if (j == SWITCH4ON) sprite[neartagsprite].picnum = SWITCH4OFF;
                   2960:        if (j == SWITCH4OFF) sprite[neartagsprite].picnum = SWITCH4ON;
                   2961: 
                   2962:        if (j == 3708) sprite[neartagsprite].picnum = 3709;
                   2963:        if (j == 3709) sprite[neartagsprite].picnum = 3708;
                   2964: 
                   2965:        for(i=0;i<numsectors;i++)
                   2966:                if (sector[i].hitag == sprite[neartagsprite].hitag)
                   2967:                        if (sector[i].lotag != 1)
                   2968:                                operatesector(i);
                   2969: 
                   2970:        i = headspritestat[0];
                   2971:        while (i != -1)
                   2972:        {
                   2973:                nexti = nextspritestat[i];
                   2974:                if (sprite[i].hitag == sprite[neartagsprite].hitag)
                   2975:                        operatesprite(i);
                   2976:                i = nexti;
                   2977:        }
                   2978: 
                   2979: 
                   2980: }
                   2981: 
                   2982: extern
                   2983: int  dbgflag,dbgcolumn;
                   2984: extern
                   2985: FILE *dbgfp;
                   2986: 
                   2987: int
                   2988: krand_intercept(char *stg)
                   2989: {
                   2990:      if (dbgflag) {
                   2991:           if (dbgcolumn > 80) {
                   2992:                fprintf(dbgfp,"\n");
                   2993:                dbgcolumn=0;
                   2994:           }
                   2995:           else {
                   2996:                fprintf(dbgfp,"%s(%-9ld) ",stg,randomseed);
                   2997:                dbgcolumn+=20;
                   2998:           }
                   2999:      }
                   3000:      return(krand());
                   3001: }
                   3002: 

unix.superglobalmegacorp.com