Annotation of src/tekspr.c, revision 1.1.1.1

1.1       root        1: /***************************************************************************
                      2:  *   TEKSPR.C  - checktouch, analyze, etc. for sprites                     *
                      3:  *                                                                         *
                      4:  *                                                                         *
                      5:  ***************************************************************************/
                      6: 
                      7: #include "string.h"
                      8: #include "build.h"
                      9: #include "names.h"
                     10: 
                     11: #include "tekwar.h"
                     12: 
                     13: #pragma aux mulscale =        \
                     14:        "imul ebx",              \
                     15:        "shrd eax, edx, cl",     \
                     16:        parm [eax][ebx][ecx]     \
                     17:        modify [edx]             \
                     18: 
                     19: // from tekstat
                     20: #define   FLOATING       322  
                     21: #define   PINBALL        403     
                     22: 
                     23: #define   AI_NULL        0x00
                     24: #define   AI_FRIEND      0x01
                     25: #define   AI_FOE         0x02
                     26: #define   AI_JUSTSHOTAT  0x04
                     27: #define   AI_CRITICAL    0x08
                     28: #define   AI_WASDRAWN    0x10
                     29: 
                     30: extern    int       difficulty;
                     31: extern    char      rearviewdraw;
                     32: extern    long      flags32[],weapons[];                                                  
                     33: extern    void      placerandompic(long picnum);
                     34: 
                     35: #pragma aux copybuf =         \
                     36:        "rep movsd",             \
                     37:        parm [esi][edi][ecx]     \
                     38: 
                     39: #define fillsprite(newspriteindex2,x2,y2,z2,cstat2,shade2,pal2,            \
                     40:                clipdist2,xrepeat2,yrepeat2,xoffset2,yoffset2,picnum2,ang2,      \
                     41:                xvel2,yvel2,zvel2,owner2,sectnum2,statnum2,lotag2,hitag2,extra2) \
                     42: {                                                                          \
                     43:        spritetype *spr2;                                                     \
                     44:        spr2 = &sprite[newspriteindex2];                                      \
                     45:        spr2->x = x2; spr2->y = y2; spr2->z = z2;                             \
                     46:        spr2->cstat = cstat2; spr2->shade = shade2;                           \
                     47:        spr2->pal = pal2; spr2->clipdist = clipdist2;                         \
                     48:        spr2->xrepeat = xrepeat2; spr2->yrepeat = yrepeat2;                   \
                     49:        spr2->xoffset = xoffset2; spr2->yoffset = yoffset2;                   \
                     50:        spr2->picnum = picnum2; spr2->ang = ang2;                             \
                     51:        spr2->xvel = xvel2; spr2->yvel = yvel2; spr2->zvel = zvel2;           \
                     52:        spr2->owner = owner2;                                                 \
                     53:        spr2->lotag = lotag2; spr2->hitag = hitag2; spr2->extra = -1;         \ 
                     54:        copybuf(&spr2->x,&osprite[newspriteindex2].x,3);                      \
                     55: }
                     56: 
                     57: 
                     58: 
                     59: short
                     60: kenmovesprite(short spritenum, long dx, long dy, long dz, long ceildist, long flordist, char cliptype)
                     61: {
                     62:        long daz, zoffs, templong;
                     63:        short retval, dasectnum, tempshort;
                     64:        spritetype *spr;
                     65: 
                     66:     #ifdef PLRSPRDEBUG
                     67:      if( isaplayersprite(spritenum) ) {
                     68:           crash("messing w plrsprite at 17");
                     69:      }
                     70:     #endif
                     71: 
                     72:        spr = &sprite[spritenum];
                     73: 
                     74:        if ((spr->cstat&128) == 0)
                     75:                zoffs = -((tilesizy[spr->picnum]*spr->yrepeat)<<1);
                     76:        else
                     77:                zoffs = 0;
                     78: 
                     79:        dasectnum = spr->sectnum;  //Can't modify sprite sectors directly becuase of linked lists
                     80:        daz = spr->z+zoffs;  //Must do this if not using the new centered centering (of course)
                     81:        retval = clipmove(&spr->x,&spr->y,&daz,&dasectnum,dx,dy,
                     82:                                                        ((long)spr->clipdist)<<2,ceildist,flordist,cliptype);
                     83: 
                     84:        if ((dasectnum != spr->sectnum) && (dasectnum >= 0))
                     85:                changespritesect(spritenum,dasectnum);
                     86: 
                     87:                //Set the blocking bit to 0 temporarly so getzrange doesn't pick up
                     88:                //its own sprite
                     89:        tempshort = spr->cstat; spr->cstat &= ~1;
                     90:        getzrange(spr->x,spr->y,spr->z-1,spr->sectnum,
                     91:                                 &globhiz,&globhihit,&globloz,&globlohit,
                     92:                                 ((long)spr->clipdist)<<2,cliptype);
                     93:        spr->cstat = tempshort;
                     94: 
                     95:        daz = spr->z+zoffs + dz;
                     96:        if ((daz <= globhiz) || (daz > globloz))
                     97:        {
                     98:                if (retval != 0) return(retval);
                     99:                return(16384+dasectnum);
                    100:        }
                    101:        spr->z = daz-zoffs;
                    102:        return(retval);
                    103: }
                    104: 
                    105: short
                    106: floatmovesprite(short spritenum, long dx, long dy, long dz, long ceildist, long flordist, char cliptype)
                    107: {
                    108:        long daz, zoffs, templong;
                    109:        short retval, dasectnum, tempshort;
                    110:        spritetype *spr;
                    111: 
                    112:     #ifdef PLRSPRDEBUG
                    113:      if( isaplayersprite(spritenum) ) {
                    114:           crash("messing w plrsprite at 18");
                    115:      }
                    116:     #endif
                    117: 
                    118:        spr = &sprite[spritenum];
                    119: 
                    120:        if ((spr->cstat&128) == 0)
                    121:                zoffs = -((tilesizy[spr->picnum]*spr->yrepeat)<<1);
                    122:        else
                    123:                zoffs = 0;
                    124: 
                    125:        dasectnum = spr->sectnum;  //Can't modify sprite sectors directly becuase of linked lists
                    126:        daz = spr->z+zoffs;  //Must do this if not using the new centered centering (of course)
                    127:        retval = clipmove(&spr->x,&spr->y,&daz,&dasectnum,dx,dy,
                    128:                                                        ((long)spr->clipdist)<<2,ceildist,flordist,cliptype);
                    129: 
                    130:        if ((dasectnum != spr->sectnum) && (dasectnum >= 0))
                    131:                changespritesect(spritenum,dasectnum);
                    132: 
                    133:        return(retval);
                    134: }
                    135: 
                    136: short
                    137: movesprite(short spritenum, long dx, long dy, long dz, long ceildist, long flordist, char cliptype)
                    138: {
                    139:        long           daz,zoffs;
                    140:      long           jumpz,deltaz;
                    141:      long           px,py,pz;
                    142:        short          retval,dasectnum,tempshort;
                    143:      short          failedsectnum;
                    144:        spritetype     *spr;
                    145: 
                    146:     #ifdef PLRSPRDEBUG
                    147:      if( isaplayersprite(spritenum) ) {
                    148:           crash("messing w plrsprite at 19");
                    149:      }
                    150:     #endif
                    151: 
                    152:        spr = &sprite[spritenum];
                    153: 
                    154:        if ((spr->cstat&128) == 0)
                    155:                zoffs = -((tilesizy[spr->picnum]*spr->yrepeat)<<1);
                    156:        else
                    157:                zoffs = 0;
                    158: 
                    159:        dasectnum = spr->sectnum;
                    160:      px=spr->x;
                    161:      py=spr->y;
                    162:      pz=spr->z;
                    163:        daz = spr->z+zoffs; 
                    164:        retval = clipmove(&spr->x,&spr->y,&daz,&dasectnum,dx,dy,
                    165:                                                        ((long)spr->clipdist)<<2,ceildist,flordist,cliptype);
                    166:        if( (dasectnum != spr->sectnum) && (dasectnum >= 0) ) {
                    167:                changespritesect(spritenum,dasectnum);
                    168:      }
                    169: 
                    170:      if( (sectptr[dasectnum]->lotag == 4) && (spr->extra != -1) ) {
                    171:           switch( spr->statnum ) {
                    172:           case FLOATING:
                    173:                break;
                    174:           default:
                    175:                spr->z=sectptr[spr->sectnum]->floorz-zoffs;
                    176:                break;
                    177:           }
                    178:           return(retval);
                    179:      }
                    180: 
                    181:        tempshort = spr->cstat; spr->cstat &= ~1;
                    182:        getzrange(spr->x,spr->y,spr->z-1,spr->sectnum,
                    183:                                 &globhiz,&globhihit,&globloz,&globlohit,
                    184:                                 ((long)spr->clipdist)<<2,cliptype);
                    185:        spr->cstat = tempshort;
                    186:        daz = spr->z+zoffs + dz;
                    187:        if( (daz <= globhiz) || (daz > globloz) ) {
                    188:                if( retval != 0 ) {
                    189:                return(retval);
                    190:           }
                    191:           else {
                    192:                     return(16384+dasectnum);
                    193:           }
                    194:        }
                    195:        if( (globloz != pz) && (spr->extra >= 0) && (spr->extra < MAXSPRITES) ) {
                    196:           spr->z=globloz;
                    197:           deltaz=labs(pz-globloz);
                    198:           jumpz=tilesizy[spr->picnum]+(spr->yrepeat-64);
                    199:           jumpz<<=8;
                    200:           if( deltaz > jumpz ) {
                    201:                failedsectnum=spr->sectnum;
                    202:                setsprite(spritenum,px,py,pz);
                    203:                retval=failedsectnum+16384;
                    204:           }
                    205:      }
                    206:      else {
                    207:             spr->z = daz-zoffs;
                    208:      }
                    209: 
                    210:        return(retval);
                    211: }
                    212: 
                    213: short
                    214: flymovesprite(short spritenum, long dx, long dy, long dz, long ceildist, long flordist, char cliptype)
                    215: {
                    216:        long           daz, zoffs, templong;
                    217:        short          retval, dasectnum, tempshort;
                    218:        spritetype *spr;
                    219: 
                    220:     #ifdef PLRSPRDEBUG
                    221:      if( isaplayersprite(spritenum) ) {
                    222:           crash("messing w plrsprite at 20");
                    223:      }
                    224:     #endif
                    225: 
                    226:        spr = &sprite[spritenum];
                    227: 
                    228:        dasectnum = spr->sectnum; 
                    229:        retval = clipmove(&spr->x,&spr->y,&spr->z,&dasectnum,dx,dy,
                    230:                                                        ((long)spr->clipdist)<<2,ceildist,flordist,cliptype);
                    231: 
                    232:        if ((dasectnum != spr->sectnum) && (dasectnum >= 0))
                    233:                changespritesect(spritenum,dasectnum);
                    234: 
                    235:      if( spr->statnum != PINBALL ) {
                    236:             tempshort = spr->cstat; spr->cstat &= ~1;
                    237:             getzrange(spr->x,spr->y,spr->z-1,spr->sectnum,
                    238:                                 &globhiz,&globhihit,&globloz,&globlohit,
                    239:                                 ((long)spr->clipdist)<<2,cliptype);
                    240:             spr->cstat = tempshort;
                    241:           daz=(globloz+globhiz);
                    242:           spr->z=(daz>>1);
                    243:      }
                    244:  
                    245:        return(retval);
                    246: }
                    247: 
                    248: analyzesprites(long dax, long day)
                    249: {
                    250:        long           i, j, k;
                    251:      int            ext;
                    252:        point3d        *ospr;
                    253:        spritetype     *tspr;
                    254: 
                    255:        for( i=0,tspr=&tsprite[0]; i<spritesortcnt; i++,tspr++ ) {
                    256: 
                    257:           ext=tspr->extra;
                    258:           if( validext(ext) ) {
                    259:                if( rearviewdraw == 0 ) {
                    260:                     sprXTptr[ext]->aimask|=AI_WASDRAWN;
                    261:                }
                    262:           }
                    263: 
                    264:             k = getangle(tspr->x-dax,tspr->y-day);
                    265:                k = (((tspr->ang+3072+128-k)&2047)>>8)&7;
                    266: 
                    267:                switch( tspr->picnum ) {
                    268:                case DOOMGUY:
                    269:           case RUBWALKPIC:
                    270:           case FRGWALKPIC:
                    271:           case SAMWALKPIC:
                    272:           case COP1WALKPIC:
                    273:           case ANTWALKPIC:
                    274:           case SARAHWALKPIC:
                    275:           case MAWALKPIC:
                    276:           case ERWALKPIC:
                    277:           case DIWALKPIC:
                    278:           case RATPIC:
                    279:           case SUNGWALKPIC:
                    280:           case COWWALKPIC:
                    281:           case COPBWALKPIC:
                    282:           case NIKAWALKPIC:
                    283:           case REBRWALKPIC:
                    284:           case TRENWALKPIC:
                    285:           case WINGWALKPIC:
                    286:           case HALTWALKPIC:
                    287:           case REDHWALKPIC:
                    288:           case ORANWALKPIC:
                    289:           case BLKSWALKPIC:
                    290:           case SFROWALKPIC:
                    291:           case SSALWALKPIC:
                    292:           case SGOLWALKPIC:
                    293:           case SWATWALKPIC:
                    294:                        if( k <= 4 ) {
                    295:                             tspr->picnum += (k<<2);
                    296:                             tspr->cstat &= ~4;   //clear x-flipping bit
                    297:                        }
                    298:                        else {
                    299:                                tspr->picnum += ((8-k)<<2);
                    300:                                tspr->cstat |= 4;    //set x-flipping bit
                    301:                        }
                    302:                        break;
                    303:           case AUTOGUN:
                    304:                     if (k <= 4) {
                    305:                                tspr->picnum += k;    
                    306:                                tspr->cstat &= ~4; 
                    307:                        }
                    308:                        else {
                    309:                                tspr->picnum += (8-k); 
                    310:                                tspr->cstat |= 4;     
                    311:                        }
                    312:                        break;
                    313:           case JAKESTANDPIC:
                    314:           case RUBSTANDPIC:
                    315:           case FRGSTANDPIC:
                    316:           case SAMSTANDPIC:
                    317:           case COP1STNDPIC:
                    318:           case ANTSTANDPIC:
                    319:           case MASTANDPIC:
                    320:           case DISTANDPIC:
                    321:           case ERSTANDPIC:
                    322:           case SUNGSTANDPIC:
                    323:           case COWSTANDPIC:
                    324:           case COPBSTANDPIC:
                    325:           case NIKASTANDPIC:
                    326:           case REBRSTANDPIC:
                    327:           case TRENSTANDPIC:
                    328:           case WINGSTANDPIC:
                    329:           case HALTSTANDPIC:
                    330:           case REDHSTANDPIC:
                    331:           case ORANSTANDPIC:
                    332:           case BLKSSTANDPIC:
                    333:           case SFROSTANDPIC:
                    334:           case SSALSTANDPIC:
                    335:           case SGOLSTANDPIC:
                    336:           case SWATSTANDPIC:
                    337:           case PROBE1:
                    338:           case RS232:
                    339:                if (k <= 4) {           
                    340:                     tspr->picnum += k;
                    341:                     tspr->cstat &= ~4; 
                    342:                }
                    343:                else {
                    344:                     tspr->picnum += ((8-k));
                    345:                     tspr->cstat |= 4;
                    346:                }
                    347:                        break;
                    348:           case RUBATAKPIC:
                    349:           case FRGATTACKPIC:
                    350:           case SAMATTACKPIC:
                    351:           case COPATTACKPIC:
                    352:           case ANTATTACKPIC:
                    353:           case MAATTACKPIC:
                    354:           case DIATTACKPIC:
                    355:           case SUNGATTACKPIC:
                    356:           case COWATTACKPIC:
                    357:           case COPBATTACKPIC:
                    358:           case NIKAATTACKPIC:
                    359:           case REBRATTACKPIC:
                    360:           case WINGATTACKPIC:
                    361:           case HALTATTACKPIC:
                    362:           case REDHATTACKPIC:
                    363:           case ORANATTACKPIC:
                    364:           case BLKSATTACKPIC:
                    365:           case SFROATTACKPIC:
                    366:           case SSALATTACKPIC:
                    367:           case SGOLATTACKPIC:
                    368:           case SWATATTACKPIC:
                    369:                if( k <= 4 ) {           
                    370:                     tspr->picnum += (k<<1);
                    371:                                tspr->cstat &= ~4;   //clear x-flipping bit
                    372:                }
                    373:                else {
                    374:                     tspr->picnum += ((8-k)<<1);
                    375:                     tspr->cstat |= 4;
                    376:                }
                    377:                        break;
                    378:           case JAKEPAINPIC:
                    379:           case RUBPAINPIC:
                    380:           case FRGPAINPIC:
                    381:           case SAMPAINPIC:
                    382:           case COP1PAINPIC:
                    383:           case ANTPAINPIC:
                    384:           case MAPAINPIC:
                    385:           case ERPAINPIC:
                    386:           case SUNGPAINPIC:
                    387:           case COWPAINPIC:
                    388:           case NIKAPAINPIC:
                    389:           case REBRPAINPIC:
                    390:           case TRENPAINPIC:
                    391:           case HALTPAINPIC:
                    392:           case ORANPAINPIC:
                    393:           case BLKSPAINPIC:
                    394:           case SFROPAINPIC:
                    395:           case SGOLPAINPIC:
                    396:           case SWATPAINPIC:
                    397:           case JAKEDEATHPIC:
                    398:           case JAKEDEATHPIC+1:
                    399:           case JAKEDEATHPIC+2:
                    400:           case JAKEDEATHPIC+3:
                    401:           case JAKEDEATHPIC+4:
                    402:           case JAKEDEATHPIC+5:
                    403:           case JAKEDEATHPIC+6:
                    404:           case JAKEDEATHPIC+7:
                    405:           case JAKEDEATHPIC+8:
                    406:                if( k <= 4 ) { 
                    407:                     tspr->picnum += (k);
                    408:                                tspr->cstat &= ~4;   //clear x-flipping bit
                    409:                }
                    410:                else {
                    411:                     tspr->picnum += ((8-k));
                    412:                     tspr->cstat |= 4;
                    413:                }
                    414:                        break;
                    415:           // mirrorman
                    416:           case 1079:  
                    417:           case 1074:
                    418:                if( k <= 4 ) { 
                    419:                     tspr->picnum += (k);
                    420:                     tspr->cstat |= 4;
                    421:                }
                    422:                else {
                    423:                     tspr->picnum += ((8-k));
                    424:                                tspr->cstat &= ~4;   //clear x-flipping bit
                    425:                }
                    426:                        break;
                    427:           case JAKEATTACKPIC:
                    428:           case JAKEATTACKPIC+1:
                    429:                if (k <= 4) {
                    430:                     tspr->picnum+=(k*3);
                    431:                     tspr->cstat&=~4;
                    432:                }
                    433:                else {
                    434:                     tspr->picnum+=((8-k)*3);
                    435:                     tspr->cstat|=4;
                    436:                }
                    437:                break;
                    438:           default:
                    439:                break;
                    440:                }
                    441: 
                    442:                k=tspr->statnum;
                    443:                if( (k >= 1) && (k <= 8) && (k != 2) ) {  //Interpolate moving sprite
                    444:                        ospr = &osprite[tspr->owner];
                    445:                        k = tspr->x-ospr->x; tspr->x = ospr->x;
                    446:                        if (k != 0) tspr->x += mulscale(k,smoothratio,16);
                    447:                        k = tspr->y-ospr->y; tspr->y = ospr->y;
                    448:                        if (k != 0) tspr->y += mulscale(k,smoothratio,16);
                    449:                        k = tspr->z-ospr->z; tspr->z = ospr->z;
                    450:                        if (k != 0) tspr->z += mulscale(k,smoothratio,16);
                    451:                }
                    452: 
                    453:        }
                    454: }
                    455: 
                    456: checktouchsprite(short snum, short sectnum)
                    457: {
                    458:        long      i, nexti;
                    459:      int       healthmax;
                    460:      char      dosound=0;
                    461:      char      str[30];
                    462: 
                    463:        if( (sectnum < 0) || (sectnum >= numsectors) ) {
                    464:           return;
                    465:      }
                    466: 
                    467:      memset(str, 0, 30);
                    468: 
                    469:        i = headspritesect[sectnum];
                    470:        while (i != -1)
                    471:        {
                    472:                nexti = nextspritesect[i];
                    473:                if ((labs(posx[snum]-sprite[i].x)+labs(posy[snum]-sprite[i].y) < 512) && (labs((posz[snum]>>8)-((sprite[i].z>>8)-(tilesizy[sprite[i].picnum]>>1))) <= 40))
                    474:                {
                    475:                // must jive with tekinitplayer settings
                    476:                switch( difficulty ) {
                    477:                case 3:
                    478:                     healthmax=(MAXHEALTH>>1);
                    479:                     break;
                    480:                default:
                    481:                     healthmax=MAXHEALTH;
                    482:                     break;
                    483:                }
                    484:                        switch( sprite[i].picnum ) {
                    485:                case MEDICKIT2PIC:
                    486:                     if (health[snum] < healthmax) {
                    487:                          changehealth(snum,100);
                    488:                          jsdeletesprite(i);
                    489:                          strcpy(str,"MEDIC KIT");
                    490:                          dosound++;
                    491:                     }
                    492:                     break;
                    493:                case MEDICKITPIC:
                    494:                     if (health[snum] < healthmax) {
                    495:                          strcpy(str,"MEDIC KIT");
                    496:                          changehealth(snum,250);
                    497:                          jsdeletesprite(i);
                    498:                          dosound++;
                    499:                     }
                    500:                     break;
                    501:                case 3637:
                    502:                     if (health[snum] < healthmax) {
                    503:                          strcpy(str,"ENERGY PELLET");
                    504:                          changehealth(snum,50);
                    505:                          jsdeletesprite(i);
                    506:                          dosound++;
                    507:                     }
                    508:                     break;
                    509:                case DONUTSPIC:
                    510:                     if (health[snum] < healthmax) {
                    511:                          strcpy(str,"MMMMMMM DONUTS");
                    512:                          changehealth(snum,50);
                    513:                          jsdeletesprite(i);
                    514:                          dosound++;
                    515:                     }
                    516:                     break;
                    517:                case ACCUTRAKPIC:
                    518:                     invaccutrak[snum]=1;
                    519:                     strcpy(str,"ACCU TRAK");
                    520:                     jsdeletesprite(i);
                    521:                     dosound++;
                    522:                     break;
                    523:                // gun pick ups
                    524:                case 3092:
                    525:                     if( ((weapons[snum])&flags32[GUN2FLAG]) == 0 ) {
                    526:                          weapons[snum]|=flags32[GUN2FLAG];
                    527:                          ammo2[snum]+=25;
                    528:                          if (ammo2[snum] > MAXAMMO) {
                    529:                               ammo2[snum]=MAXAMMO;
                    530:                          }
                    531:                          strcpy(str,"PISTOL");
                    532:                          jsdeletesprite(i);
                    533:                          dosound++;
                    534:                     }
                    535:                     break;
                    536:                case 3094:
                    537:                     if( ((weapons[snum])&flags32[GUN3FLAG]) == 0 ) {
                    538:                          weapons[snum]|=flags32[GUN3FLAG];
                    539:                          ammo3[snum]+=15;
                    540:                          if (ammo3[snum] > MAXAMMO) {
                    541:                               ammo3[snum]=MAXAMMO;
                    542:                          }
                    543:                          strcpy(str,"SHRIKE DBK");
                    544:                          jsdeletesprite(i);
                    545:                          dosound++;
                    546:                     }
                    547:                     break;
                    548:                case 3093:
                    549:                     if( ((weapons[snum])&flags32[GUN4FLAG]) == 0 ) {
                    550:                          weapons[snum]|=flags32[GUN4FLAG];
                    551:                          ammo4[snum]+=15;
                    552:                          if (ammo4[snum] > MAXAMMO) {
                    553:                               ammo4[snum]=MAXAMMO;
                    554:                          }
                    555:                          strcpy(str,"ORLOW");
                    556:                          jsdeletesprite(i);
                    557:                          dosound++;
                    558:                     }
                    559:                     break;
                    560:                case 3095:
                    561:                     if( ((weapons[snum])&flags32[GUN5FLAG]) == 0 ) {
                    562:                          weapons[snum]|=flags32[GUN5FLAG];
                    563:                          ammo5[snum]+=15;
                    564:                          if (ammo5[snum] > MAXAMMO) {
                    565:                               ammo5[snum]=MAXAMMO;
                    566:                          }
                    567:                          strcpy(str,"EMP GUN");
                    568:                          jsdeletesprite(i);
                    569:                          dosound++;
                    570:                     }
                    571:                     break;
                    572:                case 3091:
                    573:                     if( ((weapons[snum])&flags32[GUN6FLAG]) == 0 ) {
                    574:                          weapons[snum]|=flags32[GUN6FLAG];
                    575:                          ammo6[snum]+=15;
                    576:                          if (ammo6[snum] > MAXAMMO) {
                    577:                               ammo6[snum]=MAXAMMO;
                    578:                          }
                    579:                          strcpy(str,"FLAMER");
                    580:                          jsdeletesprite(i);
                    581:                          dosound++;
                    582:                     }
                    583:                     break;
                    584:                case 3090:
                    585:                     if( ((weapons[snum])&flags32[GUN7FLAG]) == 0 ) {
                    586:                          weapons[snum]|=flags32[GUN7FLAG];
                    587:                          ammo7[snum]+=10;
                    588:                          if (ammo7[snum] > MAXAMMO) {
                    589:                               ammo7[snum]=MAXAMMO;
                    590:                          }
                    591:                          strcpy(str,"BAZOOKA");
                    592:                          jsdeletesprite(i);
                    593:                          dosound++;
                    594:                     }
                    595:                     break;
                    596:                // ammo pick ups
                    597:                case 924:
                    598:                case 3102:
                    599:                     if( (ammo2[snum] < MAXAMMO) ) { // && ((weapons[snum]&flags32[GUN2FLAG]) != 0) ) {
                    600:                          ammo2[snum]+=20;
                    601:                          if( ammo2[snum] > MAXAMMO ) {
                    602:                               ammo2[snum]=MAXAMMO;
                    603:                          }
                    604:                          strcpy(str,"PISTOL KLIP");
                    605:                          jsdeletesprite(i);
                    606:                          dosound++;
                    607:                     }
                    608:                     break;
                    609:                case 3104:
                    610:                     if( (ammo3[snum] < MAXAMMO) ) { // && ((weapons[snum]&flags32[GUN3FLAG]) != 0) ) {
                    611:                          ammo3[snum]+=10;
                    612:                          if( ammo3[snum] > MAXAMMO ) {
                    613:                               ammo3[snum]=MAXAMMO;
                    614:                          }
                    615:                          strcpy(str,"SHRIKE CHARGES");
                    616:                          jsdeletesprite(i);
                    617:                          dosound++;
                    618:                     }
                    619:                     break;
                    620:                case 3103:
                    621:                     if( (ammo4[snum] < MAXAMMO) ) { // && ((weapons[snum]&flags32[GUN4FLAG]) != 0) ) {
                    622:                          ammo4[snum]+=10;
                    623:                          if( ammo4[snum] > MAXAMMO ) {
                    624:                               ammo4[snum]=MAXAMMO;
                    625:                          }
                    626:                          strcpy(str,"ORLOW CHARGES");
                    627:                          jsdeletesprite(i);
                    628:                          dosound++;
                    629:                     }
                    630:                     break;
                    631:                case 925:
                    632:                case 3101:
                    633:                     if( (ammo6[snum] < MAXAMMO) ) { // && ((weapons[snum]&flags32[GUN6FLAG]) != 0) ) {
                    634:                          ammo6[snum]+=10;
                    635:                          if( ammo6[snum] > MAXAMMO ) {
                    636:                               ammo6[snum]=MAXAMMO;
                    637:                          }
                    638:                          strcpy(str,"FUEL BOTTLE");
                    639:                          jsdeletesprite(i);
                    640:                          dosound++;
                    641:                     }
                    642:                     break;
                    643:                case CHARGEPAKPIC:
                    644:                case 3100:
                    645:                     if( (ammo7[snum] < MAXAMMO) ) { // && ((weapons[snum]&flags32[GUN7FLAG]) != 0) ) {
                    646:                          ammo7[snum]+=5;
                    647:                          if( ammo7[snum] > MAXAMMO ) {
                    648:                               ammo7[snum]=MAXAMMO;
                    649:                          }
                    650:                          strcpy(str,"BAZOOKA FUEL");
                    651:                          jsdeletesprite(i);
                    652:                          dosound++;
                    653:                     }
                    654:                     break;
                    655:                case 3836:
                    656:                     if( (ammo8[snum] < MAXAMMO) ) { 
                    657:                          ammo8[snum]+=25;
                    658:                          if( ammo8[snum] > MAXAMMO ) {
                    659:                               ammo8[snum]=MAXAMMO;
                    660:                          }
                    661:                          strcpy(str,"GLOVE CHARGE");
                    662:                          jsdeletesprite(i);
                    663:                          dosound++;
                    664:                     }
                    665:                     break;
                    666: 
                    667: #if 0
                    668:                case CHARGEPAKPIC:
                    669:                     if (health[snum] < healthmax) {
                    670:                          strcpy(str,"HEALTH CHARGE PACK");
                    671:                          changehealth(snum,50);
                    672:                          jsdeletesprite(i);
                    673:                          dosound++;
                    674:                     }
                    675:                     break;
                    676: #endif
                    677:                case RED_KEYCARD:
                    678:                     if( invredcards[snum] == 0 ) {
                    679:                          strcpy(str,"RED KEY CARD");
                    680:                          invredcards[snum]=1;
                    681:                          jsdeletesprite(i);
                    682:                          dosound++;
                    683:                     }
                    684:                     break;
                    685:                case BLUE_KEYCARD:
                    686:                     if( invbluecards[snum] == 0 ) {
                    687:                          strcpy(str,"BLUE KEY CARD");
                    688:                          invbluecards[snum]=1;
                    689:                          jsdeletesprite(i);
                    690:                          dosound++;
                    691:                     }
                    692:                     break;
                    693:                default:
                    694:                     break;
                    695:                        }
                    696:                }
                    697:           if( dosound && (screenpeek == snum) ) {
                    698:                playsound(S_PICKUP_BONUS,0,0,0,ST_UNIQUE);
                    699:                showmessage(str);
                    700:           }
                    701:           dosound=0;
                    702: 
                    703:                i = nexti;
                    704:      }
                    705: }
                    706: 
                    707: extern
                    708: int  switchlevelsflag;
                    709: 
                    710: operatesprite(short dasprite)
                    711: {
                    712:        long           datag;
                    713:      int            healthmax;
                    714:      long           dx,dy,dz;
                    715:      spritetype     *spr;
                    716:      int            pu;
                    717: 
                    718:      // from tekstat.c
                    719:      #define   SPR_LOTAG_PICKUP    2004
                    720: 
                    721:      if( (option[4] == 0) && (sprptr[dasprite]->lotag == SPR_LOTAG_PICKUP) ) {
                    722:           pu=pickupsprite(dasprite);
                    723:           switch( sprptr[dasprite]->picnum ) {
                    724:           case RATPIC:
                    725:                if( pu ) {
                    726:                     showmessage("LIVE RAT");
                    727:                }
                    728:                break;
                    729:           case TUBEBOMB+1:
                    730:           case DARTBOMB+1:
                    731:                if( pu ) {
                    732:                     showmessage("GRENADE");
                    733:                }
                    734:           default:
                    735:                break;
                    736:           }
                    737:           return;
                    738:      }
                    739: 
                    740:      switch( sprptr[dasprite]->picnum ) {
                    741:      case 1361:   // the witchaven poster for demo
                    742:           playsound(S_WITCH,sprite[dasprite].x,sprite[dasprite].y,0,ST_UNIQUE);
                    743:           break;
                    744:      case 592:   // the witchaven poster for demo
                    745:           playsound(S_FLUSH,sprite[dasprite].x,sprite[dasprite].y,0,ST_UNIQUE);
                    746:           break;
                    747:      default:
                    748:           break;
                    749:      }
                    750: 
                    751:      spr=sprptr[dasprite];
                    752:      datag=spr->lotag;
                    753:      switch (datag) {
                    754:      case 6:
                    755:           if ((sprptr[dasprite]->cstat&0x001) != 0) {
                    756:                setanimpic(&spr->picnum,TICSPERFRAME*3,4);
                    757:           }
                    758:           else {
                    759:                setanimpic(&spr->picnum,TICSPERFRAME*3,-4);
                    760:           }
                    761:           sprptr[dasprite]->cstat^=0x101;
                    762:           teksetdelayfunc(operatesprite,CLKIPS*4,dasprite);
                    763:           break;
                    764:      case 4:
                    765:           if (!switchlevelsflag) {
                    766:                break;
                    767:           }
                    768:           if (option[4] != 0 && (spr->picnum == 182 || spr->picnum == 803)) {
                    769:                playsound(S_WH_SWITCH,sprite[dasprite].x,sprite[dasprite].y,0,ST_UNIQUE);
                    770:                nextnetlevel();
                    771:           }
                    772:           break;
                    773:      }
                    774: }
                    775: 
                    776: #define   DROPSIES       406    
                    777: #define   MAXDROPANGLES  6
                    778: char      dropanglecnt;
                    779: short     dropangles[MAXDROPANGLES] = { 0, 1792, 512, 768, 1536, 1024 };
                    780: 
                    781: dropit(long x, long y, long z, short sect, int pic)
                    782: {
                    783:      int       j,ang;
                    784: 
                    785:      j=jsinsertsprite(sect, DROPSIES);
                    786:      if( j != -1 ) {
                    787:           ang=dropangles[dropanglecnt];
                    788:             fillsprite(j,x,y,z,0,
                    789:                      0,0,12,
                    790:                      16,16,0,0,pic,ang,
                    791:                           sintable[(ang+2560)&2047]>>6,sintable[(ang+2048)&2047]>>6,
                    792:                           30L,0,sect,DROPSIES,0,0,0);
                    793:      }
                    794:      dropanglecnt++;
                    795:      if( dropanglecnt >= MAXDROPANGLES ) {
                    796:           dropanglecnt=0;
                    797:      }
                    798: }
                    799: 
                    800: playerdropitems(int snum)
                    801: {
                    802:      if( !validplayer(snum) ) {
                    803:           crash("dropitems on bad plrnum");
                    804:      }
                    805: 
                    806:      if( (weapons[snum]&flags32[GUN2FLAG]) != 0 ) {
                    807:           dropit(posx[snum],posy[snum],posz[snum]-(32<<8),cursectnum[snum],924);
                    808:           dropit(posx[snum],posy[snum],posz[snum]-(32<<8),cursectnum[snum],3102);
                    809:      }
                    810:      if( (weapons[snum]&flags32[GUN3FLAG]) != 0 ) {
                    811:           dropit(posx[snum],posy[snum],posz[snum]-(32<<8),cursectnum[snum],3104);
                    812:      }
                    813:      if( (weapons[snum]&flags32[GUN4FLAG]) != 0 ) {
                    814:           dropit(posx[snum],posy[snum],posz[snum]-(32<<8),cursectnum[snum],3103);
                    815:           dropit(posx[snum],posy[snum],posz[snum]-(32<<8),cursectnum[snum],3093);
                    816:      }
                    817:      if( (weapons[snum]&flags32[GUN5FLAG]) != 0 ) {
                    818:           dropit(posx[snum],posy[snum],posz[snum]-(32<<8),cursectnum[snum],3095);
                    819:      }
                    820:      if( (weapons[snum]&flags32[GUN6FLAG]) != 0 ) {
                    821:           dropit(posx[snum],posy[snum],posz[snum]-(32<<8),cursectnum[snum],925);
                    822:           dropit(posx[snum],posy[snum],posz[snum]-(32<<8),cursectnum[snum],3101);
                    823:           dropit(posx[snum],posy[snum],posz[snum]-(32<<8),cursectnum[snum],3091);
                    824:      }
                    825:      if( (weapons[snum]&flags32[GUN7FLAG]) != 0 ) {
                    826:           dropit(posx[snum],posy[snum],posz[snum]-(32<<8),cursectnum[snum],3100);
                    827:           dropit(posx[snum],posy[snum],posz[snum]-(32<<8),cursectnum[snum],3090);
                    828:      }
                    829: }

unix.superglobalmegacorp.com