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; }