C++ P_RemoveThinker函数代码示例

//
// 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(&lt->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));
}