teambeef/dvr
0
0
Fork 0
mirror of https://github.com/DrBeef/DVR.git synced 2024-12-21 01:51:11 +00:00
Code Issues Projects Releases Packages Wiki Activity
dvr/app/jni/prboom/p_floor.c
Simon 9138ea77ab Initial Commit of all Source
2016-03-03 22:28:59 +00:00

1042 lines
33 KiB
C
Raw Blame History

/* Emacs style mode select -*- C++ -*-
*-----------------------------------------------------------------------------
*
*
* PrBoom: a Doom port merged with LxDoom and LSDLDoom
* based on BOOM, a modified and improved DOOM engine
* Copyright (C) 1999 by
* id Software, Chi Hoang, Lee Killough, Jim Flynn, Rand Phares, Ty Halderman
* Copyright (C) 1999-2000 by
* Jess Haas, Nicolas Kalkhof, Colin Phipps, Florian Schulze
* Copyright 2005, 2006 by
* Florian Schulze, Colin Phipps, Neil Stevens, Andrey Budko
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
* 02111-1307, USA.
*
* DESCRIPTION:
* General plane mover and floor mover action routines
* Floor motion, pure changer types, raising stairs. donuts, elevators
*
*-----------------------------------------------------------------------------*/
#include "doomstat.h"
#include "r_main.h"
#include "p_map.h"
#include "p_spec.h"
#include "p_tick.h"
#include "s_sound.h"
#include "sounds.h"
///////////////////////////////////////////////////////////////////////
//
// Plane (floor or ceiling), Floor motion and Elevator action routines
//
///////////////////////////////////////////////////////////////////////
//
// T_MovePlane()
//
// Move a plane (floor or ceiling) and check for crushing. Called
// every tick by all actions that move floors or ceilings.
//
// Passed the sector to move a plane in, the speed to move it at,
// the dest height it is to achieve, whether it crushes obstacles,
// whether it moves a floor or ceiling, and the direction up or down
// to move.
//
// Returns a result_e:
// ok - plane moved normally, has not achieved destination yet
// pastdest - plane moved normally and is now at destination height
// crushed - plane encountered an obstacle, is holding until removed
//
result_e T_MovePlane
( sector_t* sector,
fixed_t speed,
fixed_t dest,
boolean crush,
int floorOrCeiling,
int direction )
{
boolean flag;
fixed_t lastpos;
fixed_t destheight; //jff 02/04/98 used to keep floors/ceilings
// from moving thru each other
switch(floorOrCeiling)
{
case 0:
// Moving a floor
switch(direction)
{
case -1:
// Moving a floor down
if (sector->floorheight - speed < dest)
{
lastpos = sector->floorheight;
sector->floorheight = dest;
flag = P_CheckSector(sector,crush); //jff 3/19/98 use faster chk
if (flag == true)
{
sector->floorheight =lastpos;
P_CheckSector(sector,crush); //jff 3/19/98 use faster chk
}
return pastdest;
}
else
{
lastpos = sector->floorheight;
sector->floorheight -= speed;
flag = P_CheckSector(sector,crush); //jff 3/19/98 use faster chk
/* cph - make more compatible with original Doom, by
* reintroducing this code. This means floors can't lower
* if objects are stuck in the ceiling */
if ((flag == true) && comp[comp_floors]) {
sector->floorheight = lastpos;
P_ChangeSector(sector,crush);
return crushed;
}
}
break;
case 1:
// Moving a floor up
// jff 02/04/98 keep floor from moving thru ceilings
// jff 2/22/98 weaken check to demo_compatibility
destheight = (comp[comp_floors] || dest<sector->ceilingheight)?
dest : sector->ceilingheight;
if (sector->floorheight + speed > destheight)
{
lastpos = sector->floorheight;
sector->floorheight = destheight;
flag = P_CheckSector(sector,crush); //jff 3/19/98 use faster chk
if (flag == true)
{
sector->floorheight = lastpos;
P_CheckSector(sector,crush); //jff 3/19/98 use faster chk
}
return pastdest;
}
else
{
// crushing is possible
lastpos = sector->floorheight;
sector->floorheight += speed;
flag = P_CheckSector(sector,crush); //jff 3/19/98 use faster chk
if (flag == true)
{
/* jff 1/25/98 fix floor crusher */
if (comp[comp_floors]) {
if (crush == true)
return crushed;
}
sector->floorheight = lastpos;
P_CheckSector(sector,crush); //jff 3/19/98 use faster chk
return crushed;
}
}
break;
}
break;
case 1:
// moving a ceiling
switch(direction)
{
case -1:
// moving a ceiling down
// jff 02/04/98 keep ceiling from moving thru floors
// jff 2/22/98 weaken check to demo_compatibility
destheight = (comp[comp_floors] || dest>sector->floorheight)?
dest : sector->floorheight;
if (sector->ceilingheight - speed < destheight)
{
lastpos = sector->ceilingheight;
sector->ceilingheight = destheight;
flag = P_CheckSector(sector,crush); //jff 3/19/98 use faster chk
if (flag == true)
{
sector->ceilingheight = lastpos;
P_CheckSector(sector,crush); //jff 3/19/98 use faster chk
}
return pastdest;
}
else
{
// crushing is possible
lastpos = sector->ceilingheight;
sector->ceilingheight -= speed;
flag = P_CheckSector(sector,crush); //jff 3/19/98 use faster chk
if (flag == true)
{
if (crush == true)
return crushed;
sector->ceilingheight = lastpos;
P_CheckSector(sector,crush); //jff 3/19/98 use faster chk
return crushed;
}
}
break;
case 1:
// moving a ceiling up
if (sector->ceilingheight + speed > dest)
{
lastpos = sector->ceilingheight;
sector->ceilingheight = dest;
flag = P_CheckSector(sector,crush); //jff 3/19/98 use faster chk
if (flag == true)
{
sector->ceilingheight = lastpos;
P_CheckSector(sector,crush); //jff 3/19/98 use faster chk
}
return pastdest;
}
else
{
lastpos = sector->ceilingheight;
sector->ceilingheight += speed;
flag = P_CheckSector(sector,crush); //jff 3/19/98 use faster chk
}
break;
}
break;
}
return ok;
}
//
// T_MoveFloor()
//
// Move a floor to it's destination (up or down).
// Called once per tick for each moving floor.
//
// Passed a floormove_t structure that contains all pertinent info about the
// move. See P_SPEC.H for fields.
// No return.
//
// jff 02/08/98 all cases with labels beginning with gen added to support
// generalized line type behaviors.
void T_MoveFloor(floormove_t* floor)
{
result_e res;
res = T_MovePlane // move the floor
(
floor->sector,
floor->speed,
floor->floordestheight,
floor->crush,
0,
floor->direction
);
if (!(leveltime&7)) // make the floormove sound
S_StartSound((mobj_t *)&floor->sector->soundorg, sfx_stnmov);
if (res == pastdest) // if destination height is reached
{
if (floor->direction == 1) // going up
{
switch(floor->type) // handle texture/type changes
{
case donutRaise:
floor->sector->special = floor->newspecial;
floor->sector->floorpic = floor->texture;
break;
case genFloorChgT:
case genFloorChg0:
floor->sector->special = floor->newspecial;
//jff add to fix bug in special transfers from changes
floor->sector->oldspecial = floor->oldspecial;
//fall thru
case genFloorChg:
floor->sector->floorpic = floor->texture;
break;
default:
break;
}
}
else if (floor->direction == -1) // going down
{
switch(floor->type) // handle texture/type changes
{
case lowerAndChange:
floor->sector->special = floor->newspecial;
//jff add to fix bug in special transfers from changes
floor->sector->oldspecial = floor->oldspecial;
floor->sector->floorpic = floor->texture;
break;
case genFloorChgT:
case genFloorChg0:
floor->sector->special = floor->newspecial;
//jff add to fix bug in special transfers from changes
floor->sector->oldspecial = floor->oldspecial;
//fall thru
case genFloorChg:
floor->sector->floorpic = floor->texture;
break;
default:
break;
}
}
floor->sector->floordata = NULL; //jff 2/22/98
P_RemoveThinker(&floor->thinker);//remove this floor from list of movers
//jff 2/26/98 implement stair retrigger lockout while still building
// note this only applies to the retriggerable generalized stairs
if (floor->sector->stairlock==-2) // if this sector is stairlocked
{
sector_t *sec = floor->sector;
sec->stairlock=-1; // thinker done, promote lock to -1
while (sec->prevsec!=-1 && sectors[sec->prevsec].stairlock!=-2)
sec = &sectors[sec->prevsec]; // search for a non-done thinker
if (sec->prevsec==-1) // if all thinkers previous are done
{
sec = floor->sector; // search forward
while (sec->nextsec!=-1 && sectors[sec->nextsec].stairlock!=-2)
sec = &sectors[sec->nextsec];
if (sec->nextsec==-1) // if all thinkers ahead are done too
{
while (sec->prevsec!=-1) // clear all locks
{
sec->stairlock = 0;
sec = &sectors[sec->prevsec];
}
sec->stairlock = 0;
}
}
}
// make floor stop sound
S_StartSound((mobj_t *)&floor->sector->soundorg, sfx_pstop);
}
}
//
// T_MoveElevator()
//
// Move an elevator to it's destination (up or down)
// Called once per tick for each moving floor.
//
// Passed an elevator_t structure that contains all pertinent info about the
// move. See P_SPEC.H for fields.
// No return.
//
// jff 02/22/98 added to support parallel floor/ceiling motion
//
void T_MoveElevator(elevator_t* elevator)
{
result_e res;
if (elevator->direction<0) // moving down
{
res = T_MovePlane //jff 4/7/98 reverse order of ceiling/floor
(
elevator->sector,
elevator->speed,
elevator->ceilingdestheight,
0,
1, // move floor
elevator->direction
);
if (res==ok || res==pastdest) // jff 4/7/98 don't move ceil if blocked
T_MovePlane
(
elevator->sector,
elevator->speed,
elevator->floordestheight,
0,
0, // move ceiling
elevator->direction
);
}
else // up
{
res = T_MovePlane //jff 4/7/98 reverse order of ceiling/floor
(
elevator->sector,
elevator->speed,
elevator->floordestheight,
0,
0, // move ceiling
elevator->direction
);
if (res==ok || res==pastdest) // jff 4/7/98 don't move floor if blocked
T_MovePlane
(
elevator->sector,
elevator->speed,
elevator->ceilingdestheight,
0,
1, // move floor
elevator->direction
);
}
// make floor move sound
if (!(leveltime&7))
S_StartSound((mobj_t *)&elevator->sector->soundorg, sfx_stnmov);
if (res == pastdest) // if destination height acheived
{
elevator->sector->floordata = NULL; //jff 2/22/98
elevator->sector->ceilingdata = NULL; //jff 2/22/98
P_RemoveThinker(&elevator->thinker); // remove elevator from actives
// make floor stop sound
S_StartSound((mobj_t *)&elevator->sector->soundorg, sfx_pstop);
}
}
///////////////////////////////////////////////////////////////////////
//
// Floor motion linedef handlers
//
///////////////////////////////////////////////////////////////////////
//
// EV_DoFloor()
//
// Handle regular and extended floor types
//
// Passed the line that activated the floor and the type of floor motion
// Returns true if a thinker was created.
//
int EV_DoFloor
( line_t* line,
floor_e floortype )
{
int secnum;
int rtn;
int i;
sector_t* sec;
floormove_t* floor;
secnum = -1;
rtn = 0;
// move all floors with the same tag as the linedef
while ((secnum = P_FindSectorFromLineTag(line,secnum)) >= 0)
{
sec = &sectors[secnum];
// Don't start a second thinker on the same floor
if (P_SectorActive(floor_special,sec)) //jff 2/23/98
continue;
// new floor thinker
rtn = 1;
floor = Z_Malloc (sizeof(*floor), PU_LEVSPEC, 0);
memset(floor, 0, sizeof(*floor));
P_AddThinker (&floor->thinker);
sec->floordata = floor; //jff 2/22/98
floor->thinker.function = T_MoveFloor;
floor->type = floortype;
floor->crush = false;
// setup the thinker according to the linedef type
switch(floortype)
{
case lowerFloor:
floor->direction = -1;
floor->sector = sec;
floor->speed = FLOORSPEED;
floor->floordestheight = P_FindHighestFloorSurrounding(sec);
break;
//jff 02/03/30 support lowering floor by 24 absolute
case lowerFloor24:
floor->direction = -1;
floor->sector = sec;
floor->speed = FLOORSPEED;
floor->floordestheight = floor->sector->floorheight + 24 * FRACUNIT;
break;
//jff 02/03/30 support lowering floor by 32 absolute (fast)
case lowerFloor32Turbo:
floor->direction = -1;
floor->sector = sec;
floor->speed = FLOORSPEED*4;
floor->floordestheight = floor->sector->floorheight + 32 * FRACUNIT;
break;
case lowerFloorToLowest:
floor->direction = -1;
floor->sector = sec;
floor->speed = FLOORSPEED;
floor->floordestheight = P_FindLowestFloorSurrounding(sec);
break;
//jff 02/03/30 support lowering floor to next lowest floor
case lowerFloorToNearest:
floor->direction = -1;
floor->sector = sec;
floor->speed = FLOORSPEED;
floor->floordestheight =
P_FindNextLowestFloor(sec,floor->sector->floorheight);
break;
case turboLower:
floor->direction = -1;
floor->sector = sec;
floor->speed = FLOORSPEED * 4;
floor->floordestheight = P_FindHighestFloorSurrounding(sec);
if (floor->floordestheight != sec->floorheight)
floor->floordestheight += 8*FRACUNIT;
break;
case raiseFloorCrush:
floor->crush = true;
case raiseFloor:
floor->direction = 1;
floor->sector = sec;
floor->speed = FLOORSPEED;
floor->floordestheight = P_FindLowestCeilingSurrounding(sec);
if (floor->floordestheight > sec->ceilingheight)
floor->floordestheight = sec->ceilingheight;
floor->floordestheight -= (8*FRACUNIT)*(floortype == raiseFloorCrush);
break;
case raiseFloorTurbo:
floor->direction = 1;
floor->sector = sec;
floor->speed = FLOORSPEED*4;
floor->floordestheight = P_FindNextHighestFloor(sec,sec->floorheight);
break;
case raiseFloorToNearest:
floor->direction = 1;
floor->sector = sec;
floor->speed = FLOORSPEED;
floor->floordestheight = P_FindNextHighestFloor(sec,sec->floorheight);
break;
case raiseFloor24:
floor->direction = 1;
floor->sector = sec;
floor->speed = FLOORSPEED;
floor->floordestheight = floor->sector->floorheight + 24 * FRACUNIT;
break;
// jff 2/03/30 support straight raise by 32 (fast)
case raiseFloor32Turbo:
floor->direction = 1;
floor->sector = sec;
floor->speed = FLOORSPEED*4;
floor->floordestheight = floor->sector->floorheight + 32 * FRACUNIT;
break;
case raiseFloor512:
floor->direction = 1;
floor->sector = sec;
floor->speed = FLOORSPEED;
floor->floordestheight = floor->sector->floorheight + 512 * FRACUNIT;
break;
case raiseFloor24AndChange:
floor->direction = 1;
floor->sector = sec;
floor->speed = FLOORSPEED;
floor->floordestheight = floor->sector->floorheight + 24 * FRACUNIT;
sec->floorpic = line->frontsector->floorpic;
sec->special = line->frontsector->special;
//jff 3/14/98 transfer both old and new special
sec->oldspecial = line->frontsector->oldspecial;
break;
case raiseToTexture:
{
int minsize = INT_MAX;
side_t* side;
/* jff 3/13/98 no ovf */
if (!comp[comp_model]) minsize = 32000<<FRACBITS;
floor->direction = 1;
floor->sector = sec;
floor->speed = FLOORSPEED;
for (i = 0; i < sec->linecount; i++)
{
if (twoSided (secnum, i) )
{
side = getSide(secnum,i,0);
// jff 8/14/98 don't scan texture 0, its not real
if (side->bottomtexture > 0 ||
(comp[comp_model] && !side->bottomtexture))
if (textureheight[side->bottomtexture] < minsize)
minsize = textureheight[side->bottomtexture];
side = getSide(secnum,i,1);
// jff 8/14/98 don't scan texture 0, its not real
if (side->bottomtexture > 0 ||
(comp[comp_model] && !side->bottomtexture))
if (textureheight[side->bottomtexture] < minsize)
minsize = textureheight[side->bottomtexture];
}
}
if (comp[comp_model])
floor->floordestheight = floor->sector->floorheight + minsize;
else
{
floor->floordestheight =
(floor->sector->floorheight>>FRACBITS) + (minsize>>FRACBITS);
if (floor->floordestheight>32000)
floor->floordestheight = 32000; //jff 3/13/98 do not
floor->floordestheight<<=FRACBITS; // allow height overflow
}
}
break;
case lowerAndChange:
floor->direction = -1;
floor->sector = sec;
floor->speed = FLOORSPEED;
floor->floordestheight = P_FindLowestFloorSurrounding(sec);
floor->texture = sec->floorpic;
// jff 1/24/98 make sure floor->newspecial gets initialized
// in case no surrounding sector is at floordestheight
// --> should not affect compatibility <--
floor->newspecial = sec->special;
//jff 3/14/98 transfer both old and new special
floor->oldspecial = sec->oldspecial;
//jff 5/23/98 use model subroutine to unify fixes and handling
sec = P_FindModelFloorSector(floor->floordestheight,sec-sectors);
if (sec)
{
floor->texture = sec->floorpic;
floor->newspecial = sec->special;
//jff 3/14/98 transfer both old and new special
floor->oldspecial = sec->oldspecial;
}
break;
default:
break;
}
}
return rtn;
}
//
// EV_DoChange()
//
// Handle pure change types. These change floor texture and sector type
// by trigger or numeric model without moving the floor.
//
// The linedef causing the change and the type of change is passed
// Returns true if any sector changes
//
// jff 3/15/98 added to better support generalized sector types
//
int EV_DoChange
( line_t* line,
change_e changetype )
{
int secnum;
int rtn;
sector_t* sec;
sector_t* secm;
secnum = -1;
rtn = 0;
// change all sectors with the same tag as the linedef
while ((secnum = P_FindSectorFromLineTag(line,secnum)) >= 0)
{
sec = &sectors[secnum];
rtn = 1;
// handle trigger or numeric change type
switch(changetype)
{
case trigChangeOnly:
sec->floorpic = line->frontsector->floorpic;
sec->special = line->frontsector->special;
sec->oldspecial = line->frontsector->oldspecial;
break;
case numChangeOnly:
secm = P_FindModelFloorSector(sec->floorheight,secnum);
if (secm) // if no model, no change
{
sec->floorpic = secm->floorpic;
sec->special = secm->special;
sec->oldspecial = secm->oldspecial;
}
break;
default:
break;
}
}
return rtn;
}
/*
* EV_BuildStairs()
*
* Handles staircase building. A sequence of sectors chosen by algorithm
* rise at a speed indicated to a height that increases by the stepsize
* each step.
*
* Passed the linedef triggering the stairs and the type of stair rise
* Returns true if any thinkers are created
*
* cph 2001/09/21 - compatibility nightmares again
* There are three different ways this function has, during its history, stepped
* through all the stairs to be triggered by the single switch
* - original Doom used a linear P_FindSectorFromLineTag, but failed to preserve
* the index of the previous sector found, so instead it would restart its
* linear search from the last sector of the previous staircase
* - MBF/PrBoom with comp_stairs fail to emulate this, because their
* P_FindSectorFromLineTag is a chained hash table implementation. Instead they
* start following the hash chain from the last sector of the previous
* staircase, which will (probably) have the wrong tag, so they miss any further
* stairs
* - Boom fixed the bug, and MBF/PrBoom without comp_stairs work right
*/
static inline int P_FindSectorFromLineTagWithLowerBound
(line_t* l, int start, int min)
{
/* Emulate original Doom's linear lower-bounded P_FindSectorFromLineTag
* as needed */
do {
start = P_FindSectorFromLineTag(l,start);
} while (start >= 0 && start <= min);
return start;
}
int EV_BuildStairs
( line_t* line,
stair_e type )
{
/* cph 2001/09/22 - cleaned up this function to save my sanity. A separate
* outer loop index makes the logic much cleared, and local variables moved
* into the inner blocks helps too */
int ssec = -1;
int minssec = -1;
int rtn = 0;
// start a stair at each sector tagged the same as the linedef
while ((ssec = P_FindSectorFromLineTagWithLowerBound(line,ssec,minssec)) >= 0)
{
int secnum = ssec;
sector_t* sec = &sectors[secnum];
// don't start a stair if the first step's floor is already moving
if (!P_SectorActive(floor_special,sec)) { //jff 2/22/98
floormove_t* floor;
int texture, height;
fixed_t stairsize;
fixed_t speed;
int ok;
// create new floor thinker for first step
rtn = 1;
floor = Z_Malloc (sizeof(*floor), PU_LEVSPEC, 0);
memset(floor, 0, sizeof(*floor));
P_AddThinker (&floor->thinker);
sec->floordata = floor;
floor->thinker.function = T_MoveFloor;
floor->direction = 1;
floor->sector = sec;
floor->type = buildStair; //jff 3/31/98 do not leave uninited
// set up the speed and stepsize according to the stairs type
switch(type)
{
default: // killough -- prevent compiler warning
case build8:
speed = FLOORSPEED/4;
stairsize = 8*FRACUNIT;
if (!demo_compatibility)
floor->crush = false; //jff 2/27/98 fix uninitialized crush field
break;
case turbo16:
speed = FLOORSPEED*4;
stairsize = 16*FRACUNIT;
if (!demo_compatibility)
floor->crush = true; //jff 2/27/98 fix uninitialized crush field
break;
}
floor->speed = speed;
height = sec->floorheight + stairsize;
floor->floordestheight = height;
texture = sec->floorpic;
// Find next sector to raise
// 1. Find 2-sided line with same sector side[0] (lowest numbered)
// 2. Other side is the next sector to raise
// 3. Unless already moving, or different texture, then stop building
do
{
int i;
ok = 0;
for (i = 0;i < sec->linecount;i++)
{
sector_t* tsec = (sec->lines[i])->frontsector;
int newsecnum;
if ( !((sec->lines[i])->flags & ML_TWOSIDED) )
continue;
newsecnum = tsec-sectors;
if (secnum != newsecnum)
continue;
tsec = (sec->lines[i])->backsector;
if (!tsec) continue; //jff 5/7/98 if no backside, continue
newsecnum = tsec - sectors;
// if sector's floor is different texture, look for another
if (tsec->floorpic != texture)
continue;
/* jff 6/19/98 prevent double stepsize
* killough 10/98: intentionally left this way [MBF comment]
* cph 2001/02/06: stair bug fix should be controlled by comp_stairs,
* except if we're emulating MBF which perversly reverted the fix
*/
if (comp[comp_stairs] || (compatibility_level == mbf_compatibility))
height += stairsize; // jff 6/28/98 change demo compatibility
// if sector's floor already moving, look for another
if (P_SectorActive(floor_special,tsec)) //jff 2/22/98
continue;
/* cph - see comment above - do this iff we didn't do so above */
if (!comp[comp_stairs] && (compatibility_level != mbf_compatibility))
height += stairsize;
sec = tsec;
secnum = newsecnum;
// create and initialize a thinker for the next step
floor = Z_Malloc (sizeof(*floor), PU_LEVSPEC, 0);
memset(floor, 0, sizeof(*floor));
P_AddThinker (&floor->thinker);
sec->floordata = floor; //jff 2/22/98
floor->thinker.function = T_MoveFloor;
floor->direction = 1;
floor->sector = sec;
floor->speed = speed;
floor->floordestheight = height;
floor->type = buildStair; //jff 3/31/98 do not leave uninited
//jff 2/27/98 fix uninitialized crush field
if (!demo_compatibility)
floor->crush = type==build8? false : true;
ok = 1;
break;
}
} while(ok); // continue until no next step is found
}
/* killough 10/98: compatibility option */
if (comp[comp_stairs]) {
/* cph 2001/09/22 - emulate buggy MBF comp_stairs for demos, with logic
* reversed since we now have a separate outer loop index.
* DEMOSYNC - what about boom_compatibility_compatibility?
*/
if ((compatibility_level >= mbf_compatibility) && (compatibility_level <
prboom_3_compatibility)) ssec = secnum; /* Trash outer loop index */
else {
/* cph 2001/09/22 - now the correct comp_stairs - Doom used a linear
* search from the last secnum, so we set that as a minimum value and do
* a fresh tag search
*/
ssec = -1; minssec = secnum;
}
}
}
return rtn;
}
//
// EV_DoDonut()
//
// Handle donut function: lower pillar, raise surrounding pool, both to height,
// texture and type of the sector surrounding the pool.
//
// Passed the linedef that triggered the donut
// Returns whether a thinker was created
//
int EV_DoDonut(line_t* line)
{
sector_t* s1;
sector_t* s2;
sector_t* s3;
int secnum;
int rtn;
int i;
floormove_t* floor;
secnum = -1;
rtn = 0;
// do function on all sectors with same tag as linedef
while ((secnum = P_FindSectorFromLineTag(line,secnum)) >= 0)
{
s1 = &sectors[secnum]; // s1 is pillar's sector
// do not start the donut if the pillar is already moving
if (P_SectorActive(floor_special,s1)) //jff 2/22/98
continue;
s2 = getNextSector(s1->lines[0],s1); // s2 is pool's sector
if (!s2) continue; // note lowest numbered line around
// pillar must be two-sided
/* do not start the donut if the pool is already moving
* cph - DEMOSYNC - was !compatibility */
if (!comp[comp_floors] && P_SectorActive(floor_special,s2))
continue; //jff 5/7/98
// find a two sided line around the pool whose other side isn't the pillar
for (i = 0;i < s2->linecount;i++)
{
//jff 3/29/98 use true two-sidedness, not the flag
// killough 4/5/98: changed demo_compatibility to compatibility
if (comp[comp_model])
{
if ((!s2->lines[i]->flags & ML_TWOSIDED) ||
(s2->lines[i]->backsector == s1))
continue;
}
else if (!s2->lines[i]->backsector || s2->lines[i]->backsector == s1)
continue;
rtn = 1; //jff 1/26/98 no donut action - no switch change on return
s3 = s2->lines[i]->backsector; // s3 is model sector for changes
// Spawn rising slime
floor = Z_Malloc (sizeof(*floor), PU_LEVSPEC, 0);
memset(floor, 0, sizeof(*floor));
P_AddThinker (&floor->thinker);
s2->floordata = floor; //jff 2/22/98
floor->thinker.function = T_MoveFloor;
floor->type = donutRaise;
floor->crush = false;
floor->direction = 1;
floor->sector = s2;
floor->speed = FLOORSPEED / 2;
floor->texture = s3->floorpic;
floor->newspecial = 0;
floor->floordestheight = s3->floorheight;
// Spawn lowering donut-hole pillar
floor = Z_Malloc (sizeof(*floor), PU_LEVSPEC, 0);
memset(floor, 0, sizeof(*floor));
P_AddThinker (&floor->thinker);
s1->floordata = floor; //jff 2/22/98
floor->thinker.function = T_MoveFloor;
floor->type = lowerFloor;
floor->crush = false;
floor->direction = -1;
floor->sector = s1;
floor->speed = FLOORSPEED / 2;
floor->floordestheight = s3->floorheight;
break;
}
}
return rtn;
}
//
// EV_DoElevator
//
// Handle elevator linedef types
//
// Passed the linedef that triggered the elevator and the elevator action
//
// jff 2/22/98 new type to move floor and ceiling in parallel
//
int EV_DoElevator
( line_t* line,
elevator_e elevtype )
{
int secnum;
int rtn;
sector_t* sec;
elevator_t* elevator;
secnum = -1;
rtn = 0;
// act on all sectors with the same tag as the triggering linedef
while ((secnum = P_FindSectorFromLineTag(line,secnum)) >= 0)
{
sec = &sectors[secnum];
// If either floor or ceiling is already activated, skip it
if (sec->floordata || sec->ceilingdata) //jff 2/22/98
continue;
// create and initialize new elevator thinker
rtn = 1;
elevator = Z_Malloc (sizeof(*elevator), PU_LEVSPEC, 0);
memset(elevator, 0, sizeof(*elevator));
P_AddThinker (&elevator->thinker);
sec->floordata = elevator; //jff 2/22/98
sec->ceilingdata = elevator; //jff 2/22/98
elevator->thinker.function = T_MoveElevator;
elevator->type = elevtype;
// set up the fields according to the type of elevator action
switch(elevtype)
{
// elevator down to next floor
case elevateDown:
elevator->direction = -1;
elevator->sector = sec;
elevator->speed = ELEVATORSPEED;
elevator->floordestheight =
P_FindNextLowestFloor(sec,sec->floorheight);
elevator->ceilingdestheight =
elevator->floordestheight + sec->ceilingheight - sec->floorheight;
break;
// elevator up to next floor
case elevateUp:
elevator->direction = 1;
elevator->sector = sec;
elevator->speed = ELEVATORSPEED;
elevator->floordestheight =
P_FindNextHighestFloor(sec,sec->floorheight);
elevator->ceilingdestheight =
elevator->floordestheight + sec->ceilingheight - sec->floorheight;
break;
// elevator to floor height of activating switch's front sector
case elevateCurrent:
elevator->sector = sec;
elevator->speed = ELEVATORSPEED;
elevator->floordestheight = line->frontsector->floorheight;
elevator->ceilingdestheight =
elevator->floordestheight + sec->ceilingheight - sec->floorheight;
elevator->direction =
elevator->floordestheight>sec->floorheight? 1 : -1;
break;
default:
break;
}
}
return rtn;
}
Reference in a new issue View git blame Copy permalink