Annotation of src/tektag.c, revision 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