summaryrefslogtreecommitdiff
path: root/src/p_doors.c
diff options
context:
space:
mode:
Diffstat (limited to 'src/p_doors.c')
-rw-r--r--src/p_doors.c767
1 files changed, 767 insertions, 0 deletions
diff --git a/src/p_doors.c b/src/p_doors.c
new file mode 100644
index 00000000..75431a97
--- /dev/null
+++ b/src/p_doors.c
@@ -0,0 +1,767 @@
+// Emacs style mode select -*- C++ -*-
+//-----------------------------------------------------------------------------
+//
+// $Id: p_doors.c 4 2005-07-23 16:19:41Z fraggle $
+//
+// Copyright (C) 1993-1996 by id Software, Inc.
+//
+// This source is available for distribution and/or modification
+// only under the terms of the DOOM Source Code License as
+// published by id Software. All rights reserved.
+//
+// The source is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// FITNESS FOR A PARTICULAR PURPOSE. See the DOOM Source Code License
+// for more details.
+//
+// $Log$
+// Revision 1.1 2005/07/23 16:20:34 fraggle
+// Initial revision
+//
+//
+// DESCRIPTION: Door animation code (opening/closing)
+//
+//-----------------------------------------------------------------------------
+
+static const char
+rcsid[] = "$Id: p_doors.c 4 2005-07-23 16:19:41Z fraggle $";
+
+
+#include "z_zone.h"
+#include "doomdef.h"
+#include "p_local.h"
+
+#include "s_sound.h"
+
+
+// State.
+#include "doomstat.h"
+#include "r_state.h"
+
+// Data.
+#include "dstrings.h"
+#include "sounds.h"
+
+#if 0
+//
+// Sliding door frame information
+//
+slidename_t slideFrameNames[MAXSLIDEDOORS] =
+{
+ {"GDOORF1","GDOORF2","GDOORF3","GDOORF4", // front
+ "GDOORB1","GDOORB2","GDOORB3","GDOORB4"}, // back
+
+ {"\0","\0","\0","\0"}
+};
+#endif
+
+
+//
+// VERTICAL DOORS
+//
+
+//
+// T_VerticalDoor
+//
+void T_VerticalDoor (vldoor_t* door)
+{
+ result_e res;
+
+ switch(door->direction)
+ {
+ case 0:
+ // WAITING
+ if (!--door->topcountdown)
+ {
+ switch(door->type)
+ {
+ case blazeRaise:
+ door->direction = -1; // time to go back down
+ S_StartSound((mobj_t *)&door->sector->soundorg,
+ sfx_bdcls);
+ break;
+
+ case normal:
+ door->direction = -1; // time to go back down
+ S_StartSound((mobj_t *)&door->sector->soundorg,
+ sfx_dorcls);
+ break;
+
+ case close30ThenOpen:
+ door->direction = 1;
+ S_StartSound((mobj_t *)&door->sector->soundorg,
+ sfx_doropn);
+ break;
+
+ default:
+ break;
+ }
+ }
+ break;
+
+ case 2:
+ // INITIAL WAIT
+ if (!--door->topcountdown)
+ {
+ switch(door->type)
+ {
+ case raiseIn5Mins:
+ door->direction = 1;
+ door->type = normal;
+ S_StartSound((mobj_t *)&door->sector->soundorg,
+ sfx_doropn);
+ break;
+
+ default:
+ break;
+ }
+ }
+ break;
+
+ case -1:
+ // DOWN
+ res = T_MovePlane(door->sector,
+ door->speed,
+ door->sector->floorheight,
+ false,1,door->direction);
+ if (res == pastdest)
+ {
+ switch(door->type)
+ {
+ case blazeRaise:
+ case blazeClose:
+ door->sector->specialdata = NULL;
+ P_RemoveThinker (&door->thinker); // unlink and free
+ S_StartSound((mobj_t *)&door->sector->soundorg,
+ sfx_bdcls);
+ break;
+
+ case normal:
+ case close:
+ door->sector->specialdata = NULL;
+ P_RemoveThinker (&door->thinker); // unlink and free
+ break;
+
+ case close30ThenOpen:
+ door->direction = 0;
+ door->topcountdown = 35*30;
+ break;
+
+ default:
+ break;
+ }
+ }
+ else if (res == crushed)
+ {
+ switch(door->type)
+ {
+ case blazeClose:
+ case close: // DO NOT GO BACK UP!
+ break;
+
+ default:
+ door->direction = 1;
+ S_StartSound((mobj_t *)&door->sector->soundorg,
+ sfx_doropn);
+ break;
+ }
+ }
+ break;
+
+ case 1:
+ // UP
+ res = T_MovePlane(door->sector,
+ door->speed,
+ door->topheight,
+ false,1,door->direction);
+
+ if (res == pastdest)
+ {
+ switch(door->type)
+ {
+ case blazeRaise:
+ case normal:
+ door->direction = 0; // wait at top
+ door->topcountdown = door->topwait;
+ break;
+
+ case close30ThenOpen:
+ case blazeOpen:
+ case open:
+ door->sector->specialdata = NULL;
+ P_RemoveThinker (&door->thinker); // unlink and free
+ break;
+
+ default:
+ break;
+ }
+ }
+ break;
+ }
+}
+
+
+//
+// EV_DoLockedDoor
+// Move a locked door up/down
+//
+
+int
+EV_DoLockedDoor
+( line_t* line,
+ vldoor_e type,
+ mobj_t* thing )
+{
+ player_t* p;
+
+ p = thing->player;
+
+ if (!p)
+ return 0;
+
+ switch(line->special)
+ {
+ case 99: // Blue Lock
+ case 133:
+ if ( !p )
+ return 0;
+ if (!p->cards[it_bluecard] && !p->cards[it_blueskull])
+ {
+ p->message = PD_BLUEO;
+ S_StartSound(NULL,sfx_oof);
+ return 0;
+ }
+ break;
+
+ case 134: // Red Lock
+ case 135:
+ if ( !p )
+ return 0;
+ if (!p->cards[it_redcard] && !p->cards[it_redskull])
+ {
+ p->message = PD_REDO;
+ S_StartSound(NULL,sfx_oof);
+ return 0;
+ }
+ break;
+
+ case 136: // Yellow Lock
+ case 137:
+ if ( !p )
+ return 0;
+ if (!p->cards[it_yellowcard] &&
+ !p->cards[it_yellowskull])
+ {
+ p->message = PD_YELLOWO;
+ S_StartSound(NULL,sfx_oof);
+ return 0;
+ }
+ break;
+ }
+
+ return EV_DoDoor(line,type);
+}
+
+
+int
+EV_DoDoor
+( line_t* line,
+ vldoor_e type )
+{
+ int secnum,rtn;
+ sector_t* sec;
+ vldoor_t* door;
+
+ secnum = -1;
+ rtn = 0;
+
+ while ((secnum = P_FindSectorFromLineTag(line,secnum)) >= 0)
+ {
+ sec = &sectors[secnum];
+ if (sec->specialdata)
+ continue;
+
+
+ // new door thinker
+ rtn = 1;
+ door = Z_Malloc (sizeof(*door), PU_LEVSPEC, 0);
+ P_AddThinker (&door->thinker);
+ sec->specialdata = door;
+
+ door->thinker.function.acp1 = (actionf_p1) T_VerticalDoor;
+ door->sector = sec;
+ door->type = type;
+ door->topwait = VDOORWAIT;
+ door->speed = VDOORSPEED;
+
+ switch(type)
+ {
+ case blazeClose:
+ door->topheight = P_FindLowestCeilingSurrounding(sec);
+ door->topheight -= 4*FRACUNIT;
+ door->direction = -1;
+ door->speed = VDOORSPEED * 4;
+ S_StartSound((mobj_t *)&door->sector->soundorg,
+ sfx_bdcls);
+ break;
+
+ case close:
+ door->topheight = P_FindLowestCeilingSurrounding(sec);
+ door->topheight -= 4*FRACUNIT;
+ door->direction = -1;
+ S_StartSound((mobj_t *)&door->sector->soundorg,
+ sfx_dorcls);
+ break;
+
+ case close30ThenOpen:
+ door->topheight = sec->ceilingheight;
+ door->direction = -1;
+ S_StartSound((mobj_t *)&door->sector->soundorg,
+ sfx_dorcls);
+ break;
+
+ case blazeRaise:
+ case blazeOpen:
+ door->direction = 1;
+ door->topheight = P_FindLowestCeilingSurrounding(sec);
+ door->topheight -= 4*FRACUNIT;
+ door->speed = VDOORSPEED * 4;
+ if (door->topheight != sec->ceilingheight)
+ S_StartSound((mobj_t *)&door->sector->soundorg,
+ sfx_bdopn);
+ break;
+
+ case normal:
+ case open:
+ door->direction = 1;
+ door->topheight = P_FindLowestCeilingSurrounding(sec);
+ door->topheight -= 4*FRACUNIT;
+ if (door->topheight != sec->ceilingheight)
+ S_StartSound((mobj_t *)&door->sector->soundorg,
+ sfx_doropn);
+ break;
+
+ default:
+ break;
+ }
+
+ }
+ return rtn;
+}
+
+
+//
+// EV_VerticalDoor : open a door manually, no tag value
+//
+void
+EV_VerticalDoor
+( line_t* line,
+ mobj_t* thing )
+{
+ player_t* player;
+ int secnum;
+ sector_t* sec;
+ vldoor_t* door;
+ int side;
+
+ 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;
+
+ if (!player->cards[it_bluecard] && !player->cards[it_blueskull])
+ {
+ player->message = PD_BLUEK;
+ S_StartSound(NULL,sfx_oof);
+ return;
+ }
+ break;
+
+ case 27: // Yellow Lock
+ case 34:
+ if ( !player )
+ return;
+
+ if (!player->cards[it_yellowcard] &&
+ !player->cards[it_yellowskull])
+ {
+ player->message = PD_YELLOWK;
+ S_StartSound(NULL,sfx_oof);
+ return;
+ }
+ break;
+
+ case 28: // Red Lock
+ case 33:
+ if ( !player )
+ return;
+
+ if (!player->cards[it_redcard] && !player->cards[it_redskull])
+ {
+ player->message = PD_REDK;
+ S_StartSound(NULL,sfx_oof);
+ return;
+ }
+ break;
+ }
+
+ // if the sector has an active thinker, use it
+ sec = sides[ line->sidenum[side^1]] .sector;
+ secnum = sec-sectors;
+
+ if (sec->specialdata)
+ {
+ door = sec->specialdata;
+ 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; // JDC: bad guys never close doors
+
+ door->direction = -1; // start going down immediately
+ }
+ return;
+ }
+ }
+
+ // 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->specialdata = door;
+ door->thinker.function.acp1 = (actionf_p1) T_VerticalDoor;
+ door->sector = sec;
+ door->direction = 1;
+ door->speed = VDOORSPEED;
+ door->topwait = VDOORWAIT;
+
+ switch(line->special)
+ {
+ case 1:
+ case 26:
+ case 27:
+ case 28:
+ door->type = normal;
+ break;
+
+ case 31:
+ case 32:
+ case 33:
+ case 34:
+ door->type = open;
+ 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;
+}
+
+
+//
+// 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->specialdata = door;
+ sec->special = 0;
+
+ door->thinker.function.acp1 = (actionf_p1)T_VerticalDoor;
+ door->sector = sec;
+ door->direction = 0;
+ door->type = normal;
+ door->speed = VDOORSPEED;
+ door->topcountdown = 30 * 35;
+}
+
+//
+// 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->specialdata = door;
+ 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;
+}
+
+
+
+// UNUSED
+// Separate into p_slidoor.c?
+
+#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->specialdata = 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
generated by cgit v1.2.3 (git 2.25.1) at 2024-06-26 04:19:04 +0000