p_doors.c

The source code of Doom legacy for windows

      door->topheight = P_FindLowestCeilingSurrounding(sec) - 4*FRACUNIT;
      door->direction = 1;

      if (door->topheight != sec->ceilingheight)
        S_StartSound((mobj_t *)&door->sector->soundorg,
                     speed >= 4 ? sfx_bdopn : sfx_doropn);
    }
}

//
// EV_CloseDoor
//
// Used by FraggleScript
void EV_CloseDoor(int sectag, int speed)
{
  vldoor_e door_type;
  int secnum = -1;
  vldoor_t *door;

  if(speed < 1) speed = 1;
  
  // find out door type first

  if(speed >= 4)              // blazing ?
    door_type = blazeClose;
  else
    door_type = doorclose;
  
  // open door in all the sectors with the specified tag

  while ((secnum = P_FindSectorFromTag(sectag, secnum)) >= 0)
    {
      sector_t *sec = &sectors[secnum];
      // if the ceiling already moving, don't start the door action
      if (P_SectorActive(ceiling_special,sec)) //jff 2/22/98
        continue;

      // new door thinker
      door = Z_Malloc (sizeof(*door), PU_LEVSPEC, 0);
      P_AddThinker(&door->thinker);
      sec->ceilingdata = door;

      door->thinker.function.acp1 = (actionf_p1)T_VerticalDoor;
      door->sector = sec;
      door->type = door_type;
      door->speed = VDOORSPEED * speed;
      door->line = NULL;   // not triggered by a line
      door->topheight = P_FindLowestCeilingSurrounding(sec) - 4*FRACUNIT;
      door->direction = -1;

      S_StartSound((mobj_t *)&door->sector->soundorg,
                   speed >= 4 ? sfx_bdcls : sfx_dorcls);
    }  
}



//
// EV_VerticalDoor : open a door manually, no tag value
//
//SoM: 3/6/2000: Needs int return for boom compatability. Also removed "side" and used boom
//methods insted.
int
EV_VerticalDoor
( line_t*       line,
  mobj_t*       thing )
{
    player_t*   player;
    int         secnum;
    sector_t*   sec;
    vldoor_t*   door;
//    int         side; //SoM: 3/6/2000

//    side = 0;   // only front sides can be used

    //  Check for locks
    player = thing->player;

    switch(line->special)
    {
      case 26: // Blue Lock
      case 32:
        if ( !player )
            return 0;
        if (!(player->cards & it_bluecard) && !(player->cards & it_blueskull))
        {
            player->message = PD_BLUEK;
#ifdef HW3SOUND
            S_StartScreamSound(player->mo, sfx_oof);
#else
            S_StartSound(player->mo,sfx_oof);   //SoM: 3/6/2000: Killough's idea
#endif
            return 0;
        }
        break;

      case 27: // Yellow Lock
      case 34:
        if ( !player )
            return 0;

        if (!(player->cards & it_yellowcard) &&
            !(player->cards & it_yellowskull))
        {
            player->message = PD_YELLOWK;
#ifdef HW3SOUND
            S_StartScreamSound(player->mo, sfx_oof);
#else
            S_StartSound(player->mo,sfx_oof); //SoM: 3/6/2000: Killough's idea
#endif
            return 0;
        }
        break;

      case 28: // Red Lock
      case 33:
        if ( !player )
            return 0;

        if (!(player->cards & it_redcard) && !(player->cards & it_redskull))
        {
            player->message = PD_REDK;
#ifdef HW3SOUND
            S_StartScreamSound(player->mo, sfx_oof);
#else
            S_StartSound(player->mo,sfx_oof); //SoM: 3/6/2000: Killough's idea
#endif
            return 0;
        }
        break;
    }
    //SoM: 3/6/2000
    // if the wrong side of door is pushed, give oof sound
    if (line->sidenum[1]==-1)                     // killough
    {
#ifdef HW3SOUND
      S_StartScreamSound(player->mo, sfx_oof);
#else
      S_StartSound(player->mo,sfx_oof);           // killough 3/20/98
#endif
      return 0;
    }

    // if the sector has an active thinker, use it
    sec = sides[ line->sidenum[1]] .sector;
    secnum = sec-sectors;

    if (sec->ceilingdata) //SoM: 3/6/2000
    {
        door = sec->ceilingdata; //SoM: 3/6/2000
        switch(line->special)
        {
          case  1: // ONLY FOR "RAISE" DOORS, NOT "OPEN"s
          case  26:
          case  27:
          case  28:
          case  117:
            if (door->direction == -1)
                door->direction = 1;    // go back up
            else
            {
                if (!thing->player)
                    return 0;            // JDC: bad guys never close doors

                door->direction = -1;   // start going down immediately
            }
            return 1;
        }
    }

    // for proper sound
    switch(line->special)
    {
      case 117: // BLAZING DOOR RAISE
      case 118: // BLAZING DOOR OPEN
        S_StartSound((mobj_t *)&sec->soundorg,sfx_bdopn);
        break;

      case 1:   // NORMAL DOOR SOUND
      case 31:
        S_StartSound((mobj_t *)&sec->soundorg,sfx_doropn);
        break;

      default:  // LOCKED DOOR SOUND
        S_StartSound((mobj_t *)&sec->soundorg,sfx_doropn);
        break;
    }


    // new door thinker
    door = Z_Malloc (sizeof(*door), PU_LEVSPEC, 0);
    P_AddThinker (&door->thinker);
    sec->ceilingdata = door; //SoM:3/6/2000
    door->thinker.function.acp1 = (actionf_p1) T_VerticalDoor;
    door->sector = sec;
    door->direction = 1;
    door->speed = VDOORSPEED;
    door->topwait = VDOORWAIT;
    door->line = line; // SoM: 3/6/2000: remember line that triggered the door

    switch(line->special)
    {
      case 1:
      case 26:
      case 27:
      case 28:
        door->type = normalDoor;
        break;

      case 31:
      case 32:
      case 33:
      case 34:
        door->type = dooropen;
        line->special = 0;
        break;

      case 117: // blazing door raise
        door->type = blazeRaise;
        door->speed = VDOORSPEED*4;
        break;
      case 118: // blazing door open
        door->type = blazeOpen;
        line->special = 0;
        door->speed = VDOORSPEED*4;
        break;
    }

    // find the top and bottom of the movement range
    door->topheight = P_FindLowestCeilingSurrounding(sec);
    door->topheight -= 4*FRACUNIT;
    return 1;
}


//
// Spawn a door that closes after 30 seconds
//
void P_SpawnDoorCloseIn30 (sector_t* sec)
{
    vldoor_t*   door;

    door = Z_Malloc ( sizeof(*door), PU_LEVSPEC, 0);

    P_AddThinker (&door->thinker);

    sec->ceilingdata = door; //SoM: 3/6/2000
    sec->special = 0;

    door->thinker.function.acp1 = (actionf_p1)T_VerticalDoor;
    door->sector = sec;
    door->direction = 0;
    door->type = normalDoor;
    door->speed = VDOORSPEED;
    door->topcountdown = 30 * 35;
    door->line = NULL; //SoM: Remember the line that triggered the door.
}

//
// Spawn a door that opens after 5 minutes
//
void
P_SpawnDoorRaiseIn5Mins
( sector_t*     sec,
  int           secnum )
{
    vldoor_t*   door;

    door = Z_Malloc ( sizeof(*door), PU_LEVSPEC, 0);

    P_AddThinker (&door->thinker);

    sec->ceilingdata = door; //SoM: 3/6/2000
    sec->special = 0;

    door->thinker.function.acp1 = (actionf_p1)T_VerticalDoor;
    door->sector = sec;
    door->direction = 2;
    door->type = raiseIn5Mins;
    door->speed = VDOORSPEED;
    door->topheight = P_FindLowestCeilingSurrounding(sec);
    door->topheight -= 4*FRACUNIT;
    door->topwait = VDOORWAIT;
    door->topcountdown = 5 * 60 * 35;
    door->line = NULL; //SoM: 3/6/2000: You know....
}



// ==========================================================================
//                        SLIDE DOORS, UNUSED
// ==========================================================================

#if 0           // ABANDONED TO THE MISTS OF TIME!!!
//
// EV_SlidingDoor : slide a door horizontally
// (animate midtexture, then set noblocking line)
//


/*slideframe_t slideFrames[MAXSLIDEDOORS];

void P_InitSlidingDoorFrames(void)
{
    int         i;
    int         f1;
    int         f2;
    int         f3;
    int         f4;

    // DOOM II ONLY...
    if ( gamemode != commercial)
        return;

    for (i = 0;i < MAXSLIDEDOORS; i++)
    {
        if (!slideFrameNames[i].frontFrame1[0])
            break;

        f1 = R_TextureNumForName(slideFrameNames[i].frontFrame1);
        f2 = R_TextureNumForName(slideFrameNames[i].frontFrame2);
        f3 = R_TextureNumForName(slideFrameNames[i].frontFrame3);
        f4 = R_TextureNumForName(slideFrameNames[i].frontFrame4);

        slideFrames[i].frontFrames[0] = f1;
        slideFrames[i].frontFrames[1] = f2;
        slideFrames[i].frontFrames[2] = f3;
        slideFrames[i].frontFrames[3] = f4;

        f1 = R_TextureNumForName(slideFrameNames[i].backFrame1);
        f2 = R_TextureNumForName(slideFrameNames[i].backFrame2);
        f3 = R_TextureNumForName(slideFrameNames[i].backFrame3);
        f4 = R_TextureNumForName(slideFrameNames[i].backFrame4);

        slideFrames[i].backFrames[0] = f1;
        slideFrames[i].backFrames[1] = f2;
        slideFrames[i].backFrames[2] = f3;
        slideFrames[i].backFrames[3] = f4;
    }
}


//
// Return index into "slideFrames" array
// for which door type to use
//
int P_FindSlidingDoorType(line_t*       line)
{
    int         i;
    int         val;

    for (i = 0;i < MAXSLIDEDOORS;i++)
    {
        val = sides[line->sidenum[0]].midtexture;
        if (val == slideFrames[i].frontFrames[0])
            return i;
    }

    return -1;
}

void T_SlidingDoor (slidedoor_t*        door)
{
    switch(door->status)
    {
      case sd_opening:
        if (!door->timer--)
        {
            if (++door->frame == SNUMFRAMES)
            {
                // IF DOOR IS DONE OPENING...
                sides[door->line->sidenum[0]].midtexture = 0;
                sides[door->line->sidenum[1]].midtexture = 0;
                door->line->flags &= ML_BLOCKING^0xff;

                if (door->type == sdt_openOnly)
                {
                    door->frontsector->ceilingdata = NULL;
                    P_RemoveThinker (&door->thinker);
                    break;
                }

                door->timer = SDOORWAIT;
                door->status = sd_waiting;
            }
            else
            {
                // IF DOOR NEEDS TO ANIMATE TO NEXT FRAME...
                door->timer = SWAITTICS;

                sides[door->line->sidenum[0]].midtexture =
                    slideFrames[door->whichDoorIndex].
                    frontFrames[door->frame];
                sides[door->line->sidenum[1]].midtexture =
                    slideFrames[door->whichDoorIndex].
                    backFrames[door->frame];
            }
        }
        break;

      case sd_waiting:
        // IF DOOR IS DONE WAITING...
        if (!door->timer--)
        {
            // CAN DOOR CLOSE?
            if (door->frontsector->thinglist != NULL ||
                door->backsector->thinglist != NULL)
            {
                door->timer = SDOORWAIT;
                break;
            }

            //door->frame = SNUMFRAMES-1;
            door->status = sd_closing;
            door->timer = SWAITTICS;
        }
        break;

      case sd_closing:
        if (!door->timer--)
        {
            if (--door->frame < 0)
            {
                // IF DOOR IS DONE CLOSING...
                door->line->flags |= ML_BLOCKING;
                door->frontsector->specialdata = NULL;
                P_RemoveThinker (&door->thinker);
                break;
            }
            else
            {
                // IF DOOR NEEDS TO ANIMATE TO NEXT FRAME...
                door->timer = SWAITTICS;

                sides[door->line->sidenum[0]].midtexture =
                    slideFrames[door->whichDoorIndex].
                    frontFrames[door->frame];
                sides[door->line->sidenum[1]].midtexture =
                    slideFrames[door->whichDoorIndex].
                    backFrames[door->frame];
            }
        }
        break;
    }
}



void
EV_SlidingDoor
( line_t*       line,
  mobj_t*       thing )
{
    sector_t*           sec;
    slidedoor_t*        door;

    // DOOM II ONLY...
    if (gamemode != commercial)
        return;

    // Make sure door isn't already being animated
    sec = line->frontsector;
    door = NULL;
    if (sec->specialdata)
    {
        if (!thing->player)
            return;

        door = sec->specialdata;
        if (door->type == sdt_openAndClose)
        {
            if (door->status == sd_waiting)
                door->status = sd_closing;
        }
        else
            return;
    }

    // Init sliding door vars
    if (!door)
    {
        door = Z_Malloc (sizeof(*door), PU_LEVSPEC, 0);
        P_AddThinker (&door->thinker);
        sec->specialdata = door;

        door->type = sdt_openAndClose;
        door->status = sd_opening;
        door->whichDoorIndex = P_FindSlidingDoorType(line);

        if (door->whichDoorIndex < 0)
            I_Error("EV_SlidingDoor: Can't use texture for sliding door!");

        door->frontsector = sec;
        door->backsector = line->backsector;
        door->thinker.function = T_SlidingDoor;
        door->timer = SWAITTICS;
        door->frame = 0;
        door->line = line;
    }
}*/
#endif