//
// EV_DoCeiling
// Move a ceiling up/down and all around!
//
// [RH] Added tag, speed, speed2, height, crush, silent, change params
BOOL EV_DoCeiling (DCeiling::ECeiling type, line_t *line,
int tag, fixed_t speed, fixed_t speed2, fixed_t height,
bool crush, int silent, int change)
{
int secnum;
BOOL rtn;
sector_t* sec;
DCeiling* ceiling;
BOOL manual = false;
fixed_t targheight = 0;
rtn = false;
// check if a manual trigger, if so do just the sector on the backside
if (tag == 0)
{
if (!line || !(sec = line->backsector))
return rtn;
secnum = sec-sectors;
manual = true;
// [RH] Hack to let manual crushers be retriggerable, too
tag ^= secnum | 0x1000000;
P_ActivateInStasisCeiling (tag);
goto manual_ceiling;
}
// Reactivate in-stasis ceilings...for certain types.
// This restarts a crusher after it has been stopped
if (type == DCeiling::ceilCrushAndRaise)
{
P_ActivateInStasisCeiling (tag);
}
secnum = -1;
// affects all sectors with the same tag as the linedef
while ((secnum = P_FindSectorFromTag (tag, secnum)) >= 0)
{
sec = §ors[secnum];
manual_ceiling:
// if ceiling already moving, don't start a second function on it
if (sec->ceilingdata)
continue;
// new door thinker
rtn = 1;
ceiling = new DCeiling (sec, speed, speed2, silent);
switch (type)
{
case DCeiling::ceilCrushAndRaise:
case DCeiling::ceilCrushRaiseAndStay:
ceiling->m_TopHeight = sec->ceilingheight;
case DCeiling::ceilLowerAndCrush:
ceiling->m_Crush = crush;
targheight = ceiling->m_BottomHeight = sec->floorheight + 8*FRACUNIT;
ceiling->m_Direction = -1;
break;
case DCeiling::ceilRaiseToHighest:
targheight = ceiling->m_TopHeight = P_FindHighestCeilingSurrounding (sec);
ceiling->m_Direction = 1;
break;
case DCeiling::ceilLowerByValue:
targheight = ceiling->m_BottomHeight = sec->ceilingheight - height;
ceiling->m_Direction = -1;
break;
case DCeiling::ceilRaiseByValue:
targheight = ceiling->m_TopHeight = sec->ceilingheight + height;
ceiling->m_Direction = 1;
break;
case DCeiling::ceilMoveToValue:
{
int diff = height - sec->ceilingheight;
if (diff < 0) {
targheight = ceiling->m_BottomHeight = height;
ceiling->m_Direction = -1;
} else {
targheight = ceiling->m_TopHeight = height;
ceiling->m_Direction = 1;
}
}
break;
case DCeiling::ceilLowerToHighestFloor:
targheight = ceiling->m_BottomHeight = P_FindHighestFloorSurrounding (sec);
ceiling->m_Direction = -1;
break;
case DCeiling::ceilRaiseToHighestFloor:
targheight = ceiling->m_TopHeight = P_FindHighestFloorSurrounding (sec);
ceiling->m_Direction = 1;
break;
case DCeiling::ceilLowerInstant:
targheight = ceiling->m_BottomHeight = sec->ceilingheight - height;
ceiling->m_Direction = -1;
ceiling->m_Speed = height;
break;
case DCeiling::ceilRaiseInstant:
targheight = ceiling->m_TopHeight = sec->ceilingheight + height;
ceiling->m_Direction = 1;
ceiling->m_Speed = height;
break;
case DCeiling::ceilLowerToNearest:
targheight = ceiling->m_BottomHeight =
P_FindNextLowestCeiling (sec, sec->ceilingheight);
ceiling->m_Direction = 1;
break;
case DCeiling::ceilRaiseToNearest:
targheight = ceiling->m_TopHeight =
P_FindNextHighestCeiling (sec, sec->ceilingheight);
ceiling->m_Direction = 1;
break;
case DCeiling::ceilLowerToLowest:
targheight = ceiling->m_BottomHeight = P_FindLowestCeilingSurrounding (sec);
ceiling->m_Direction = -1;
break;
case DCeiling::ceilRaiseToLowest:
targheight = ceiling->m_TopHeight = P_FindLowestCeilingSurrounding (sec);
ceiling->m_Direction = -1;
break;
case DCeiling::ceilLowerToFloor:
targheight = ceiling->m_BottomHeight = sec->floorheight;
ceiling->m_Direction = -1;
break;
case DCeiling::ceilRaiseToFloor:
targheight = ceiling->m_TopHeight = sec->floorheight;
ceiling->m_Direction = 1;
break;
case DCeiling::ceilLowerToHighest:
targheight = ceiling->m_BottomHeight = P_FindHighestCeilingSurrounding (sec);
ceiling->m_Direction = -1;
break;
case DCeiling::ceilLowerByTexture:
targheight = ceiling->m_BottomHeight =
sec->ceilingheight - P_FindShortestUpperAround (secnum);
ceiling->m_Direction = -1;
break;
case DCeiling::ceilRaiseByTexture:
targheight = ceiling->m_TopHeight =
sec->ceilingheight + P_FindShortestUpperAround (secnum);
ceiling->m_Direction = 1;
break;
case DCeiling::genCeilingChg0: // denis - fixme - will these need code?
case DCeiling::genCeilingChgT:
case DCeiling::genCeilingChg:
break;
}
ceiling->m_Tag = tag;
ceiling->m_Type = type;
// set texture/type change properties
if (change & 3) // if a texture change is indicated
{
if (change & 4) // if a numeric model change
{
sector_t *sec;
//jff 5/23/98 find model with floor at target height if target
//is a floor type
sec = (type == DCeiling::ceilRaiseToHighest ||
type == DCeiling::ceilRaiseToFloor ||
type == DCeiling::ceilLowerToHighest ||
type == DCeiling::ceilLowerToFloor) ?
P_FindModelFloorSector (targheight, secnum) :
P_FindModelCeilingSector (targheight, secnum);
if (sec)
{
ceiling->m_Texture = sec->ceilingpic;
switch (change & 3)
{
case 1: // type is zeroed
ceiling->m_NewSpecial = 0;
ceiling->m_Type = DCeiling::genCeilingChg0;
break;
case 2: // type is copied
ceiling->m_NewSpecial = sec->special;
ceiling->m_Type = DCeiling::genCeilingChgT;
break;
case 3: // type is left alone
ceiling->m_Type = DCeiling::genCeilingChg;
break;
}
}
}
else if (line) // else if a trigger model change
{
ceiling->m_Texture = line->frontsector->ceilingpic;
switch (change & 3)
{
case 1: // type is zeroed
ceiling->m_NewSpecial = 0;
ceiling->m_Type = DCeiling::genCeilingChg0;
break;
case 2: // type is copied
ceiling->m_NewSpecial = line->frontsector->special;
ceiling->m_Type = DCeiling::genCeilingChgT;
break;
case 3: // type is left alone
ceiling->m_Type = DCeiling::genCeilingChg;
break;
}
}
}
ceiling->PlayCeilingSound ();
if (manual)
return rtn;
}
return rtn;
}
//
// EV_DoCeiling
// Move a ceiling up/down and all around!
//
int
EV_DoCeiling
( line_t* line,
ceiling_e type )
{
int secnum;
int rtn;
sector_t* sec;
ceiling_t* ceiling;
secnum = -1;
rtn = 0;
// Reactivate in-stasis ceilings...for certain types.
switch(type)
{
case fastCrushAndRaise:
case silentCrushAndRaise:
case crushAndRaise:
P_ActivateInStasisCeiling(line);
default:
break;
}
while ((secnum = P_FindSectorFromLineTag(line,secnum)) >= 0)
{
sec = §ors[secnum];
if (sec->specialdata)
continue;
// new door thinker
rtn = 1;
ceiling = Z_Malloc (sizeof(*ceiling), PU_LEVSPEC, 0);
P_AddThinker (&ceiling->thinker);
sec->specialdata = ceiling;
ceiling->thinker.function.acp1 = (actionf_p1)T_MoveCeiling;
ceiling->sector = sec;
ceiling->crush = false;
switch(type)
{
case fastCrushAndRaise:
ceiling->crush = true;
ceiling->topheight = sec->ceilingheight;
ceiling->bottomheight = sec->floorheight + (8*FRACUNIT);
ceiling->direction = -1;
ceiling->speed = CEILSPEED * 2;
break;
case silentCrushAndRaise:
case crushAndRaise:
ceiling->crush = true;
ceiling->topheight = sec->ceilingheight;
case lowerAndCrush:
case lowerToFloor:
ceiling->bottomheight = sec->floorheight;
if (type != lowerToFloor)
ceiling->bottomheight += 8*FRACUNIT;
ceiling->direction = -1;
ceiling->speed = CEILSPEED;
break;
case raiseToHighest:
ceiling->topheight = P_FindHighestCeilingSurrounding(sec);
ceiling->direction = 1;
ceiling->speed = CEILSPEED;
break;
}
ceiling->tag = sec->tag;
ceiling->type = type;
P_AddActiveCeiling(ceiling);
}
return rtn;
}
//
// EV_DoCeiling
// Move a ceiling up/down and all around!
//
// haleyjd 10/04/10: [STRIFE] Changes:
// * Fast crushers were made 2x as fast.
// * lowerAndCrush was apparently "fixed" to actually crush, and was also
// altered to lower all the way to the floor rather than remain 8 above.
// * silentCrushAndRaise and crushAndRaise no longer crush.
int
EV_DoCeiling
( line_t* line,
ceiling_e type )
{
int secnum;
int rtn;
sector_t* sec;
ceiling_t* ceiling;
secnum = -1;
rtn = 0;
// Reactivate in-stasis ceilings...for certain types.
switch(type)
{
case fastCrushAndRaise:
case silentCrushAndRaise:
case crushAndRaise:
P_ActivateInStasisCeiling(line);
default:
break;
}
while ((secnum = P_FindSectorFromLineTag(line,secnum)) >= 0)
{
sec = §ors[secnum];
if (sec->specialdata)
continue;
// new door thinker
rtn = 1;
ceiling = Z_Malloc (sizeof(*ceiling), PU_LEVSPEC, 0);
P_AddThinker (&ceiling->thinker);
sec->specialdata = ceiling;
ceiling->thinker.function.acp1 = (actionf_p1)T_MoveCeiling;
ceiling->sector = sec;
ceiling->crush = false;
switch(type)
{
case fastCrushAndRaise:
// [STRIFE]: Speed of fast crushers increased by 2x!
ceiling->crush = true;
ceiling->topheight = sec->ceilingheight;
ceiling->bottomheight = sec->floorheight + (8*FRACUNIT);
ceiling->direction = -1;
ceiling->speed = CEILSPEED * 4; // [STRIFE] Was CEILSPEED * 2
break;
case lowerAndCrush:
// [STRIFE] lowerAndCrush doesn't seem to have crushed in DOOM,
// but it was certainly made to do so in Strife! It is also
// changed to lower all the way to the floor.
ceiling->crush = 1;
ceiling->direction = -1;
ceiling->speed = CEILSPEED;
ceiling->bottomheight = sec->floorheight;
break;
case silentCrushAndRaise:
case crushAndRaise:
// [STRIFE] haleyjd 20130209: Turns out these types do NOT crush
// in Strife... yeah, that makes a lot of sense. Thanks to Gez for
// having detected this difference.
//ceiling->crush = true;
ceiling->topheight = sec->ceilingheight;
case lowerToFloor:
ceiling->bottomheight = sec->floorheight;
if (type != lowerToFloor)
ceiling->bottomheight += 8*FRACUNIT;
ceiling->direction = -1;
ceiling->speed = CEILSPEED;
break;
case raiseToHighest:
ceiling->topheight = P_FindHighestCeilingSurrounding(sec);
ceiling->direction = 1;
ceiling->speed = CEILSPEED;
break;
}
ceiling->tag = sec->tag;
ceiling->type = type;
P_AddActiveCeiling(ceiling);
}
return rtn;
}
//
// EV_DoCeiling
//
// Move a ceiling up/down or start a crusher
//
// Passed the linedef activating the function and the type of function desired
// returns true if a thinker started
//
int EV_DoCeiling
(line_t* line,
ceiling_e type)
{
int secnum;
int rtn;
sector_t* sec;
ceiling_t* ceiling;
secnum = -1;
rtn = 0;
// Reactivate in-stasis ceilings...for certain types.
// This restarts a crusher after it has been stopped
switch (type)
{
case fastCrushAndRaise:
case silentCrushAndRaise:
case crushAndRaise:
//jff 4/5/98 return if activated
rtn = P_ActivateInStasisCeiling(line);
default:
break;
}
// affects all sectors with the same tag as the linedef
while ((secnum = P_FindSectorFromLineTag(line, secnum)) >= 0)
{
sec = §ors[secnum];
// if ceiling already moving, don't start a second function on it
if (P_SectorActive(ceiling_special, sec)) //jff 2/22/98
continue;
// create a new ceiling thinker
rtn = 1;
ceiling = Z_Malloc(sizeof(*ceiling), PU_LEVSPEC, 0);
P_AddThinker(&ceiling->thinker);
sec->ceilingdata = ceiling; //jff 2/22/98
ceiling->thinker.function = T_MoveCeiling;
ceiling->sector = sec;
ceiling->crush = false;
// setup ceiling structure according to type of function
switch (type)
{
case fastCrushAndRaise:
ceiling->crush = true;
ceiling->topheight = sec->ceilingheight;
ceiling->bottomheight = sec->floorheight + (8 * FRACUNIT);
ceiling->direction = -1;
ceiling->speed = CEILSPEED * 2;
break;
case silentCrushAndRaise:
case crushAndRaise:
ceiling->crush = true;
ceiling->topheight = sec->ceilingheight;
case lowerAndCrush:
case lowerToFloor:
ceiling->bottomheight = sec->floorheight;
if (type != lowerToFloor)
ceiling->bottomheight += 8 * FRACUNIT;
ceiling->direction = -1;
ceiling->speed = CEILSPEED;
break;
case raiseToHighest:
ceiling->topheight = P_FindHighestCeilingSurrounding(sec);
ceiling->direction = 1;
ceiling->speed = CEILSPEED;
break;
case lowerToLowest:
ceiling->bottomheight = P_FindLowestCeilingSurrounding(sec);
ceiling->direction = -1;
ceiling->speed = CEILSPEED;
break;
case lowerToMaxFloor:
ceiling->bottomheight = P_FindHighestFloorSurrounding(sec);
ceiling->direction = -1;
ceiling->speed = CEILSPEED;
break;
default:
break;
}
// add the ceiling to the active list
ceiling->tag = sec->tag;
ceiling->type = type;
P_AddActiveCeiling(ceiling);
}
return rtn;
}
int EV_OpenPillar(line_t *line, byte *args)
{
int secnum;
sector_t *sec;
pillar_t *pillar;
int rtn;
rtn = 0;
secnum = -1;
while((secnum = P_FindSectorFromTag(args[0], secnum)) >= 0)
{
sec = §ors[secnum];
if(sec->specialdata)
continue; // already moving
if(sec->floorheight != sec->ceilingheight)
{ // pillar isn't closed
continue;
}
rtn = 1;
pillar = Z_Malloc(sizeof(*pillar), PU_LEVSPEC, 0);
sec->specialdata = pillar;
P_AddThinker(&pillar->thinker);
pillar->thinker.function = T_BuildPillar;
pillar->sector = sec;
if(!args[2])
{
pillar->floordest = P_FindLowestFloorSurrounding(sec);
}
else
{
pillar->floordest = sec->floorheight-(args[2]<<FRACBITS);
}
if(!args[3])
{
pillar->ceilingdest = P_FindHighestCeilingSurrounding(sec);
}
else
{
pillar->ceilingdest = sec->ceilingheight+(args[3]<<FRACBITS);
}
if(sec->floorheight-pillar->floordest >= pillar->ceilingdest-
sec->ceilingheight)
{
pillar->floorSpeed = args[1]*(FRACUNIT/8);
pillar->ceilingSpeed = FixedMul(sec->ceilingheight-
pillar->ceilingdest, FixedDiv(pillar->floorSpeed,
pillar->floordest-sec->floorheight));
}
else
{
pillar->ceilingSpeed = args[1]*(FRACUNIT/8);
pillar->floorSpeed = FixedMul(pillar->floordest-sec->floorheight,
FixedDiv(pillar->ceilingSpeed, sec->ceilingheight-
pillar->ceilingdest));
}
pillar->direction = -1; // open the pillar
SN_StartSequence((mobj_t *)&pillar->sector->soundorg,
SEQ_PLATFORM+pillar->sector->seqType);
}
return rtn;
}
//
// EV_DoCeiling
//
// Move a ceiling up/down or start a crusher
//
// Passed the linedef activating the function and the type of function desired
// returns true if a thinker started
//
int EV_DoCeiling(const line_t *line, ceiling_e type)
{
int secnum = -1;
int rtn = 0;
int noise = CNOISE_NORMAL; // haleyjd 09/28/06
sector_t *sec;
CeilingThinker *ceiling;
// Reactivate in-stasis ceilings...for certain types.
// This restarts a crusher after it has been stopped
switch(type)
{
case fastCrushAndRaise:
case silentCrushAndRaise:
case crushAndRaise:
//jff 4/5/98 return if activated
rtn = P_ActivateInStasisCeiling(line, line->tag);
default:
break;
}
// affects all sectors with the same tag as the linedef
while((secnum = P_FindSectorFromLineTag(line,secnum)) >= 0)
{
sec = §ors[secnum];
// if ceiling already moving, don't start a second function on it
if(P_SectorActive(ceiling_special, sec)) //jff 2/22/98
continue;
// create a new ceiling thinker
rtn = 1;
ceiling = new CeilingThinker;
ceiling->addThinker();
sec->ceilingdata = ceiling; //jff 2/22/98
ceiling->sector = sec;
ceiling->crush = -1;
ceiling->crushflags = 0; // ioanch 20160305
// setup ceiling structure according to type of function
switch(type)
{
case fastCrushAndRaise:
ceiling->crush = 10;
ceiling->topheight = sec->ceilingheight;
ceiling->bottomheight = sec->floorheight + (8*FRACUNIT);
ceiling->direction = plat_down;
ceiling->speed = CEILSPEED * 2;
break;
case silentCrushAndRaise:
noise = CNOISE_SEMISILENT;
case crushAndRaise:
ceiling->crush = 10;
ceiling->topheight = sec->ceilingheight;
case lowerAndCrush:
case lowerToFloor:
ceiling->bottomheight = sec->floorheight;
if(type != lowerToFloor)
ceiling->bottomheight += 8*FRACUNIT;
ceiling->direction = plat_down;
ceiling->speed = CEILSPEED;
break;
case raiseToHighest:
ceiling->topheight = P_FindHighestCeilingSurrounding(sec);
ceiling->direction = plat_up;
ceiling->speed = CEILSPEED;
break;
case lowerToLowest:
ceiling->bottomheight = P_FindLowestCeilingSurrounding(sec);
ceiling->direction = plat_down;
ceiling->speed = CEILSPEED;
break;
case lowerToMaxFloor:
ceiling->bottomheight = P_FindHighestFloorSurrounding(sec);
ceiling->direction = plat_down;
ceiling->speed = CEILSPEED;
break;
default:
break;
}
// add the ceiling to the active list
ceiling->tag = sec->tag;
ceiling->type = type;
P_AddActiveCeiling(ceiling);
// haleyjd 09/28/06: sound sequences
P_CeilingSequence(ceiling->sector, noise);
}
return rtn;
}
//==================================================================
//
// EV_DoCeiling
// Move a ceiling up/down and all around!
//
//==================================================================
int EV_DoCeiling(line_t *line, byte *arg, ceiling_e type)
{
int secnum, rtn;
sector_t *sec;
ceiling_t *ceiling;
secnum = -1;
rtn = 0;
/* Old Ceiling stasis code
//
// Reactivate in-stasis ceilings...for certain types.
//
switch(type)
{
case CLEV_CRUSHANDRAISE:
P_ActivateInStasisCeiling(line);
default:
break;
}
*/
while((secnum = P_FindSectorFromTag(arg[0], secnum)) >= 0)
{
sec = §ors[secnum];
if(sec->specialdata)
continue;
//
// new door thinker
//
rtn = 1;
ceiling = Z_Malloc(sizeof(*ceiling), PU_LEVSPEC, 0);
P_AddThinker(&ceiling->thinker);
sec->specialdata = ceiling;
ceiling->thinker.function = T_MoveCeiling;
ceiling->sector = sec;
ceiling->crush = 0;
ceiling->speed = arg[1] * (FRACUNIT / 8);
switch (type)
{
case CLEV_CRUSHRAISEANDSTAY:
ceiling->crush = arg[2]; // arg[2] = crushing value
ceiling->topheight = sec->ceilingheight;
ceiling->bottomheight = sec->floorheight + (8 * FRACUNIT);
ceiling->direction = -1;
break;
case CLEV_CRUSHANDRAISE:
ceiling->topheight = sec->ceilingheight;
case CLEV_LOWERANDCRUSH:
ceiling->crush = arg[2]; // arg[2] = crushing value
case CLEV_LOWERTOFLOOR:
ceiling->bottomheight = sec->floorheight;
if(type != CLEV_LOWERTOFLOOR)
{
ceiling->bottomheight += 8 * FRACUNIT;
}
ceiling->direction = -1;
break;
case CLEV_RAISETOHIGHEST:
ceiling->topheight = P_FindHighestCeilingSurrounding(sec);
ceiling->direction = 1;
break;
case CLEV_LOWERBYVALUE:
ceiling->bottomheight = sec->ceilingheight - arg[2] * FRACUNIT;
ceiling->direction = -1;
break;
case CLEV_RAISEBYVALUE:
ceiling->topheight = sec->ceilingheight + arg[2] * FRACUNIT;
ceiling->direction = 1;
break;
case CLEV_MOVETOVALUETIMES8:
{
int destHeight = arg[2] * FRACUNIT * 8;
if(arg[3])
{
destHeight = -destHeight;
}
if(sec->ceilingheight <= destHeight)
{
ceiling->direction = 1;
ceiling->topheight = destHeight;
if(sec->ceilingheight == destHeight)
{
rtn = 0;
}
}
else if(sec->ceilingheight > destHeight)
{
ceiling->direction = -1;
ceiling->bottomheight = destHeight;
}
break;
}
default:
rtn = 0;
break;
}
ceiling->tag = sec->tag;
ceiling->type = type;
P_AddActiveCeiling(ceiling);
if(rtn)
{
SN_StartSequence((mobj_t *) &ceiling->sector->soundorg,
SEQ_PLATFORM + ceiling->sector->seqType);
}
}
return rtn;
}
//
// EV_DoCeiling
// Move a ceiling up/down and all around!
//
dboolean EV_DoCeiling(line_t *line, ceiling_e type)
{
int secnum = -1;
dboolean rtn = false;
sector_t *sec;
ceiling_t *ceiling;
// Reactivate in-stasis ceilings...for certain types.
switch (type)
{
case fastCrushAndRaise:
case silentCrushAndRaise:
case crushAndRaise:
rtn = P_ActivateInStasisCeiling(line);
default:
break;
}
while ((secnum = P_FindSectorFromLineTag(line, secnum)) >= 0)
{
sec = §ors[secnum];
if (P_SectorActive(ceiling_special, sec))
continue;
// new door thinker
rtn = true;
ceiling = Z_Malloc(sizeof(*ceiling), PU_LEVSPEC, 0);
memset(ceiling, 0, sizeof(*ceiling));
P_AddThinker(&ceiling->thinker);
sec->ceilingdata = ceiling;
ceiling->thinker.function = T_MoveCeiling;
ceiling->sector = sec;
ceiling->crush = false;
switch (type)
{
case fastCrushAndRaise:
ceiling->crush = true;
ceiling->topheight = sec->ceilingheight;
ceiling->bottomheight = sec->floorheight + 8 * FRACUNIT;
ceiling->direction = -1;
ceiling->speed = CEILSPEED * 2;
break;
case silentCrushAndRaise:
case crushAndRaise:
ceiling->crush = true;
ceiling->topheight = sec->ceilingheight;
case lowerAndCrush:
case lowerToFloor:
ceiling->bottomheight = sec->floorheight;
if (type != lowerToFloor && !(gamemission == doom2 && gamemap == 4 && canmodify))
ceiling->bottomheight += 8 * FRACUNIT;
ceiling->direction = -1;
ceiling->speed = CEILSPEED;
break;
case raiseToHighest:
ceiling->topheight = P_FindHighestCeilingSurrounding(sec);
ceiling->direction = 1;
ceiling->speed = CEILSPEED;
break;
case lowerToLowest:
ceiling->bottomheight = P_FindLowestCeilingSurrounding(sec);
ceiling->direction = -1;
ceiling->speed = CEILSPEED;
break;
case lowerToMaxFloor:
ceiling->bottomheight = P_FindHighestFloorSurrounding(sec);
ceiling->direction = -1;
ceiling->speed = CEILSPEED;
break;
}
ceiling->tag = sec->tag;
ceiling->type = type;
P_AddActiveCeiling(ceiling);
}
return rtn;
}
DPillar::DPillar (sector_t *sector, EPillar type, fixed_t speed,
fixed_t height, fixed_t height2, bool crush)
: DMover (sector), m_Status(init)
{
fixed_t ceilingdist, floordist;
sector->floordata = sector->ceilingdata = this;
fixed_t floorheight = P_FloorHeight(sector);
fixed_t ceilingheight = P_CeilingHeight(sector);
m_Type = type;
m_Crush = crush;
if (type == pillarBuild)
{
// If the pillar height is 0, have the floor and ceiling meet halfway
if (height == 0)
{
m_FloorTarget = m_CeilingTarget =
(ceilingheight - floorheight) / 2 + floorheight;
floordist = m_FloorTarget - floorheight;
}
else
{
m_FloorTarget = m_CeilingTarget = floorheight + height;
floordist = height;
}
ceilingdist = ceilingheight - m_CeilingTarget;
}
else
{
// If one of the heights is 0, figure it out based on the
// surrounding sectors
if (height == 0)
{
m_FloorTarget = P_FindLowestFloorSurrounding (sector);
floordist = floorheight - m_FloorTarget;
}
else
{
floordist = height;
m_FloorTarget = floorheight - height;
}
if (height2 == 0)
{
m_CeilingTarget = P_FindHighestCeilingSurrounding (sector);
ceilingdist = m_CeilingTarget - ceilingheight;
}
else
{
m_CeilingTarget = ceilingheight + height2;
ceilingdist = height2;
}
}
// The speed parameter applies to whichever part of the pillar
// travels the farthest. The other part's speed is then set so
// that it arrives at its destination at the same time.
if (floordist > ceilingdist)
{
m_FloorSpeed = speed;
m_CeilingSpeed = FixedDiv (FixedMul (speed, ceilingdist), floordist);
}
else
{
m_CeilingSpeed = speed;
m_FloorSpeed = FixedDiv (FixedMul (speed, floordist), ceilingdist);
}
PlayPillarSound();
}
