8cc169cb28
git-svn-id: svn://svn.rockbox.org/rockbox/trunk@21857 a1c6a512-1295-4272-9138-f99709370657
1035 lines
34 KiB
C
1035 lines
34 KiB
C
/* 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
|
|
*
|
|
* 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"
|
|
|
|
#include "rockmacros.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 = §ors[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 = §ors[sec->nextsec];
|
|
if (sec->nextsec==-1) // if all thinkers ahead are done too
|
|
{
|
|
while (sec->prevsec!=-1) // clear all locks
|
|
{
|
|
sec->stairlock = 0;
|
|
sec = §ors[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 = §ors[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);
|
|
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 = §ors[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 = §ors[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);
|
|
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);
|
|
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 = §ors[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);
|
|
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);
|
|
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 = §ors[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);
|
|
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;
|
|
}
|