//
// EV_ForceField : switch a force field off and on
//
void T_ForceField (forcefield_t *field)
{
switch(field->status)
{
// open it and let it close again after some time
case ff_open:
field->s0_texture = sides[field->line->sidenum[0]].midtexture;
field->s1_texture = sides[field->line->sidenum[1]].midtexture;
sides[field->line->sidenum[0]].midtexture = 0;
sides[field->line->sidenum[1]].midtexture = 0;
field->s0_lightlevel = field->frontsector->lightlevel;
field->s1_lightlevel = field->backsector->lightlevel;
field->backsector->lightlevel = P_FindMinSurroundingLight(
field->backsector, field->backsector->lightlevel);
field->frontsector->lightlevel = P_FindMinSurroundingLight(
field->frontsector, field->frontsector->lightlevel);
field->line->flags &= ~(ML_BLOCKING | ML_SHOOTBLOCK);
field->timer = FFWAITTICS;
field->status = ff_waiting;
S_StartSound((mobj_t *)&field->frontsector->soundorg, sfx_metal);
break;
// switch it off permanentely
case ff_damaged:
sides[field->line->sidenum[0]].midtexture = 0;
sides[field->line->sidenum[1]].midtexture = 0;
field->backsector->lightlevel = P_FindMinSurroundingLight(
field->backsector, field->backsector->lightlevel);
field->frontsector->lightlevel = P_FindMinSurroundingLight(
field->frontsector, field->frontsector->lightlevel);
field->line->flags &= ~(ML_BLOCKING | ML_SHOOTBLOCK);
field->line->special = 0;
S_StartSound((mobj_t *)&field->frontsector->soundorg, sfx_metal);
P_RemoveThinker(&field->thinker);
break;
// wait and after timer is used up close it
case ff_waiting:
if (!field->timer--)
{
// make sure no things get stuck in the force field
if ((field->frontsector->thinglist != NULL) ||
(field->backsector->thinglist != NULL))
{
field->timer = FFWAITTICS;
break;
}
sides[field->line->sidenum[0]].midtexture = field->s0_texture;
sides[field->line->sidenum[1]].midtexture = field->s1_texture;
field->frontsector->lightlevel = field->s0_lightlevel;
field->backsector->lightlevel = field->s1_lightlevel;
field->line->flags = field->oldflags;
S_StartSound((mobj_t *)&field->frontsector->soundorg, sfx_metal);
P_RemoveThinker(&field->thinker);
}
break;
}
}
void T_LaserThinker(laserthinker_t* laserthinker)
{
laser_t* laser = laserthinker->laser;
laser->dist += 64;
// laser reached its destination?
if(laser->dist >= laser->distmax)
{
// reached the end?
if(!laser->next)
{
P_RemoveThinker(&laserthinker->thinker);
// fade out the laser puff
P_FadeMobj(laserthinker->dest, -24, 0, 0);
}
else
laserthinker->laser = laser->next; // advance to next laser point
// remove marker and free laser
P_RemoveMobj(laser->marker);
Z_Free(laser);
}
else
{
// update laser's location
laser->x1 += laser->slopex;
laser->y1 += laser->slopey;
laser->z1 += laser->slopez;
}
}
/** Spawns a one-time lightning flash.
*
* \param sector Sector to light up.
* \sa T_LightningFlash
*/
void P_SpawnLightningFlash(sector_t *sector)
{
INT32 minlight;
lightflash_t *flash;
minlight = sector->lightlevel;
if (sector->lightingdata)
{
if (((lightflash_t *)sector->lightingdata)->thinker.function.acp1
== (actionf_p1)T_LightningFlash)
{
// lightning was already flashing in this sector
// save the original light level value
minlight = ((lightflash_t *)sector->lightingdata)->minlight;
}
P_RemoveThinker(&((elevator_t *)sector->lightingdata)->thinker);
}
sector->lightingdata = NULL;
flash = Z_Calloc(sizeof (*flash), PU_LEVSPEC, NULL);
P_AddThinker(&flash->thinker);
flash->thinker.function.acp1 = (actionf_p1)T_LightningFlash;
flash->sector = sector;
flash->maxlight = 255;
flash->minlight = minlight;
sector->lightlevel = (INT16)flash->maxlight;
sector->lightingdata = flash;
}
int EV_FloorCrushStop(line_t *line, byte *args)
{
thinker_t *think;
floormove_t *floor;
boolean rtn;
rtn = 0;
for(think = thinkercap.next; think != &thinkercap; think = think->next)
{
if(think->function != T_MoveFloor)
{
continue;
}
floor = (floormove_t *)think;
if(floor->type != FLEV_RAISEFLOORCRUSH)
{
continue;
}
// Completely remove the crushing floor
SN_StopSequence((mobj_t *)&floor->sector->soundorg);
floor->sector->specialdata = NULL;
P_TagFinished(floor->sector->tag);
P_RemoveThinker(&floor->thinker);
rtn = 1;
}
return rtn;
}
void T_FadeInBrightness(fadebright_t* fb) {
fb->factor += 2;
if(fb->factor < (i_brightness.value + 100)) {
R_SetLightFactor(fb->factor);
}
else {
P_RemoveThinker(&fb->thinker);
}
}
//
// P_RemoveActivePlat()
//
// Remove a plat from the active plat list
//
// Passed a pointer to the plat to remove
// Returns nothing
//
void P_RemoveActivePlat(plat_t* plat)
{
platlist_t *list = plat->list;
plat->sector->floordata = NULL; //jff 2/23/98 multiple thinkers
P_RemoveThinker(&plat->thinker);
if ((*list->prev = list->next))
list->next->prev = list->prev;
free(list);
}
//
// P_RemoveActiveCeiling()
//
// Removes a ceiling from the list of active ceilings
//
// Passed the ceiling motion structure
// Returns nothing
//
void P_RemoveActiveCeiling(ceiling_t* ceiling)
{
ceilinglist_t* list = ceiling->list;
ceiling->sector->ceilingdata = NULL; //jff 2/22/98
P_RemoveThinker(&ceiling->thinker);
if ((*list->prev = list->next))
list->next->prev = list->prev;
free(list);
}
//
// P_RemoveActivePlat()
//
// Remove a plat from the active plat list
//
// Passed a pointer to the plat to remove
// Returns nothing
//
void P_RemoveActivePlat(plat_t *plat)
{
platlist_t *list = plat->list;
plat->sector->floordata = (void *)0;
P_RemoveThinker(&plat->thinker);
if ((*list->prev = list->next))
list->next->prev = list->prev;
Z_Free(list);
}
/** Removes any active lighting effects in a sector.
*
* \param sector The sector to remove effects from.
*/
static void P_RemoveLighting(sector_t *sector)
{
if (sector->lightingdata)
{
// The thinker is the first member in all the lighting action structs,
// so just let the thinker get freed, and that will free the whole
// structure.
P_RemoveThinker(&((elevator_t *)sector->lightingdata)->thinker);
sector->lightingdata = NULL;
}
}
void T_InterpretACS(acs_t * script)
{
int cmd;
int action;
if (ACSInfo[script->infoIndex].state == ASTE_TERMINATING)
{
ACSInfo[script->infoIndex].state = ASTE_INACTIVE;
ScriptFinished(ACScript->number);
P_RemoveThinker(&ACScript->thinker);
return;
}
if (ACSInfo[script->infoIndex].state != ASTE_RUNNING)
{
return;
}
if (script->delayCount)
{
script->delayCount--;
return;
}
ACScript = script;
PCodePtr = ACScript->ip;
do
{
cmd = LONG(*PCodePtr);
++PCodePtr;
action = PCodeCmds[cmd] ();
} while (action == SCRIPT_CONTINUE);
ACScript->ip = PCodePtr;
if (action == SCRIPT_TERMINATE)
{
ACSInfo[script->infoIndex].state = ASTE_INACTIVE;
ScriptFinished(ACScript->number);
P_RemoveThinker(&ACScript->thinker);
}
}
void P_RemoveActivePlat(plat_t * plat)
{
int i;
for (i = 0; i < MAXPLATS; i++)
if (plat == activeplats[i])
{
(activeplats[i])->sector->specialdata = NULL;
P_RemoveThinker(&(activeplats[i])->thinker);
activeplats[i] = NULL;
return;
}
I_Error("P_RemoveActivePlat: can't find plat!");
}
//==================================================================
//
// Remove a ceiling's thinker
//
//==================================================================
void P_RemoveActiveCeiling(ceiling_t * c)
{
int i;
for(i = 0; i < MAXCEILINGS; i++)
if(activeceilings[i] == c)
{
activeceilings[i]->sector->specialdata = NULL;
P_RemoveThinker(&activeceilings[i]->thinker);
activeceilings[i] = NULL;
break;
}
}
void T_Combine(combine_t *combine) {
sector_t *sector;
sector = combine->sector;
if(combine->special != sector->special ||
combine->func != combine->combiner->function.acp1) {
sector->lightlevel = 0;
P_RemoveThinker(&combine->thinker);
return;
}
sector->lightlevel = ((combine_t*)combine->combiner)->sector->lightlevel;
}
void T_Glow(glow_t* g) {
sector_t *sector;
if(--g->count) {
return;
}
sector = g->sector;
if(g->special != sector->special) {
sector->lightlevel = 0;
P_RemoveThinker(&g->thinker);
return;
}
g->count = 2;
if(g->direction == -1) {
sector->lightlevel -= 2;
if(!(sector->lightlevel < g->minlight)) {
return;
}
sector->lightlevel = g->minlight;
if(g->type == PULSERANDOM) {
g->maxlight = (P_Random(pr_lights) & 31) + 17;
}
g->direction = 1;
return;
}
else if(g->direction == 1) {
sector->lightlevel += 2;
if(!(g->maxlight < sector->lightlevel)) {
return;
}
if(g->type == PULSERANDOM) {
g->minlight = (P_Random(pr_lights) & 15);
}
g->direction = -1;
}
else {
return;
}
}
void T_LightMorph(lightmorph_t *lt) {
lt->inc += 4;
if(lt->inc > 256) {
lt->dest->base_r = lt->dest->active_r;
lt->dest->base_g = lt->dest->active_g;
lt->dest->base_b = lt->dest->active_b;
P_RemoveThinker(<->thinker);
return;
}
lt->dest->active_r = (lt->r + ((lt->inc * (lt->src->base_r - lt->r)) >> 8));
lt->dest->active_g = (lt->g + ((lt->inc * (lt->src->base_g - lt->g)) >> 8));
lt->dest->active_b = (lt->b + ((lt->inc * (lt->src->base_b - lt->b)) >> 8));
}
void T_FireFlicker(fireflicker_t* flick) {
int amount;
if(--flick->count) {
return;
}
if(flick->special != flick->sector->special) {
flick->sector->lightlevel = 0;
P_RemoveThinker(&flick->thinker);
return;
}
amount = (P_Random(pr_lights) & 31);
flick->sector->lightlevel = amount;
flick->count = 3;
}
//
// MOVE A FLOOR TO IT'S DESTINATION (UP OR DOWN)
//
void T_MoveFloor(floormove_t* floor)
{
result_e res;
res = T_MovePlane(floor->sector,
floor->speed,
floor->floordestheight,
floor->crush,0,floor->direction);
if (!(leveltime&7))
S_StartSound((mobj_t *)&floor->sector->soundorg,
sfx_stnmov);
if (res == pastdest)
{
floor->sector->specialdata = NULL;
if (floor->direction == 1)
{
switch(floor->type)
{
case donutRaise:
floor->sector->special = floor->newspecial;
floor->sector->floorpic = floor->texture;
default:
break;
}
}
else if (floor->direction == -1)
{
switch(floor->type)
{
case lowerAndChange:
floor->sector->special = floor->newspecial;
floor->sector->floorpic = floor->texture;
default:
break;
}
}
P_RemoveThinker(&floor->thinker);
S_StartSound((mobj_t *)&floor->sector->soundorg,
sfx_pstop);
}
}
void T_BuildPillar(pillar_t *pillar)
{
result_e res1;
result_e res2;
// First, raise the floor
res1 = T_MovePlane(pillar->sector, pillar->floorSpeed, pillar->floordest,
pillar->crush, 0, pillar->direction); // floorOrCeiling, direction
// Then, lower the ceiling
res2 = T_MovePlane(pillar->sector, pillar->ceilingSpeed,
pillar->ceilingdest, pillar->crush, 1, -pillar->direction);
if (res1 == RES_PASTDEST && res2 == RES_PASTDEST)
{
pillar->sector->specialdata = NULL;
SN_StopSequence((mobj_t *)&pillar->sector->soundorg);
P_TagFinished(pillar->sector->tag);
P_RemoveThinker(&pillar->thinker);
}
}
//
// P_RemoveActivePlat
//
void P_RemoveActivePlat(plat_t* plat)
{
int i;
// haleyjd 20140816: [SVE] remove activeplats limit
for(i = 0; i < numactiveplats; i++)
{
if(plat == activeplats[i])
{
activeplats[i]->sector->specialdata = NULL;
P_RemoveThinker(&(activeplats[i]->thinker));
activeplats[i] = NULL;
return;
}
}
// haleyjd 20140816: [SVE] stability
//I_Error("P_RemoveActivePlat: can't find plat!");
}
int P_SuspendMacro(int tag) {
int id = MACROMASK(tag);
if(id < 0) {
return 0;
}
if(!macro) {
return 0;
}
if(!macrothinker) {
return 0;
}
P_RemoveThinker(macrothinker);
P_InitMacroVars();
return 1;
}
void T_StrobeFlash(strobe_t* flash) {
if(--flash->count) {
return;
}
if(flash->special != flash->sector->special) {
flash->sector->lightlevel = 0;
P_RemoveThinker(&flash->thinker);
return;
}
if(flash->sector->lightlevel != 0) {
flash->sector->lightlevel = 0;
flash->count =flash->darktime;
}
else {
flash->sector->lightlevel = flash->maxlight;
flash->count = flash->brighttime;
}
}
void T_LightFlash(lightflash_t* flash) {
if(--flash->count) {
return;
}
if(flash->special != flash->sector->special) {
flash->sector->lightlevel = 0;
P_RemoveThinker(&flash->thinker);
return;
}
if(flash->sector->lightlevel == 32) {
flash->sector->lightlevel = 0;
flash->count = (P_Random(pr_lights) & 7) + 1;
}
else {
flash->sector->lightlevel = 32;
flash->count = (P_Random(pr_lights) & 32) + 1;
}
}
int EV_CeilingCrushStop(line_t *line, byte *args)
{
int i;
int rtn;
rtn = 0;
for(i = 0; i < MAXCEILINGS; i++)
{
if(activeceilings[i] && activeceilings[i]->tag == args[0])
{
rtn = 1;
SN_StopSequence((mobj_t *) &activeceilings[i]->sector->soundorg);
activeceilings[i]->sector->specialdata = NULL;
P_RemoveThinker(&activeceilings[i]->thinker);
P_TagFinished(activeceilings[i]->sector->tag);
activeceilings[i] = NULL;
break;
}
}
return rtn;
}
//
// MOVE AN ELEVATOR TO IT'S DESTINATION (UP OR DOWN)
//
// Called once per tick for each moving floor.
// Passed an elevator_t structure that contains all pertinent info
// about the move. Supports parallel floor/ceiling motion.
//
// This is from Boom.
//
void T_MoveElevator(elevator_t *elevator)
{
result_e res;
if (elevator->direction < 0) // moving down
{
res = T_MovePlane(elevator->sector, elevator->speed, // move floor
elevator->ceilingdestheight, 0, 1,
elevator->direction);
if (res == ok || res == pastdest) // don't move ceil if blocked
T_MovePlane(elevator->sector, elevator->speed, // move ceil
elevator->floordestheight, 0, 0,
elevator->direction
);
}
else // moving down
{
res = T_MovePlane(elevator->sector, elevator->speed,
elevator->floordestheight, 0, 0,
elevator->direction);
if (res == ok || res == pastdest) // don't move floor if blocked
T_MovePlane(elevator->sector, elevator->speed,
elevator->ceilingdestheight, 0, 1,
elevator->direction);
}
// make floor move sound
if (!(leveltime & 7))
S_StartSound((mobj_t *)&elevator->sector->soundorg, sfx_stnmov);
if (res == pastdest) // if destination height archived
{
elevator->sector->floordata = (void *)0;
elevator->sector->ceilingdata = (void *)0;
P_RemoveThinker(&elevator->thinker);
// make flor stop sound
S_StartSound((mobj_t *)&elevator->sector->soundorg, sfx_pstop);
}
}
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);
}
//
// MOVE A FLOOR TO IT'S DESTINATION (UP OR DOWN)
//
void T_MoveFloor(floormove_t* floor)
{
result_e res;
res = T_MovePlane(floor->sector,
floor->speed,
floor->floordestheight,
floor->crush,0,floor->direction);
if (res == pastdest)
{
floor->sector->specialdata = NULL;
if (floor->direction == 1)
{
switch(floor->type)
{
case donutRaise:
floor->sector->special = (short)floor->newspecial;
floor->sector->floorpic = floor->texture;
default:
break;
}
}
else if (floor->direction == -1)
{
switch(floor->type)
{
case lowerAndChange:
floor->sector->special = (short)floor->newspecial;
floor->sector->floorpic = floor->texture;
default:
break;
}
}
P_RemoveThinker(&floor->thinker);
}
}
//==================================================================
//
// T_VerticalDoor
//
//==================================================================
void T_VerticalDoor(vldoor_t *door)
{
result_e res;
switch(door->direction)
{
case 0: // WAITING
if(!--door->topcountdown)
switch(door->type)
{
case DREV_NORMAL:
door->direction = -1; // time to go back down
SN_StartSequence((mobj_t *)&door->sector->soundorg,
SEQ_DOOR_STONE+door->sector->seqType);
break;
case DREV_CLOSE30THENOPEN:
door->direction = 1;
break;
default:
break;
}
break;
case 2: // INITIAL WAIT
if(!--door->topcountdown)
{
switch(door->type)
{
case DREV_RAISEIN5MINS:
door->direction = 1;
door->type = DREV_NORMAL;
break;
default:
break;
}
}
break;
case -1: // DOWN
res = T_MovePlane(door->sector, door->speed,
door->sector->floorheight, false, 1, door->direction);
if(res == RES_PASTDEST)
{
SN_StopSequence((mobj_t *)&door->sector->soundorg);
switch(door->type)
{
case DREV_NORMAL:
case DREV_CLOSE:
door->sector->specialdata = NULL;
P_TagFinished(door->sector->tag);
P_RemoveThinker(&door->thinker); // unlink and free
break;
case DREV_CLOSE30THENOPEN:
door->direction = 0;
door->topcountdown = 35*30;
break;
default:
break;
}
}
else if(res == RES_CRUSHED)
{
switch(door->type)
{
case DREV_CLOSE: // DON'T GO BACK UP!
break;
default:
door->direction = 1;
break;
}
}
break;
case 1: // UP
res = T_MovePlane(door->sector, door->speed,
door->topheight, false, 1, door->direction);
if(res == RES_PASTDEST)
{
SN_StopSequence((mobj_t *)&door->sector->soundorg);
switch(door->type)
{
case DREV_NORMAL:
door->direction = 0; // wait at top
door->topcountdown = door->topwait;
break;
case DREV_CLOSE30THENOPEN:
case DREV_OPEN:
door->sector->specialdata = NULL;
P_TagFinished(door->sector->tag);
P_RemoveThinker (&door->thinker); // unlink and free
break;
default:
break;
}
}
break;
}
}
//==================================================================
//
// T_VerticalDoor
//
//==================================================================
void T_VerticalDoor(vldoor_t * door)
{
result_e res;
switch (door->direction)
{
case 0: // WAITING
if (!--door->topcountdown)
switch (door->type)
{
case normal:
door->direction = -1; // time to go back down
S_StartSound(&door->sector->soundorg, sfx_doropn);
break;
case close30ThenOpen:
door->direction = 1;
S_StartSound(&door->sector->soundorg, sfx_doropn);
break;
default:
break;
}
break;
case 2: // INITIAL WAIT
if (!--door->topcountdown)
{
switch (door->type)
{
case raiseIn5Mins:
door->direction = 1;
door->type = normal;
S_StartSound(&door->sector->soundorg, sfx_doropn);
break;
default:
break;
}
}
break;
case -1: // DOWN
res = T_MovePlane(door->sector, door->speed,
door->sector->floorheight, false, 1,
door->direction);
if (res == pastdest)
{
switch (door->type)
{
case normal:
case close:
door->sector->specialdata = NULL;
P_RemoveThinker(&door->thinker); // unlink and free
S_StartSound(&door->sector->soundorg, sfx_dorcls);
break;
case close30ThenOpen:
door->direction = 0;
door->topcountdown = 35 * 30;
break;
default:
break;
}
}
else if (res == crushed)
{
switch (door->type)
{
case close: // DON'T GO BACK UP!
break;
default:
door->direction = 1;
S_StartSound(&door->sector->soundorg, sfx_doropn);
break;
}
}
break;
case 1: // UP
res = T_MovePlane(door->sector, door->speed,
door->topheight, false, 1, door->direction);
if (res == pastdest)
{
switch (door->type)
{
case normal:
door->direction = 0; // wait at top
door->topcountdown = door->topwait;
break;
case close30ThenOpen:
case open:
door->sector->specialdata = NULL;
P_RemoveThinker(&door->thinker); // unlink and free
S_StopSound(&door->sector->soundorg);
break;
default:
break;
}
}
break;
}
}
//
// T_VerticalDoor
//
void T_VerticalDoor(vldoor_t* door) {
result_e res1;
result_e res2;
switch(door->direction) {
case 0:
// WAITING
if(!--door->topcountdown) {
switch(door->type) {
case blazeRaise:
door->direction = -1; // time to go back down
S_StartSound((mobj_t *)&door->sector->soundorg,sfx_door2dwn);
break;
case normal:
door->direction = -1; // time to go back down
S_StartSound((mobj_t *)&door->sector->soundorg,sfx_doordown);
break;
case close30ThenOpen:
door->direction = 1;
S_StartSound((mobj_t *)&door->sector->soundorg,sfx_doorup);
break;
default:
break;
}
}
break;
case 2:
// INITIAL WAIT
if(!--door->topcountdown) {
switch(door->type) {
case raiseIn5Mins:
door->direction = 1;
door->type = normal;
S_StartSound((mobj_t *)&door->sector->soundorg,sfx_doorup);
break;
default:
break;
}
}
break;
case -1:
// DOWN
res1 = T_MovePlane(door->sector, door->speed, door->initceiling, false, 1, -1);
res2 = T_MovePlane(door->sector, door->speed, door->initceiling, false, 0, 1);
if(res1 == pastdest && res2 == pastdest) {
switch(door->type) {
case blazeRaise:
case blazeClose:
door->sector->specialdata = NULL;
P_RemoveThinker(&door->thinker); // unlink and free
S_StartSound((mobj_t *)&door->sector->soundorg,sfx_door2dwn);
break;
case normal:
case doorclose:
door->sector->specialdata = NULL;
P_RemoveThinker(&door->thinker); // unlink and free
break;
case close30ThenOpen:
door->direction = 0;
door->topcountdown = 30*30;
break;
default:
break;
}
}
else if(res1 == crushed) {
switch(door->type) {
case blazeClose:
case doorclose: // DO NOT GO BACK UP!
break;
default:
door->direction = 1;
S_StartSound((mobj_t *)&door->sector->soundorg,sfx_doorup);
break;
}
}
break;
case 1:
// UP
res1 = T_MovePlane(door->sector, door->speed, door->topheight, false, 1, 1);
res2 = T_MovePlane(door->sector, door->speed, door->bottomheight, false, 0, -1);
if(res1 == pastdest && res2 == pastdest) {
switch(door->type) {
case blazeRaise:
case normal:
door->direction = 0; // wait at top
door->topcountdown = door->topwait;
break;
case close30ThenOpen:
case blazeOpen:
case dooropen:
door->sector->specialdata = NULL;
P_RemoveThinker(&door->thinker); // unlink and free
break;
default:
break;
}
}
break;
}
}
void T_SlidingDoor (slidedoor_t* door)
{
switch(door->status)
{
case sd_opening:
if (!door->timer--)
{
if (++door->frame == SNUMFRAMES)
{
// IF DOOR IS DONE OPENING...
sides[door->line->sidenum[0]].midtexture = 0;
sides[door->line->sidenum[1]].midtexture = 0;
door->line->flags &= ML_BLOCKING^0xff;
if (door->type == sdt_openOnly)
{
door->frontsector->specialdata = NULL;
P_RemoveThinker (&door->thinker);
break;
}
door->timer = SDOORWAIT;
door->status = sd_waiting;
}
else
{
// IF DOOR NEEDS TO ANIMATE TO NEXT FRAME...
door->timer = SWAITTICS;
sides[door->line->sidenum[0]].midtexture =
slideFrames[door->whichDoorIndex].
frontFrames[door->frame];
sides[door->line->sidenum[1]].midtexture =
slideFrames[door->whichDoorIndex].
backFrames[door->frame];
}
}
break;
case sd_waiting:
// IF DOOR IS DONE WAITING...
if (!door->timer--)
{
// CAN DOOR CLOSE?
if (door->frontsector->thinglist != NULL ||
door->backsector->thinglist != NULL)
{
door->timer = SDOORWAIT;
break;
}
//door->frame = SNUMFRAMES-1;
door->status = sd_closing;
door->timer = SWAITTICS;
}
break;
case sd_closing:
if (!door->timer--)
{
if (--door->frame < 0)
{
// IF DOOR IS DONE CLOSING...
door->line->flags |= ML_BLOCKING;
door->frontsector->specialdata = NULL;
P_RemoveThinker (&door->thinker);
break;
}
else
{
// IF DOOR NEEDS TO ANIMATE TO NEXT FRAME...
door->timer = SWAITTICS;
sides[door->line->sidenum[0]].midtexture =
slideFrames[door->whichDoorIndex].
frontFrames[door->frame];
sides[door->line->sidenum[1]].midtexture =
slideFrames[door->whichDoorIndex].
backFrames[door->frame];
}
}
break;
}
}
