Annotation of src/movedoor.c, revision 1.1.1.1

1.1       root        1: void
                      2: EFF_moveDoor(short d)
                      3: {
                      4:      int  i,
                      5:           j,
                      6:           rotang,
                      7:           s;
                      8:      long beforez,goalz,
                      9:           deltaz,
                     10:           newx,newy;
                     11:      struct doorData *dptr;
                     12:      sectortype *sect;
                     13: 
                     14:      dptr=doorPtr[d];
                     15:      if (dptr->state == DOORSTATE_IDLE) {
                     16:           return;
                     17:      }
                     18:      s=dptr->sectorIndex;
                     19:      sect=sectorPtr[s];
                     20:      switch (sect->lotag) {
                     21:      case SEC_DOORUPTAG:
                     22:      case SEC_DOORUPONCETAG:
                     23:           switch (dptr->state) {
                     24:           case DOORSTATE_OPEN:
                     25:                if (EFF_moveSectorCeiling(s,sect,-(dptr->speed*TICWAITPERFRAME),
                     26:                                          dptr->hiz)) {
                     27:                     dptr->state=DOORSTATE_OPENED;
                     28:                }
                     29:                break;
                     30:           case DOORSTATE_CLOSE:
                     31:                i=headspritesect[s];
                     32:                while (i != -1) {   // check for living objects in door sector
                     33:                     j=nextspritesect[i];
                     34:                     if (ACT_getHealth(i) > 0) {
                     35:                          dptr->state=DOORSTATE_OPEN;
                     36:                          break;
                     37:                     }
                     38:                     i=j;
                     39:                }
                     40:                if (EFF_moveSectorCeiling(s,sect,(dptr->speed*TICWAITPERFRAME),
                     41:                                          dptr->loz)) {
                     42:                     dptr->state=DOORSTATE_CLOSED;
                     43:                }
                     44:                break;
                     45:           }
                     46:           break;
                     47:      case SEC_DOORDOWNTAG:
                     48:      case SEC_DOORDOWNONCETAG:
                     49:      case SEC_PLATFORMDOWNTAG:
                     50:      case SEC_PLATFORMELEVATORTAG:
                     51:           switch (dptr->state) {
                     52:           case DOORSTATE_OPEN:
                     53:                beforez=sect->floorz;
                     54:                if (EFF_moveSectorFloor(s,sect,dptr->speed*TICWAITPERFRAME,
                     55:                                         dptr->loz)) {
                     56:                     dptr->state=DOORSTATE_OPENED;
                     57:                }
                     58:                if (EFF_isElevator(s)) {
                     59:                     deltaz=sect->floorz-beforez;
                     60:                     for (i=headspritesect[s] ; i >= 0 ; i=j) {
                     61:                          j=nextspritesect[i];
                     62:                          if (GAM_isOnGround(i)) {
                     63:                               spritePtr[i]->z+=deltaz;
                     64:                          }
                     65:                     }
                     66:                     if (sect->lotag == SEC_PLATFORMELEVATORTAG) {
                     67:                          sect->ceilingz=sect->floorz-dptr->height;
                     68:                     }
                     69:                }
                     70:                break;
                     71:           case DOORSTATE_CLOSE:
                     72:                if (EFF_isDoor(s)) {
                     73:                     i=headspritesect[s];
                     74:                     while (i != -1) {   // check for living objects in sector
                     75:                          j=nextspritesect[i];
                     76:                          if (ACT_getHealth(i) > 0) {
                     77:                               dptr->state=DOORSTATE_OPEN;
                     78:                               break;
                     79:                          }
                     80:                          i=j;
                     81:                     }
                     82:                }
                     83:                beforez=sect->floorz;
                     84:                if (EFF_moveSectorFloor(s,sect,-(dptr->speed*TICWAITPERFRAME),
                     85:                                         dptr->hiz)) {
                     86:                     dptr->state=DOORSTATE_CLOSED;
                     87:                }
                     88:                if (EFF_isElevator(s)) {
                     89:                     deltaz=sect->floorz-beforez;
                     90:                     for (i=headspritesect[s] ; i >= 0 ; i=j) {
                     91:                          j=nextspritesect[i];
                     92:                          if (GAM_isOnGround(i)) {
                     93:                               spritePtr[i]->z+=deltaz;
                     94:                          }
                     95:                     }
                     96:                     if (sect->lotag == SEC_PLATFORMELEVATORTAG) {
                     97:                          sect->ceilingz=sect->floorz-dptr->height;
                     98:                     }
                     99:                }
                    100:                break;
                    101:           }
                    102:           break;
                    103:      case SEC_PLATFORMUPTAG:
                    104:           switch (dptr->state) {
                    105:           case DOORSTATE_OPEN:
                    106:                beforez=sect->floorz;
                    107:                if (EFF_moveSectorFloor(s,sect,-(dptr->speed*TICWAITPERFRAME),
                    108:                                         dptr->hiz)) {
                    109:                     dptr->state=DOORSTATE_OPENED;
                    110:                }
                    111:                deltaz=sect->floorz-beforez;
                    112:                for (i=headspritesect[s] ; i >= 0 ; i=j) {
                    113:                     j=nextspritesect[i];
                    114:                     if (GAM_isOnGround(i)) {
                    115:                          spritePtr[i]->z+=deltaz;
                    116:                     }
                    117:                }
                    118:                break;
                    119:           case DOORSTATE_CLOSE:
                    120:                beforez=sect->floorz;
                    121:                if (EFF_moveSectorFloor(s,sect,dptr->speed*TICWAITPERFRAME,
                    122:                                         dptr->loz)) {
                    123:                     dptr->state=DOORSTATE_CLOSED;
                    124:                }
                    125:                deltaz=sect->floorz-beforez;
                    126:                for (i=headspritesect[s] ; i >= 0 ; i=j) {
                    127:                     j=nextspritesect[i];
                    128:                     if (GAM_isOnGround(i)) {
                    129:                          spritePtr[i]->z+=deltaz;
                    130:                     }
                    131:                }
                    132:                break;
                    133:           }
                    134:           break;
                    135:      case SEC_DOORHSPLITTAG:
                    136:      case SEC_DOORHSPLITONCETAG:
                    137:           switch (dptr->state) {
                    138:           case DOORSTATE_OPEN:
                    139:                i=0;
                    140:                if (EFF_moveSectorCeiling(s,sect,-(dptr->speed*TICWAITPERFRAME),
                    141:                                           dptr->hiz)) {
                    142:                     i=1;
                    143:                }
                    144:                if (EFF_moveSectorFloor(s,sect,dptr->speed*TICWAITPERFRAME,
                    145:                                         dptr->loz)) {
                    146:                     i|=2;
                    147:                }
                    148:                if (i == 3) {
                    149:                     dptr->state=DOORSTATE_OPENED;
                    150:                }
                    151:                break;
                    152:           case DOORSTATE_CLOSE:
                    153:                i=headspritesect[s];
                    154:                while (i != -1) {   // check for living objects in door sector
                    155:                     j=nextspritesect[i];
                    156:                     if (ACT_getHealth(i) > 0) {
                    157:                          dptr->state=DOORSTATE_OPEN;
                    158:                          break;
                    159:                     }
                    160:                     i=j;
                    161:                }
                    162:                goalz=sectorCenterPtr[s]->centerz;
                    163:                i=0;
                    164:                if (EFF_moveSectorCeiling(s,sect,dptr->speed*TICWAITPERFRAME,
                    165:                                           goalz)) {
                    166:                     i=1;
                    167:                }
                    168:                if (EFF_moveSectorFloor(s,sect,-(dptr->speed*TICWAITPERFRAME),
                    169:                                         goalz)) {
                    170:                     i|=2;
                    171:                }
                    172:                if (i == 3) {
                    173:                     dptr->state=DOORSTATE_CLOSED;
                    174:                }
                    175:                break;
                    176:           }
                    177:           break;
                    178:      case SEC_DOORSLIDECENTERTAG:
                    179:           switch (dptr->state) {
                    180:           case DOORSTATE_OPEN:
                    181:                if (EFF_slideDoorOpen(d)) {
                    182:                     dptr->state=DOORSTATE_OPENED;
                    183:                }
                    184:                break;
                    185:           case DOORSTATE_CLOSE:
                    186:                if (EFF_slideDoorClose(d)) {
                    187:                     dptr->state=DOORSTATE_CLOSED;
                    188:                }
                    189:                break;
                    190:           }
                    191:           break;
                    192:      case SEC_ROTATESECTORTAG:
                    193:      case SEC_BONUSSECTORTAG:
                    194:           i=0;
                    195:           rotang=dptr->hiz-dptr->loz;
                    196:           dptr->loz=dptr->hiz;
                    197:           while ((j=dptr->wallIndex[i]) >= 0) {
                    198:                rotatepoint(sectorCenterPtr[s]->centerx,
                    199:                            sectorCenterPtr[s]->centery,
                    200:                            dptr->wallx[i],dptr->wally[i],
                    201:                            dptr->loz,&newx,&newy);
                    202:                dragpoint(j,newx,newy);
                    203:                i++;
                    204:           }
                    205:           for (i=headspritesect[s] ; i >= 0 ; i=j) {
                    206:                j=nextspritesect[i];
                    207:                if (!GAM_isOnGround(i)) {
                    208:                     continue;
                    209:                }
                    210:                if (rotang != 0) {
                    211:                     spritePtr[i]->ang=(spritePtr[i]->ang+rotang)&2047;
                    212:                     rotatepoint(sectorCenterPtr[s]->centerx,
                    213:                                 sectorCenterPtr[s]->centery,
                    214:                                 spritePtr[i]->x,spritePtr[i]->y,
                    215:                                 rotang&2047,&newx,&newy);
                    216:                     setsprite(i,newx,newy,spritePtr[i]->z);
                    217:                }
                    218:           }
                    219:           dptr->hiz=(dptr->hiz+dptr->speed)&2047;
                    220:           break;
                    221:      }
                    222: //** play sounds here
                    223:      switch (dptr->state) {
                    224:      case DOORSTATE_OPEN:
                    225:      case DOORSTATE_CLOSE:
                    226:           SND_playSectorMovingSound(s,1);
                    227:           break;
                    228:      case DOORSTATE_OPENED:
                    229:           switch (sect->lotag) {
                    230:           case SEC_DOORUPONCETAG:
                    231:           case SEC_DOORDOWNONCETAG:
                    232:           case SEC_DOORHSPLITONCETAG:
                    233:                dptr->state=DOORSTATE_IDLE;
                    234:                break;
                    235:           default:
                    236:                dptr->state=DOORSTATE_WAITING;
                    237:                dptr->delay=TMR_getSecondTics(4);
                    238:                break;
                    239:           }
                    240:           SND_playSectorMovingSound(s,0);
                    241:           SND_playSectorStopSound(s);
                    242:           break;
                    243:      case DOORSTATE_CLOSED:
                    244:           dptr->state=DOORSTATE_IDLE;
                    245:           EFF_blockDoorWalls(s);
                    246:           SND_playSectorMovingSound(s,0);
                    247:           SND_playSectorStopSound(s);
                    248:           break;
                    249:      case DOORSTATE_WAITING:
                    250:           if (dptr->movingSectorFlag == 0) {
                    251:                dptr->delay-=TICWAITPERFRAME;
                    252:                if (dptr->delay <= 0) {
                    253:                     dptr->state=DOORSTATE_CLOSE;
                    254:                     EFF_turnSwitchesOff(sect->hitag);
                    255:                     SND_playSectorMovingSound(s,0);
                    256:                     SND_playSectorCloseSound(s);
                    257:                }
                    258:           }
                    259:           break;
                    260:      }
                    261: }
                    262: 

unix.superglobalmegacorp.com