bool EV_CeilingCrushStop (int tag, bool remove)
{
bool rtn = false;
DCeiling *scan;
TThinkerIterator<DCeiling> iterator;
scan = iterator.Next();
while (scan != nullptr)
{
DCeiling *next = iterator.Next();
if (scan->m_Tag == tag && scan->m_Direction != 0)
{
if (!remove)
{
SN_StopSequence(scan->m_Sector, CHAN_CEILING);
scan->m_OldDirection = scan->m_Direction;
scan->m_Direction = 0; // in-stasis;
}
else
{
scan->Destroy();
}
rtn = true;
}
scan = next;
}
return rtn;
}
//
// Restart a ceiling that's in-stasis
// [RH] Passed a tag instead of a line and rewritten to use list
//
void P_ActivateInStasisCeiling (int tag)
{
DCeiling *scan;
TThinkerIterator<DCeiling> iterator;
while ( (scan = iterator.Next ()) )
{
if (scan->m_Tag == tag && scan->m_Direction == 0)
{
scan->m_Direction = scan->m_OldDirection;
scan->PlayCeilingSound ();
}
}
}
//*****************************************************************************
//
DCeiling *P_GetCeilingByID( LONG lID )
{
DCeiling *pCeiling;
TThinkerIterator<DCeiling> Iterator;
while (( pCeiling = Iterator.Next( )))
{
if ( pCeiling->GetID( ) == lID )
return ( pCeiling );
}
return ( NULL );
}
//
// Restart a ceiling that's in-stasis
// [RH] Passed a tag instead of a line and rewritten to use a list
//
void P_ActivateInStasisCeiling (int tag)
{
DCeiling *scan;
TThinkerIterator<DCeiling> iterator;
while ( (scan = iterator.Next ()) )
{
if (scan->m_Tag == tag && scan->m_Direction == 0)
{
scan->m_Direction = scan->m_OldDirection;
scan->PlayCeilingSound ();
// [BC] If we're the server, tell clients to change the ceiling direction, and
// play the ceiling sound.
if ( NETWORK_GetState( ) == NETSTATE_SERVER )
{
SERVERCOMMANDS_ChangeCeilingDirection( scan->GetID( ), scan->GetDirection( ));
SERVERCOMMANDS_PlayCeilingSound( scan->GetID( ));
}
}
}
}
//
// EV_CeilingCrushStop
// Stop a ceiling from crushing!
// [RH] Passed a tag instead of a line and rewritten to use a list
//
bool EV_CeilingCrushStop (int tag)
{
bool rtn = false;
DCeiling *scan;
TThinkerIterator<DCeiling> iterator;
while ( (scan = iterator.Next ()) )
{
if (scan->m_Tag == tag && scan->m_Direction != 0)
{
// [BC] If we're stopping, this is probably a good time to verify all the clients
// have the correct floor/ceiling height for this sector.
if ( NETWORK_GetState( ) == NETSTATE_SERVER )
{
if ( scan->m_Sector->floorOrCeiling == 0 )
SERVERCOMMANDS_SetSectorFloorPlane( ULONG( scan->m_Sector - sectors ));
else
SERVERCOMMANDS_SetSectorCeilingPlane( ULONG( scan->m_Sector - sectors ));
// Tell clients to stop the floor's sound sequence.
SERVERCOMMANDS_StopSectorSequence( scan->m_Sector );
}
SN_StopSequence (scan->m_Sector);
scan->m_OldDirection = scan->m_Direction;
scan->m_Direction = 0; // in-stasis;
rtn = true;
// [BB] Also tell the updated direction to the clients.
if ( NETWORK_GetState( ) == NETSTATE_SERVER )
SERVERCOMMANDS_ChangeCeilingDirection( scan->GetID( ), scan->GetDirection( ));
}
}
return rtn;
}
//
// 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;
}
DCeiling *DCeiling::Create(sector_t *sec, DCeiling::ECeiling type, line_t *line, int tag,
fixed_t speed, fixed_t speed2, fixed_t height,
int crush, int silent, int change, bool hexencrush)
{
fixed_t targheight = 0; // Silence, GCC
// if ceiling already moving, don't start a second function on it
if (sec->PlaneMoving(sector_t::ceiling))
{
return NULL;
}
// new door thinker
DCeiling *ceiling = new DCeiling (sec, speed, speed2, silent);
vertex_t *spot = sec->lines[0]->v1;
switch (type)
{
case ceilCrushAndRaise:
case ceilCrushRaiseAndStay:
ceiling->m_TopHeight = sec->ceilingplane.d;
case ceilLowerAndCrush:
case ceilLowerAndCrushDist:
targheight = sec->FindHighestFloorPoint (&spot);
if (type == ceilLowerAndCrush)
{
targheight += 8*FRACUNIT;
}
else if (type == ceilCrushAndRaise)
{
targheight += height;
}
ceiling->m_BottomHeight = sec->ceilingplane.PointToDist (spot, targheight);
ceiling->m_Direction = -1;
break;
case ceilRaiseToHighest:
targheight = sec->FindHighestCeilingSurrounding (&spot);
ceiling->m_TopHeight = sec->ceilingplane.PointToDist (spot, targheight);
ceiling->m_Direction = 1;
break;
case ceilLowerByValue:
targheight = sec->ceilingplane.ZatPoint (spot) - height;
ceiling->m_BottomHeight = sec->ceilingplane.PointToDist (spot, targheight);
ceiling->m_Direction = -1;
break;
case ceilRaiseByValue:
targheight = sec->ceilingplane.ZatPoint (spot) + height;
ceiling->m_TopHeight = sec->ceilingplane.PointToDist (spot, targheight);
ceiling->m_Direction = 1;
break;
case ceilMoveToValue:
{
int diff = height - sec->ceilingplane.ZatPoint (spot);
targheight = height;
if (diff < 0)
{
ceiling->m_BottomHeight = sec->ceilingplane.PointToDist (spot, height);
ceiling->m_Direction = -1;
}
else
{
ceiling->m_TopHeight = sec->ceilingplane.PointToDist (spot, height);
ceiling->m_Direction = 1;
}
}
break;
case ceilLowerToHighestFloor:
targheight = sec->FindHighestFloorSurrounding (&spot);
ceiling->m_BottomHeight = sec->ceilingplane.PointToDist (spot, targheight);
ceiling->m_Direction = -1;
break;
case ceilRaiseToHighestFloor:
targheight = sec->FindHighestFloorSurrounding (&spot);
ceiling->m_TopHeight = sec->ceilingplane.PointToDist (spot, targheight);
ceiling->m_Direction = 1;
break;
case ceilLowerInstant:
targheight = sec->ceilingplane.ZatPoint (spot) - height;
ceiling->m_BottomHeight = sec->ceilingplane.PointToDist (spot, targheight);
ceiling->m_Direction = -1;
ceiling->m_Speed = height;
break;
case ceilRaiseInstant:
targheight = sec->ceilingplane.ZatPoint (spot) + height;
ceiling->m_TopHeight = sec->ceilingplane.PointToDist (spot, targheight);
ceiling->m_Direction = 1;
ceiling->m_Speed = height;
break;
case ceilLowerToNearest:
targheight = sec->FindNextLowestCeiling (&spot);
ceiling->m_BottomHeight = sec->ceilingplane.PointToDist (spot, targheight);
ceiling->m_Direction = -1;
break;
case ceilRaiseToNearest:
targheight = sec->FindNextHighestCeiling (&spot);
ceiling->m_TopHeight = sec->ceilingplane.PointToDist (spot, targheight);
ceiling->m_Direction = 1;
break;
case ceilLowerToLowest:
targheight = sec->FindLowestCeilingSurrounding (&spot);
ceiling->m_BottomHeight = sec->ceilingplane.PointToDist (spot, targheight);
ceiling->m_Direction = -1;
break;
case ceilRaiseToLowest:
targheight = sec->FindLowestCeilingSurrounding (&spot);
ceiling->m_TopHeight = sec->ceilingplane.PointToDist (spot, targheight);
ceiling->m_Direction = 1;
break;
case ceilLowerToFloor:
targheight = sec->FindHighestFloorPoint (&spot);
ceiling->m_BottomHeight = sec->ceilingplane.PointToDist (spot, targheight);
ceiling->m_Direction = -1;
break;
case ceilRaiseToFloor: // [RH] What's this for?
targheight = sec->FindHighestFloorPoint (&spot);
ceiling->m_TopHeight = sec->ceilingplane.PointToDist (spot, targheight);
ceiling->m_Direction = 1;
break;
case ceilLowerToHighest:
targheight = sec->FindHighestCeilingSurrounding (&spot);
ceiling->m_BottomHeight = sec->ceilingplane.PointToDist (spot, targheight);
ceiling->m_Direction = -1;
break;
case ceilLowerByTexture:
targheight = sec->ceilingplane.ZatPoint (spot) - sec->FindShortestUpperAround ();
ceiling->m_BottomHeight = sec->ceilingplane.PointToDist (spot, targheight);
ceiling->m_Direction = -1;
break;
case ceilRaiseByTexture:
targheight = sec->ceilingplane.ZatPoint (spot) + sec->FindShortestUpperAround ();
ceiling->m_TopHeight = sec->ceilingplane.PointToDist (spot, targheight);
ceiling->m_Direction = 1;
break;
default:
break; // Silence GCC
}
ceiling->m_Tag = tag;
ceiling->m_Type = type;
ceiling->m_Crush = crush;
ceiling->m_Hexencrush = hexencrush;
// Do not interpolate instant movement ceilings.
// Note for ZDoomGL: Check to make sure that you update the sector
// after the ceiling moves, because it hasn't actually moved yet.
fixed_t movedist;
if (ceiling->m_Direction < 0)
{
movedist = sec->ceilingplane.d - ceiling->m_BottomHeight;
}
else
{
movedist = ceiling->m_TopHeight - sec->ceilingplane.d;
}
if (ceiling->m_Speed >= movedist)
{
ceiling->StopInterpolation();
}
// set texture/type change properties
if (change & 3) // if a texture change is indicated
{
if (change & 4) // if a numeric model change
{
sector_t *modelsec;
//jff 5/23/98 find model with floor at target height if target
//is a floor type
modelsec = (/*type == ceilRaiseToHighest ||*/
type == ceilRaiseToFloor ||
/*type == ceilLowerToHighest ||*/
type == ceilLowerToFloor) ?
sec->FindModelFloorSector (targheight) :
sec->FindModelCeilingSector (targheight);
if (modelsec != NULL)
{
ceiling->m_Texture = modelsec->GetTexture(sector_t::ceiling);
switch (change & 3)
{
case 1: // type is zeroed
ceiling->m_NewSpecial = 0;
ceiling->m_Type = genCeilingChg0;
break;
case 2: // type is copied
ceiling->m_NewSpecial = sec->special;
ceiling->m_Type = genCeilingChgT;
break;
case 3: // type is left alone
ceiling->m_Type = genCeilingChg;
break;
}
}
}
else if (line) // else if a trigger model change
{
ceiling->m_Texture = line->frontsector->GetTexture(sector_t::ceiling);
switch (change & 3)
{
case 1: // type is zeroed
ceiling->m_NewSpecial = 0;
ceiling->m_Type = genCeilingChg0;
break;
case 2: // type is copied
ceiling->m_NewSpecial = line->frontsector->special;
ceiling->m_Type = genCeilingChgT;
break;
case 3: // type is left alone
ceiling->m_Type = genCeilingChg;
break;
}
}
}
ceiling->PlayCeilingSound ();
return ceiling;
}
//
// 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,
int crush, int silent, int change, bool hexencrush)
{
int secnum;
bool rtn;
sector_t* sec;
DCeiling* ceiling;
bool manual = false;
fixed_t targheight = 0; // Silence, GCC
vertex_t* spot;
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 = (int)(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)
{
if (!manual)
continue;
else
return false;
}
// new door thinker
rtn = 1;
ceiling = new DCeiling (sec, speed, speed2, silent);
spot = sec->lines[0]->v1;
// [BC] If we're not a client, assign a network ID to the ceiling.
if (( NETWORK_GetState( ) != NETSTATE_CLIENT ) && !( CLIENTDEMO_IsPlaying( )))
ceiling->m_lCeilingID = P_GetFirstFreeCeilingID( );
switch (type)
{
case DCeiling::ceilCrushAndRaise:
case DCeiling::ceilCrushRaiseAndStay:
ceiling->m_TopHeight = sec->ceilingplane.d;
case DCeiling::ceilLowerAndCrush:
targheight = sec->FindHighestFloorPoint (&spot);
if (type != DCeiling::ceilLowerAndCrush || gameinfo.gametype != GAME_Strife)
{
targheight += 8*FRACUNIT;
}
ceiling->m_BottomHeight = sec->ceilingplane.PointToDist (spot, targheight);
ceiling->m_Direction = -1;
break;
case DCeiling::ceilRaiseToHighest:
targheight = sec->FindHighestCeilingSurrounding (&spot);
ceiling->m_TopHeight = sec->ceilingplane.PointToDist (spot, targheight);
ceiling->m_Direction = 1;
break;
case DCeiling::ceilLowerByValue:
targheight = sec->ceilingplane.ZatPoint (spot) - height;
ceiling->m_BottomHeight = sec->ceilingplane.PointToDist (spot, targheight);
ceiling->m_Direction = -1;
break;
case DCeiling::ceilRaiseByValue:
targheight = sec->ceilingplane.ZatPoint (spot) + height;
ceiling->m_TopHeight = sec->ceilingplane.PointToDist (spot, targheight);
ceiling->m_Direction = 1;
break;
case DCeiling::ceilMoveToValue:
{
int diff = height - sec->ceilingplane.ZatPoint (spot);
targheight = height;
if (diff < 0)
{
ceiling->m_BottomHeight = sec->ceilingplane.PointToDist (spot, height);
ceiling->m_Direction = -1;
}
else
{
ceiling->m_TopHeight = sec->ceilingplane.PointToDist (spot, height);
ceiling->m_Direction = 1;
}
}
break;
case DCeiling::ceilLowerToHighestFloor:
targheight = sec->FindHighestFloorSurrounding (&spot);
ceiling->m_BottomHeight = sec->ceilingplane.PointToDist (spot, targheight);
ceiling->m_Direction = -1;
break;
case DCeiling::ceilRaiseToHighestFloor:
targheight = sec->FindHighestFloorSurrounding (&spot);
ceiling->m_TopHeight = sec->ceilingplane.PointToDist (spot, targheight);
ceiling->m_Direction = 1;
break;
case DCeiling::ceilLowerInstant:
targheight = sec->ceilingplane.ZatPoint (spot) - height;
ceiling->m_BottomHeight = sec->ceilingplane.PointToDist (spot, targheight);
ceiling->m_Direction = -1;
ceiling->m_Speed = height;
break;
case DCeiling::ceilRaiseInstant:
targheight = sec->ceilingplane.ZatPoint (spot) + height;
ceiling->m_TopHeight = sec->ceilingplane.PointToDist (spot, targheight);
ceiling->m_Direction = 1;
ceiling->m_Speed = height;
break;
case DCeiling::ceilLowerToNearest:
targheight = sec->FindNextLowestCeiling (&spot);
ceiling->m_BottomHeight = sec->ceilingplane.PointToDist (spot, targheight);
ceiling->m_Direction = -1;
break;
case DCeiling::ceilRaiseToNearest:
targheight = sec->FindNextHighestCeiling (&spot);
ceiling->m_TopHeight = sec->ceilingplane.PointToDist (spot, targheight);
ceiling->m_Direction = 1;
break;
case DCeiling::ceilLowerToLowest:
targheight = sec->FindLowestCeilingSurrounding (&spot);
ceiling->m_BottomHeight = sec->ceilingplane.PointToDist (spot, targheight);
ceiling->m_Direction = -1;
break;
case DCeiling::ceilRaiseToLowest:
targheight = sec->FindLowestCeilingSurrounding (&spot);
ceiling->m_TopHeight = sec->ceilingplane.PointToDist (spot, targheight);
ceiling->m_Direction = 1;
break;
case DCeiling::ceilLowerToFloor:
targheight = sec->FindHighestFloorPoint (&spot);
ceiling->m_BottomHeight = sec->ceilingplane.PointToDist (spot, targheight);
ceiling->m_Direction = -1;
break;
case DCeiling::ceilRaiseToFloor: // [RH] What's this for?
targheight = sec->FindHighestFloorPoint (&spot);
ceiling->m_TopHeight = sec->ceilingplane.PointToDist (spot, targheight);
ceiling->m_Direction = 1;
break;
case DCeiling::ceilLowerToHighest:
targheight = sec->FindHighestCeilingSurrounding (&spot);
ceiling->m_BottomHeight = sec->ceilingplane.PointToDist (spot, targheight);
ceiling->m_Direction = -1;
break;
case DCeiling::ceilLowerByTexture:
targheight = sec->ceilingplane.ZatPoint (spot) - sec->FindShortestUpperAround ();
ceiling->m_BottomHeight = sec->ceilingplane.PointToDist (spot, targheight);
ceiling->m_Direction = -1;
break;
case DCeiling::ceilRaiseByTexture:
targheight = sec->ceilingplane.ZatPoint (spot) + sec->FindShortestUpperAround ();
ceiling->m_TopHeight = sec->ceilingplane.PointToDist (spot, targheight);
ceiling->m_Direction = 1;
break;
default:
break; // Silence GCC
}
ceiling->m_Tag = tag;
ceiling->m_Type = type;
ceiling->m_Crush = crush;
ceiling->m_Hexencrush = hexencrush;
// Do not interpolate instant movement ceilings.
// Note for ZDoomGL: Check to make sure that you update the sector
// after the ceiling moves, because it hasn't actually moved yet.
fixed_t movedist;
if (ceiling->m_Direction < 0)
{
movedist = sec->ceilingplane.d - ceiling->m_BottomHeight;
}
else
{
movedist = ceiling->m_TopHeight - sec->ceilingplane.d;
}
if (ceiling->m_Speed >= movedist)
{
ceiling->StopInterpolation();
}
// [BC] If we're the server, tell clients to create a ceiling.
if ( NETWORK_GetState( ) == NETSTATE_SERVER )
SERVERCOMMANDS_DoCeiling( type, §ors[secnum], ceiling->m_Direction, ceiling->m_BottomHeight, ceiling->m_TopHeight, ceiling->m_Speed, ceiling->m_Crush, ceiling->m_Silent, ceiling->m_lCeilingID );
// set texture/type change properties
if (change & 3) // if a texture change is indicated
{
if (change & 4) // if a numeric model change
{
sector_t *modelsec;
//jff 5/23/98 find model with floor at target height if target
//is a floor type
modelsec = (/*type == DCeiling::ceilRaiseToHighest ||*/
type == DCeiling::ceilRaiseToFloor ||
/*type == DCeiling::ceilLowerToHighest ||*/
type == DCeiling::ceilLowerToFloor) ?
sec->FindModelFloorSector (targheight) :
sec->FindModelCeilingSector (targheight);
if (modelsec != NULL)
{
ceiling->m_Texture = modelsec->GetTexture(sector_t::ceiling);
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->GetTexture(sector_t::ceiling);
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 ();
// [BC] If we're the server, tell clients to play the ceiling sound.
if ( NETWORK_GetState( ) == NETSTATE_SERVER )
SERVERCOMMANDS_PlayCeilingSound( ceiling->m_lCeilingID );
if (manual)
return rtn;
}
return rtn;
}
