bool P_Scroll3dMidtex(sector_t *sector, int crush, fixed_t move, bool ceiling)
{
extsector_t::midtex::plane &scrollplane = ceiling? sector->e->Midtex.Ceiling : sector->e->Midtex.Floor;
// [Dusk] Mark down how much we change here
scrollplane.MoveDistance += move;
// First step: Change all lines' texture offsets
for(unsigned i = 0; i < scrollplane.AttachedLines.Size(); i++)
{
line_t *l = scrollplane.AttachedLines[i];
l->sidedef[0]->AddTextureYOffset(side_t::mid, move);
l->sidedef[1]->AddTextureYOffset(side_t::mid, move);
}
// Second step: Check all sectors whether the move is ok.
bool res = false;
for(unsigned i = 0; i < scrollplane.AttachedSectors.Size(); i++)
{
res |= P_ChangeSector(scrollplane.AttachedSectors[i], crush, move, 2, true);
}
return !res;
}
void T_FloorWaggle(waggle_t *waggle)
{
DENG_ASSERT(waggle != 0);
switch(waggle->state)
{
default:
case WS_STABLE:
if(waggle->ticker != -1)
{
if(!--waggle->ticker)
{
waggle->state = WS_REDUCE;
}
}
break;
case WS_EXPAND:
if((waggle->scale += waggle->scaleDelta) >= waggle->targetScale)
{
waggle->scale = waggle->targetScale;
waggle->state = WS_STABLE;
}
break;
case WS_REDUCE:
if((waggle->scale -= waggle->scaleDelta) <= 0)
{
// Remove.
P_SetDoublep(waggle->sector, DMU_FLOOR_HEIGHT, waggle->originalHeight);
P_ChangeSector(waggle->sector, 1 /*crush damage*/);
P_ToXSector(waggle->sector)->specialData = nullptr;
P_NotifySectorFinished(P_ToXSector(waggle->sector)->tag);
Thinker_Remove(&waggle->thinker);
return;
}
break;
}
waggle->accumulator += waggle->accDelta;
coord_t fh = waggle->originalHeight +
FLOATBOBOFFSET(((int) waggle->accumulator) & 63) * waggle->scale;
P_SetDoublep(waggle->sector, DMU_FLOOR_HEIGHT, fh);
P_SetDoublep(waggle->sector, DMU_FLOOR_TARGET_HEIGHT, fh);
P_SetFloatp(waggle->sector, DMU_FLOOR_SPEED, 0);
P_ChangeSector(waggle->sector, 1 /*crush damage*/);
}
void T_FloorWaggle(floorWaggle_t *waggle)
{
switch(waggle->state)
{
case WGLSTATE_EXPAND:
if((waggle->scale += waggle->scaleDelta)
>= waggle->targetScale)
{
waggle->scale = waggle->targetScale;
waggle->state = WGLSTATE_STABLE;
}
break;
case WGLSTATE_REDUCE:
if((waggle->scale -= waggle->scaleDelta) <= 0)
{ // Remove
waggle->sector->floorheight = waggle->originalHeight;
P_ChangeSector(waggle->sector, true);
waggle->sector->specialdata = NULL;
P_TagFinished(waggle->sector->tag);
P_RemoveThinker(&waggle->thinker);
return;
}
break;
case WGLSTATE_STABLE:
if(waggle->ticker != -1)
{
if(!--waggle->ticker)
{
waggle->state = WGLSTATE_REDUCE;
}
}
break;
}
waggle->accumulator += waggle->accDelta;
waggle->sector->floorheight = waggle->originalHeight
+FixedMul(FloatBobOffsets[(waggle->accumulator>>FRACBITS)&63],
waggle->scale);
P_ChangeSector(waggle->sector, true);
}
static bool MoveCeiling(sector_t *sector, int crush, fixed_t move)
{
sector->ceilingplane.ChangeHeight (move);
sector->ChangePlaneTexZ(sector_t::ceiling, move);
if (P_ChangeSector(sector, crush, move, 1, true)) return false;
// Don't let the ceiling go below the floor
if ((sector->ceilingplane.a | sector->ceilingplane.b |
sector->floorplane.a | sector->floorplane.b) == 0 &&
sector->GetPlaneTexZ(sector_t::floor) > sector->GetPlaneTexZ(sector_t::ceiling)) return false;
return true;
}
//
// Move a plane (floor or ceiling) and check for crushing
//
result_e T_MovePlane( sector_t* sector, fixed_t speed,fixed_t dest, boolean crush,int floorOrCeiling,int direction )
{
boolean flag;
fixed_t lastpos;
switch(floorOrCeiling)
{
case 0:
// FLOOR
switch(direction)
{
case -1:
// DOWN
if (sector->floorheight - speed < dest)
{
lastpos = sector->floorheight;
sector->floorheight = dest;
flag = P_ChangeSector(sector,crush);
if (flag == true)
{
sector->floorheight =lastpos;
P_ChangeSector(sector,crush);
//return crushed;
}
return pastdest;
}
else
{
lastpos = sector->floorheight;
sector->floorheight -= speed;
flag = P_ChangeSector(sector,crush);
if (flag == true)
{
sector->floorheight = lastpos;
P_ChangeSector(sector,crush);
return crushed;
}
}
break;
case 1:
// UP
if (sector->floorheight + speed > dest)
{
lastpos = sector->floorheight;
sector->floorheight = dest;
flag = P_ChangeSector(sector,crush);
if (flag == true)
{
sector->floorheight = lastpos;
P_ChangeSector(sector,crush);
//return crushed;
}
return pastdest;
}
else
{
// COULD GET CRUSHED
lastpos = sector->floorheight;
sector->floorheight += speed;
flag = P_ChangeSector(sector,crush);
if (flag == true)
{
if (crush == true)
return crushed;
sector->floorheight = lastpos;
P_ChangeSector(sector,crush);
return crushed;
}
}
break;
}
break;
case 1:
// CEILING
switch(direction)
{
case -1:
// DOWN
if (sector->ceilingheight - speed < dest)
{
lastpos = sector->ceilingheight;
sector->ceilingheight = dest;
flag = P_ChangeSector(sector,crush);
if (flag == true)
{
sector->ceilingheight = lastpos;
P_ChangeSector(sector,crush);
//return crushed;
}
return pastdest;
}
else
{
// COULD GET CRUSHED
lastpos = sector->ceilingheight;
sector->ceilingheight -= speed;
flag = P_ChangeSector(sector,crush);
if (flag == true)
{
if (crush == true)
return crushed;
sector->ceilingheight = lastpos;
P_ChangeSector(sector,crush);
return crushed;
}
}
break;
case 1:
// UP
if (sector->ceilingheight + speed > dest)
{
lastpos = sector->ceilingheight;
sector->ceilingheight = dest;
flag = P_ChangeSector(sector,crush);
if (flag == true)
{
sector->ceilingheight = lastpos;
P_ChangeSector(sector,crush);
//return crushed;
}
return pastdest;
}
else
{
lastpos = sector->ceilingheight;
sector->ceilingheight += speed;
flag = P_ChangeSector(sector,crush);
// UNUSED
}
break;
}
break;
}
return ok;
}
//
// CL_ResetSectors
//
void CL_ResetSectors (void)
{
for(size_t i = 0; i < real_plats.Size(); i++)
{
plat_pred_t *pred = &real_plats[i];
sector_t *sec = §ors[pred->secnum];
if(!sec->floordata && !sec->ceilingdata)
{
real_plats.Pop(real_plats[i]);
if (!real_plats.Size())
break;
continue;
}
// Pillars and elevators set both floordata and ceilingdata
if(sec->ceilingdata && sec->ceilingdata->IsA(RUNTIME_CLASS(DPillar)))
{
DPillar *Pillar = (DPillar *)sec->ceilingdata;
sec->floorheight = pred->floorheight;
sec->ceilingheight = pred->ceilingheight;
P_ChangeSector(sec, false);
Pillar->m_Type = (DPillar::EPillar)pred->Both.m_Type;
Pillar->m_FloorSpeed = pred->Both.m_FloorSpeed;
Pillar->m_CeilingSpeed = pred->Both.m_CeilingSpeed;
Pillar->m_FloorTarget = pred->Both.m_FloorTarget;
Pillar->m_CeilingTarget = pred->Both.m_CeilingTarget;
Pillar->m_Crush = pred->Both.m_Crush;
continue;
}
if (sec->ceilingdata && sec->ceilingdata->IsA(RUNTIME_CLASS(DElevator)))
{
DElevator *Elevator = (DElevator *)sec->ceilingdata;
sec->floorheight = pred->floorheight;
sec->ceilingheight = pred->ceilingheight;
P_ChangeSector(sec, false);
Elevator->m_Type = (DElevator::EElevator)pred->Both.m_Type;
Elevator->m_Direction = pred->Both.m_Direction;
Elevator->m_FloorDestHeight = pred->Both.m_FloorDestHeight;
Elevator->m_CeilingDestHeight = pred->Both.m_CeilingDestHeight;
Elevator->m_Speed = pred->Both.m_Speed;
continue;
}
if (sec->floordata && sec->floordata->IsA(RUNTIME_CLASS(DFloor)))
{
DFloor *Floor = (DFloor *)sec->floordata;
sec->floorheight = pred->floorheight;
P_ChangeSector(sec, false);
Floor->m_Type = (DFloor::EFloor)pred->Floor.m_Type;
Floor->m_Crush = pred->Floor.m_Crush;
Floor->m_Direction = pred->Floor.m_Direction;
Floor->m_NewSpecial = pred->Floor.m_NewSpecial;
Floor->m_Texture = pred->Floor.m_Texture;
Floor->m_FloorDestHeight = pred->Floor.m_FloorDestHeight;
Floor->m_Speed = pred->Floor.m_Speed;
Floor->m_ResetCount = pred->Floor.m_ResetCount;
Floor->m_OrgHeight = pred->Floor.m_OrgHeight;
Floor->m_Delay = pred->Floor.m_Delay;
Floor->m_PauseTime = pred->Floor.m_PauseTime;
Floor->m_StepTime = pred->Floor.m_StepTime;
Floor->m_PerStepTime = pred->Floor.m_PerStepTime;
}
if(sec->floordata && sec->floordata->IsA(RUNTIME_CLASS(DPlat)))
{
DPlat *Plat = (DPlat *)sec->floordata;
sec->floorheight = pred->floorheight;
P_ChangeSector(sec, false);
Plat->m_Speed = pred->Floor.m_Speed;
Plat->m_Low = pred->Floor.m_Low;
Plat->m_High = pred->Floor.m_High;
Plat->m_Wait = pred->Floor.m_Wait;
Plat->m_Count = pred->Floor.m_Count;
Plat->m_Status = (DPlat::EPlatState)pred->Floor.m_Status;
Plat->m_OldStatus = (DPlat::EPlatState)pred->Floor.m_OldStatus;
Plat->m_Crush = pred->Floor.m_Crush;
Plat->m_Tag = pred->Floor.m_Tag;
Plat->m_Type = (DPlat::EPlatType)pred->Floor.m_Type;
}
if (sec->ceilingdata && sec->ceilingdata->IsA(RUNTIME_CLASS(DCeiling)))
{
DCeiling *Ceiling = (DCeiling *)sec->ceilingdata;
sec->ceilingheight = pred->ceilingheight;
P_ChangeSector(sec, false);
Ceiling->m_Type = (DCeiling::ECeiling)pred->Ceiling.m_Type;
Ceiling->m_BottomHeight = pred->Ceiling.m_BottomHeight;
Ceiling->m_TopHeight = pred->Ceiling.m_TopHeight;
Ceiling->m_Speed = pred->Ceiling.m_Speed;
Ceiling->m_Speed1 = pred->Ceiling.m_Speed1;
Ceiling->m_Speed2 = pred->Ceiling.m_Speed2;
Ceiling->m_Crush = pred->Ceiling.m_Crush;
Ceiling->m_Silent = pred->Ceiling.m_Silent;
Ceiling->m_Direction = pred->Ceiling.m_Direction;
Ceiling->m_Texture = pred->Ceiling.m_Texture;
Ceiling->m_NewSpecial = pred->Ceiling.m_NewSpecial;
Ceiling->m_Tag = pred->Ceiling.m_Tag;
Ceiling->m_OldDirection = pred->Ceiling.m_OldDirection;
}
if (sec->ceilingdata && sec->ceilingdata->IsA(RUNTIME_CLASS(DDoor)))
{
DDoor *Door = (DDoor *)sec->ceilingdata;
sec->ceilingheight = pred->ceilingheight;
P_ChangeSector(sec, false);
Door->m_Type = (DDoor::EVlDoor)pred->Ceiling.m_Type;
Door->m_TopHeight = pred->Ceiling.m_TopHeight;
Door->m_Speed = pred->Ceiling.m_Speed;
Door->m_Direction = pred->Ceiling.m_Direction;
Door->m_TopWait = pred->Ceiling.m_TopWait;
Door->m_TopCountdown = pred->Ceiling.m_TopCountdown;
Door->m_Status = (DDoor::EVlDoorState)pred->Ceiling.m_Status;
Door->m_Line = pred->Ceiling.m_Line;
}
}
}
//
// Move a plane (floor or ceiling) and check for crushing
// [RH] Crush specifies the actual amount of crushing damage inflictable.
// (Use -1 to prevent it from trying to crush)
//
DMover::EResult DMover::MovePlane (fixed_t speed, fixed_t dest, bool crush,
int floorOrCeiling, int direction)
{
bool 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:
// FLOOR
switch (direction)
{
case -1:
// DOWN
if (m_Sector->floorheight - speed < dest)
{
lastpos = m_Sector->floorheight;
m_Sector->floorheight = dest;
flag = P_ChangeSector (m_Sector, crush);
if (flag == true)
{
m_Sector->floorheight = lastpos;
P_ChangeSector (m_Sector, crush);
//return crushed;
}
return pastdest;
}
else
{
lastpos = m_Sector->floorheight;
m_Sector->floorheight -= speed;
flag = P_ChangeSector (m_Sector, crush);
if (flag == true)
{
m_Sector->floorheight = lastpos;
P_ChangeSector (m_Sector, crush);
return crushed;
}
}
break;
case 1:
// UP
// jff 02/04/98 keep floor from moving thru ceilings
destheight = (dest < m_Sector->ceilingheight) ? dest : m_Sector->ceilingheight;
destheight = dest; // denis - fix coopuv30.lmp
if (m_Sector->floorheight + speed > destheight)
{
lastpos = m_Sector->floorheight;
m_Sector->floorheight = destheight;
flag = P_ChangeSector (m_Sector, crush);
if (flag == true)
{
m_Sector->floorheight = lastpos;
P_ChangeSector (m_Sector, crush);
//return crushed;
}
return pastdest;
}
else
{
// COULD GET CRUSHED
lastpos = m_Sector->floorheight;
m_Sector->floorheight += speed;
flag = P_ChangeSector (m_Sector, crush);
if (flag == true)
{
if (crush)
return crushed;
m_Sector->floorheight = lastpos;
P_ChangeSector (m_Sector, crush);
return crushed;
}
}
break;
}
break;
case 1:
// CEILING
switch(direction)
{
case -1:
// DOWN
// jff 02/04/98 keep ceiling from moving thru floors
destheight = (dest > m_Sector->floorheight) ? dest : m_Sector->floorheight;
destheight = dest; // denis - fix coopuv30.lmp
if (m_Sector->ceilingheight - speed < destheight)
{
lastpos = m_Sector->ceilingheight;
m_Sector->ceilingheight = destheight;
flag = P_ChangeSector (m_Sector, crush);
if (flag == true)
{
m_Sector->ceilingheight = lastpos;
P_ChangeSector (m_Sector, crush);
//return crushed;
}
return pastdest;
}
else
{
// COULD GET CRUSHED
lastpos = m_Sector->ceilingheight;
m_Sector->ceilingheight -= speed;
flag = P_ChangeSector (m_Sector, crush);
if (flag == true)
{
if (crush)
return crushed;
m_Sector->ceilingheight = lastpos;
P_ChangeSector (m_Sector, crush);
return crushed;
}
}
break;
case 1:
// UP
if (m_Sector->ceilingheight + speed > dest)
{
lastpos = m_Sector->ceilingheight;
m_Sector->ceilingheight = dest;
flag = P_ChangeSector (m_Sector, crush);
if (flag == true)
{
m_Sector->ceilingheight = lastpos;
P_ChangeSector (m_Sector, crush);
//return crushed;
}
return pastdest;
}
else
{
lastpos = m_Sector->ceilingheight;
m_Sector->ceilingheight += speed;
flag = P_ChangeSector (m_Sector, crush);
// UNUSED
#if 0
if (flag == true)
{
m_Sector->ceilingheight = lastpos;
P_ChangeSector (m_Sector, crush);
return crushed;
}
#endif
}
break;
}
break;
}
return ok;
}
//
// Move a plane (floor or ceiling) and check for crushing
// [RH] Crush specifies the actual amount of crushing damage inflictable.
// (Use -1 to prevent it from trying to crush)
// dest is the desired d value for the plane
//
DMover::EResult DMover::MovePlane (fixed_t speed, fixed_t dest, int crush,
int floorOrCeiling, int direction, bool hexencrush)
{
bool flag;
fixed_t lastpos;
fixed_t movedest;
fixed_t move;
//fixed_t destheight; //jff 02/04/98 used to keep floors/ceilings
// from moving thru each other
switch (floorOrCeiling)
{
case 0:
// FLOOR
lastpos = m_Sector->floorplane.d;
switch (direction)
{
case -1:
// DOWN
movedest = m_Sector->floorplane.GetChangedHeight (-speed);
if (movedest >= dest)
{
move = m_Sector->floorplane.HeightDiff (lastpos, dest);
if (!MoveAttached(crush, move, 0, true)) return crushed;
m_Sector->floorplane.d = dest;
flag = P_ChangeSector (m_Sector, crush, move, 0, false);
if (flag)
{
m_Sector->floorplane.d = lastpos;
P_ChangeSector (m_Sector, crush, -move, 0, true);
MoveAttached(crush, -move, 0, false);
}
else
{
m_Sector->ChangePlaneTexZ(sector_t::floor, move);
m_Sector->AdjustFloorClip ();
}
return pastdest;
}
else
{
if (!MoveAttached(crush, -speed, 0, true)) return crushed;
m_Sector->floorplane.d = movedest;
flag = P_ChangeSector (m_Sector, crush, -speed, 0, false);
if (flag)
{
m_Sector->floorplane.d = lastpos;
P_ChangeSector (m_Sector, crush, speed, 0, true);
MoveAttached(crush, speed, 0, false);
return crushed;
}
else
{
m_Sector->ChangePlaneTexZ(sector_t::floor, m_Sector->floorplane.HeightDiff (lastpos));
m_Sector->AdjustFloorClip ();
}
}
break;
case 1:
// UP
// jff 02/04/98 keep floor from moving thru ceilings
// [RH] not so easy with arbitrary planes
//destheight = (dest < m_Sector->ceilingheight) ? dest : m_Sector->ceilingheight;
if ((m_Sector->ceilingplane.a | m_Sector->ceilingplane.b |
m_Sector->floorplane.a | m_Sector->floorplane.b) == 0 &&
(!(i_compatflags2 & COMPATF2_FLOORMOVE) && -dest > m_Sector->ceilingplane.d))
{
dest = -m_Sector->ceilingplane.d;
}
movedest = m_Sector->floorplane.GetChangedHeight (speed);
if (movedest <= dest)
{
move = m_Sector->floorplane.HeightDiff (lastpos, dest);
if (!MoveAttached(crush, move, 0, true)) return crushed;
m_Sector->floorplane.d = dest;
flag = P_ChangeSector (m_Sector, crush, move, 0, false);
if (flag)
{
m_Sector->floorplane.d = lastpos;
P_ChangeSector (m_Sector, crush, -move, 0, true);
MoveAttached(crush, -move, 0, false);
}
else
{
m_Sector->ChangePlaneTexZ(sector_t::floor, move);
m_Sector->AdjustFloorClip ();
}
return pastdest;
}
else
{
if (!MoveAttached(crush, speed, 0, true)) return crushed;
m_Sector->floorplane.d = movedest;
// COULD GET CRUSHED
flag = P_ChangeSector (m_Sector, crush, speed, 0, false);
if (flag)
{
if (crush >= 0 && !hexencrush)
{
m_Sector->ChangePlaneTexZ(sector_t::floor, m_Sector->floorplane.HeightDiff (lastpos));
m_Sector->AdjustFloorClip ();
return crushed;
}
m_Sector->floorplane.d = lastpos;
P_ChangeSector (m_Sector, crush, -speed, 0, true);
MoveAttached(crush, -speed, 0, false);
return crushed;
}
m_Sector->ChangePlaneTexZ(sector_t::floor, m_Sector->floorplane.HeightDiff (lastpos));
m_Sector->AdjustFloorClip ();
}
break;
}
break;
case 1:
// CEILING
lastpos = m_Sector->ceilingplane.d;
switch (direction)
{
case -1:
// DOWN
// jff 02/04/98 keep ceiling from moving thru floors
// [RH] not so easy with arbitrary planes
//destheight = (dest > m_Sector->floorheight) ? dest : m_Sector->floorheight;
if ((m_Sector->ceilingplane.a | m_Sector->ceilingplane.b |
m_Sector->floorplane.a | m_Sector->floorplane.b) == 0 &&
(!(i_compatflags2 & COMPATF2_FLOORMOVE) && dest < -m_Sector->floorplane.d))
{
dest = -m_Sector->floorplane.d;
}
movedest = m_Sector->ceilingplane.GetChangedHeight (-speed);
if (movedest <= dest)
{
move = m_Sector->ceilingplane.HeightDiff (lastpos, dest);
if (!MoveAttached(crush, move, 1, true)) return crushed;
m_Sector->ceilingplane.d = dest;
flag = P_ChangeSector (m_Sector, crush, move, 1, false);
if (flag)
{
m_Sector->ceilingplane.d = lastpos;
P_ChangeSector (m_Sector, crush, -move, 1, true);
MoveAttached(crush, -move, 1, false);
}
else
{
m_Sector->ChangePlaneTexZ(sector_t::ceiling, move);
}
return pastdest;
}
else
{
if (!MoveAttached(crush, -speed, 1, true)) return crushed;
m_Sector->ceilingplane.d = movedest;
// COULD GET CRUSHED
flag = P_ChangeSector (m_Sector, crush, -speed, 1, false);
if (flag)
{
if (crush >= 0 && !hexencrush)
{
m_Sector->ChangePlaneTexZ(sector_t::ceiling, m_Sector->ceilingplane.HeightDiff (lastpos));
return crushed;
}
m_Sector->ceilingplane.d = lastpos;
P_ChangeSector (m_Sector, crush, speed, 1, true);
MoveAttached(crush, speed, 1, false);
return crushed;
}
m_Sector->ChangePlaneTexZ(sector_t::ceiling, m_Sector->ceilingplane.HeightDiff (lastpos));
}
break;
case 1:
// UP
movedest = m_Sector->ceilingplane.GetChangedHeight (speed);
if (movedest >= dest)
{
move = m_Sector->ceilingplane.HeightDiff (lastpos, dest);
if (!MoveAttached(crush, move, 1, true)) return crushed;
m_Sector->ceilingplane.d = dest;
flag = P_ChangeSector (m_Sector, crush, move, 1, false);
if (flag)
{
m_Sector->ceilingplane.d = lastpos;
P_ChangeSector (m_Sector, crush, move, 1, true);
MoveAttached(crush, move, 1, false);
}
else
{
m_Sector->ChangePlaneTexZ(sector_t::ceiling, move);
}
return pastdest;
}
else
{
if (!MoveAttached(crush, speed, 1, true)) return crushed;
m_Sector->ceilingplane.d = movedest;
flag = P_ChangeSector (m_Sector, crush, speed, 1, false);
if (flag)
{
m_Sector->ceilingplane.d = lastpos;
P_ChangeSector (m_Sector, crush, -speed, 1, true);
MoveAttached(crush, -speed, 1, false);
return crushed;
}
m_Sector->ChangePlaneTexZ(sector_t::ceiling, m_Sector->ceilingplane.HeightDiff (lastpos));
}
break;
}
break;
}
return ok;
}
//==================================================================
//
// Move a plane (floor or ceiling) and check for crushing
//
//==================================================================
result_e T_MovePlane(sector_t *sector,fixed_t speed,
fixed_t dest, int crush,int floorOrCeiling,int direction)
{
boolean flag;
fixed_t lastpos;
switch(floorOrCeiling)
{
case 0: // FLOOR
switch(direction)
{
case -1: // DOWN
if (sector->floorheight - speed < dest)
{
lastpos = sector->floorheight;
sector->floorheight = dest;
flag = P_ChangeSector(sector,crush);
if (flag == true)
{
sector->floorheight =lastpos;
P_ChangeSector(sector,crush);
//return RES_CRUSHED;
}
return RES_PASTDEST;
}
else
{
lastpos = sector->floorheight;
sector->floorheight -= speed;
flag = P_ChangeSector(sector,crush);
if (flag == true)
{
sector->floorheight = lastpos;
P_ChangeSector(sector,crush);
return RES_CRUSHED;
}
}
break;
case 1: // UP
if (sector->floorheight + speed > dest)
{
lastpos = sector->floorheight;
sector->floorheight = dest;
flag = P_ChangeSector(sector,crush);
if (flag == true)
{
sector->floorheight = lastpos;
P_ChangeSector(sector,crush);
//return RES_CRUSHED;
}
return RES_PASTDEST;
}
else // COULD GET CRUSHED
{
lastpos = sector->floorheight;
sector->floorheight += speed;
flag = P_ChangeSector(sector,crush);
if (flag == true)
{
//if (crush == true)
//{
// return RES_CRUSHED;
//}
sector->floorheight = lastpos;
P_ChangeSector(sector,crush);
return RES_CRUSHED;
}
}
break;
}
break;
case 1: // CEILING
switch(direction)
{
case -1: // DOWN
if (sector->ceilingheight - speed < dest)
{
lastpos = sector->ceilingheight;
sector->ceilingheight = dest;
flag = P_ChangeSector(sector,crush);
if (flag == true)
{
sector->ceilingheight = lastpos;
P_ChangeSector(sector,crush);
//return RES_CRUSHED;
}
return RES_PASTDEST;
}
else // COULD GET CRUSHED
{
lastpos = sector->ceilingheight;
sector->ceilingheight -= speed;
flag = P_ChangeSector(sector,crush);
if (flag == true)
{
//if (crush == true)
//{
// return RES_CRUSHED;
//}
sector->ceilingheight = lastpos;
P_ChangeSector(sector,crush);
return RES_CRUSHED;
}
}
break;
case 1: // UP
if (sector->ceilingheight + speed > dest)
{
lastpos = sector->ceilingheight;
sector->ceilingheight = dest;
flag = P_ChangeSector(sector,crush);
if (flag == true)
{
sector->ceilingheight = lastpos;
P_ChangeSector(sector,crush);
//return RES_CRUSHED;
}
return RES_PASTDEST;
}
else
{
lastpos = sector->ceilingheight;
sector->ceilingheight += speed;
flag = P_ChangeSector(sector,crush);
#if 0
if (flag == true)
{
sector->ceilingheight = lastpos;
P_ChangeSector(sector,crush);
return RES_CRUSHED;
}
#endif
}
break;
}
break;
}
return RES_OK;
}
EMoveResult sector_t::MoveCeiling(double speed, double dest, int crush, int direction, bool hexencrush)
{
bool flag;
double lastpos;
double movedest;
double move;
//double destheight; //jff 02/04/98 used to keep floors/ceilings
// from moving thru each other
lastpos = ceilingplane.fD();
switch (direction)
{
case -1:
// DOWN
// jff 02/04/98 keep ceiling from moving thru floors
// [RH] not so easy with arbitrary planes
//destheight = (dest > floorheight) ? dest : floorheight;
if (!ceilingplane.isSlope() && !floorplane.isSlope() &&
!PortalIsLinked(sector_t::floor) &&
(!(i_compatflags2 & COMPATF2_FLOORMOVE) && dest < -floorplane.fD()))
{
dest = -floorplane.fD();
}
movedest = ceilingplane.GetChangedHeight (-speed);
if (movedest <= dest)
{
move = ceilingplane.HeightDiff (lastpos, dest);
if (!MoveAttached(crush, move, 1, true)) return EMoveResult::crushed;
ceilingplane.setD(dest);
flag = P_ChangeSector (this, crush, move, 1, false);
if (flag)
{
ceilingplane.setD(lastpos);
P_ChangeSector (this, crush, -move, 1, true);
MoveAttached(crush, -move, 1, false);
}
else
{
ChangePlaneTexZ(sector_t::ceiling, move);
}
return EMoveResult::pastdest;
}
else
{
if (!MoveAttached(crush, -speed, 1, true)) return EMoveResult::crushed;
ceilingplane.setD(movedest);
// COULD GET CRUSHED
flag = P_ChangeSector (this, crush, -speed, 1, false);
if (flag)
{
if (crush >= 0 && !hexencrush)
{
ChangePlaneTexZ(sector_t::ceiling, ceilingplane.HeightDiff (lastpos));
return EMoveResult::crushed;
}
ceilingplane.setD(lastpos);
P_ChangeSector (this, crush, speed, 1, true);
MoveAttached(crush, speed, 1, false);
return EMoveResult::crushed;
}
ChangePlaneTexZ(sector_t::ceiling, ceilingplane.HeightDiff (lastpos));
}
break;
case 1:
// UP
movedest = ceilingplane.GetChangedHeight (speed);
if (movedest >= dest)
{
move = ceilingplane.HeightDiff (lastpos, dest);
if (!MoveAttached(crush, move, 1, true)) return EMoveResult::crushed;
ceilingplane.setD(dest);
flag = P_ChangeSector (this, crush, move, 1, false);
if (flag)
{
ceilingplane.setD(lastpos);
P_ChangeSector (this, crush, move, 1, true);
MoveAttached(crush, move, 1, false);
}
else
{
ChangePlaneTexZ(sector_t::ceiling, move);
}
return EMoveResult::pastdest;
}
else
{
if (!MoveAttached(crush, speed, 1, true)) return EMoveResult::crushed;
ceilingplane.setD(movedest);
flag = P_ChangeSector (this, crush, speed, 1, false);
if (flag)
{
ceilingplane.setD(lastpos);
P_ChangeSector (this, crush, -speed, 1, true);
MoveAttached(crush, -speed, 1, false);
return EMoveResult::crushed;
}
ChangePlaneTexZ(sector_t::ceiling, ceilingplane.HeightDiff (lastpos));
}
break;
}
return EMoveResult::ok;
}
//
// Move a plane (floor or ceiling) and check for crushing
// [RH] Crush specifies the actual amount of crushing damage inflictable.
// (Use -1 to prevent it from trying to crush)
//
DMover::EResult DMover::MovePlane (fixed_t speed, fixed_t dest, bool crush,
int floorOrCeiling, int direction)
{
bool flag;
fixed_t lastpos;
switch (floorOrCeiling)
{
case 0:
// FLOOR
switch (direction)
{
case -1:
// DOWN
lastpos = P_FloorHeight(m_Sector);
if (lastpos - speed < dest)
{
P_ChangeFloorHeight(m_Sector, dest - lastpos);
flag = P_ChangeSector (m_Sector, crush);
if (flag == true)
{
P_ChangeFloorHeight(m_Sector, lastpos - dest);
P_ChangeSector (m_Sector, crush);
//return crushed;
}
return pastdest;
}
else
{
P_ChangeFloorHeight(m_Sector, -speed);
flag = P_ChangeSector (m_Sector, crush);
if (flag == true)
{
P_ChangeFloorHeight(m_Sector, speed); // should be lastpos
P_ChangeSector (m_Sector, crush);
return crushed;
}
}
break;
case 1:
// UP
lastpos = P_FloorHeight(m_Sector);
if (lastpos + speed > dest)
{
P_ChangeFloorHeight(m_Sector, dest - lastpos);
flag = P_ChangeSector (m_Sector, crush);
if (flag == true)
{
P_ChangeFloorHeight(m_Sector, lastpos - dest);
P_ChangeSector (m_Sector, crush);
}
return pastdest;
}
else
{
// COULD GET CRUSHED
P_ChangeFloorHeight(m_Sector, speed);
flag = P_ChangeSector (m_Sector, crush);
if (flag == true)
{
if (crush)
return crushed;
P_ChangeFloorHeight(m_Sector, -speed);
P_ChangeSector (m_Sector, crush);
return crushed;
}
}
break;
}
break;
case 1:
// CEILING
switch(direction)
{
case -1:
// DOWN
lastpos = P_CeilingHeight(m_Sector);
if (lastpos - speed < dest)
{
P_SetCeilingHeight(m_Sector, dest);
flag = P_ChangeSector (m_Sector, crush);
if (flag == true)
{
P_SetCeilingHeight(m_Sector, lastpos);
P_ChangeSector (m_Sector, crush);
}
return pastdest;
}
else
{
// COULD GET CRUSHED
P_SetCeilingHeight(m_Sector, lastpos - speed);
flag = P_ChangeSector (m_Sector, crush);
if (flag == true)
{
if (crush)
return crushed;
P_SetCeilingHeight(m_Sector, lastpos);
P_ChangeSector (m_Sector, crush);
return crushed;
}
}
break;
case 1:
// UP
lastpos = P_CeilingHeight(m_Sector);
if (lastpos + speed > dest)
{
P_SetCeilingHeight(m_Sector, dest);
flag = P_ChangeSector (m_Sector, crush);
if (flag == true)
{
P_SetCeilingHeight(m_Sector, lastpos);
P_ChangeSector (m_Sector, crush);
}
return pastdest;
}
else
{
P_SetCeilingHeight(m_Sector, lastpos + speed);
flag = P_ChangeSector (m_Sector, crush);
// UNUSED
#if 0
if (flag == true)
{
P_ChangeCeilingHeight(m_Sector, -speed);
P_ChangeSector (m_Sector, crush);
return crushed;
}
#endif
}
break;
}
break;
}
return ok;
}
void DWaggleBase::DoWaggle (bool ceiling)
{
secplane_t *plane;
int pos;
double dist;
if (ceiling)
{
plane = &m_Sector->ceilingplane;
pos = sector_t::ceiling;
}
else
{
plane = &m_Sector->floorplane;
pos = sector_t::floor;
}
switch (m_State)
{
case WGLSTATE_EXPAND:
if ((m_Scale += m_ScaleDelta) >= m_TargetScale)
{
m_Scale = m_TargetScale;
m_State = WGLSTATE_STABLE;
}
break;
case WGLSTATE_REDUCE:
if ((m_Scale -= m_ScaleDelta) <= 0)
{ // Remove
dist = (m_OriginalDist - plane->fD()) / plane->fC();
m_Sector->ChangePlaneTexZ(pos, -plane->HeightDiff (m_OriginalDist));
plane->setD(m_OriginalDist);
P_ChangeSector (m_Sector, true, dist, ceiling, false);
if (ceiling)
{
m_Sector->ceilingdata = NULL;
}
else
{
m_Sector->floordata = NULL;
}
Destroy ();
return;
}
break;
case WGLSTATE_STABLE:
if (m_Ticker != -1)
{
if (!--m_Ticker)
{
m_State = WGLSTATE_REDUCE;
}
}
break;
}
m_Accumulator += m_AccDelta;
dist = plane->fD();
plane->setD(m_OriginalDist + plane->PointToDist (DVector2(0, 0), BobSin(m_Accumulator) *m_Scale));
m_Sector->ChangePlaneTexZ(pos, plane->HeightDiff (dist));
dist = plane->HeightDiff (dist);
// Interesting: Hexen passes 'true' for the crunch parameter which really is crushing damage here...
// Also, this does not reset the move if it blocks.
P_Scroll3dMidtex(m_Sector, 1, dist, ceiling);
P_MoveLinkedSectors(m_Sector, 1, dist, ceiling);
P_ChangeSector (m_Sector, 1, dist, ceiling, false);
}
//
// Move a plane (floor or ceiling) and check for crushing
// [RH] Crush specifies the actual amount of crushing damage inflictable.
// (Use -1 to prevent it from trying to crush)
// dest is the desired d value for the plane
//
DMover::EResult DMover::MovePlane (fixed_t speed, fixed_t dest, int crush,
int floorOrCeiling, int direction)
{
bool 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:
// FLOOR
lastpos = m_Sector->floorplane.d;
switch (direction)
{
case -1:
// DOWN
m_Sector->floorplane.ChangeHeight (-speed);
if (m_Sector->floorplane.d >= dest)
{
m_Sector->floorplane.d = dest;
flag = P_ChangeSector (m_Sector, crush,
m_Sector->floorplane.HeightDiff (lastpos), 0);
if (flag)
{
m_Sector->floorplane.d = lastpos;
P_ChangeSector (m_Sector, crush,
m_Sector->floorplane.HeightDiff (dest), 0);
}
else
{
m_Sector->floortexz += m_Sector->floorplane.HeightDiff (lastpos);
m_Sector->AdjustFloorClip ();
}
return pastdest;
}
else
{
flag = P_ChangeSector (m_Sector, crush, -speed, 0);
if (flag)
{
m_Sector->floorplane.d = lastpos;
P_ChangeSector (m_Sector, crush, speed, 0);
return crushed;
}
else
{
m_Sector->floortexz += m_Sector->floorplane.HeightDiff (lastpos);
m_Sector->AdjustFloorClip ();
}
}
break;
case 1:
// UP
// jff 02/04/98 keep floor from moving thru ceilings
// [RH] not so easy with arbitrary planes
//destheight = (dest < m_Sector->ceilingheight) ? dest : m_Sector->ceilingheight;
if ((m_Sector->ceilingplane.a | m_Sector->ceilingplane.b |
m_Sector->floorplane.a | m_Sector->floorplane.b) == 0 &&
-dest > m_Sector->ceilingplane.d)
{
dest = -m_Sector->ceilingplane.d;
}
m_Sector->floorplane.ChangeHeight (speed);
if (m_Sector->floorplane.d <= dest)
{
m_Sector->floorplane.d = dest;
flag = P_ChangeSector (m_Sector, crush,
m_Sector->floorplane.HeightDiff (lastpos), 0);
if (flag)
{
m_Sector->floorplane.d = lastpos;
P_ChangeSector (m_Sector, crush,
m_Sector->floorplane.HeightDiff (dest), 0);
}
else
{
m_Sector->floortexz += m_Sector->floorplane.HeightDiff (lastpos);
m_Sector->AdjustFloorClip ();
}
return pastdest;
}
else
{
// COULD GET CRUSHED
flag = P_ChangeSector (m_Sector, crush, speed, 0);
if (flag)
{
if (crush >= 0 && gameinfo.gametype != GAME_Hexen)
{
m_Sector->floortexz += m_Sector->floorplane.HeightDiff (lastpos);
m_Sector->AdjustFloorClip ();
return crushed;
}
m_Sector->floorplane.d = lastpos;
P_ChangeSector (m_Sector, crush, -speed, 0);
return crushed;
}
m_Sector->floortexz += m_Sector->floorplane.HeightDiff (lastpos);
m_Sector->AdjustFloorClip ();
}
break;
}
break;
case 1:
// CEILING
lastpos = m_Sector->ceilingplane.d;
switch (direction)
{
case -1:
// DOWN
// jff 02/04/98 keep ceiling from moving thru floors
// [RH] not so easy with arbitrary planes
//destheight = (dest > m_Sector->floorheight) ? dest : m_Sector->floorheight;
if ((m_Sector->ceilingplane.a | m_Sector->ceilingplane.b |
m_Sector->floorplane.a | m_Sector->floorplane.b) == 0 &&
dest < -m_Sector->floorplane.d)
{
dest = -m_Sector->floorplane.d;
}
m_Sector->ceilingplane.ChangeHeight (-speed);
if (m_Sector->ceilingplane.d <= dest)
{
m_Sector->ceilingplane.d = dest;
flag = P_ChangeSector (m_Sector, crush,
m_Sector->ceilingplane.HeightDiff (lastpos), 1);
if (flag)
{
m_Sector->ceilingplane.d = lastpos;
P_ChangeSector (m_Sector, crush,
m_Sector->ceilingplane.HeightDiff (dest), 1);
}
else
{
m_Sector->ceilingtexz += m_Sector->ceilingplane.HeightDiff (lastpos);
}
return pastdest;
}
else
{
// COULD GET CRUSHED
flag = P_ChangeSector (m_Sector, crush, -speed, 1);
if (flag)
{
if (crush >= 0 && gameinfo.gametype != GAME_Hexen)
{
m_Sector->ceilingtexz += m_Sector->ceilingplane.HeightDiff (lastpos);
return crushed;
}
m_Sector->ceilingplane.d = lastpos;
P_ChangeSector (m_Sector, crush, speed, 1);
return crushed;
}
m_Sector->ceilingtexz += m_Sector->ceilingplane.HeightDiff (lastpos);
}
break;
case 1:
// UP
m_Sector->ceilingplane.ChangeHeight (speed);
if (m_Sector->ceilingplane.d >= dest)
{
m_Sector->ceilingplane.d = dest;
flag = P_ChangeSector (m_Sector, crush,
m_Sector->ceilingplane.HeightDiff (lastpos), 1);
if (flag)
{
m_Sector->ceilingplane.d = lastpos;
P_ChangeSector (m_Sector, crush,
m_Sector->ceilingplane.HeightDiff (dest), 1);
}
else
{
m_Sector->ceilingtexz += m_Sector->ceilingplane.HeightDiff (lastpos);
}
return pastdest;
}
else
{
flag = P_ChangeSector (m_Sector, crush, speed, 1);
// UNUSED
#if 0
if (flag)
{
m_Sector->ceilingplane.d = lastpos;
P_ChangeSector (m_Sector, crush, -speed, 1);
return crushed;
}
#endif
m_Sector->ceilingtexz += m_Sector->ceilingplane.HeightDiff (lastpos);
}
break;
}
break;
}
return ok;
}
