doom

p_lights.c (5016B)

---

 #include "z_zone.h"
 #include "m_random.h"
 
 #include "doomdef.h"
 #include "p_local.h"
 
 
 
 #include "r_state.h"
 
 
 
 
 
 
 
 
 void T_FireFlicker (fireflicker_t* flick)
 {
     int	amount;
 	
     if (--flick->count)
 	return;
 	
     amount = (P_Random()&3)*16;
     
     if (flick->sector->lightlevel - amount < flick->minlight)
 	flick->sector->lightlevel = flick->minlight;
     else
 	flick->sector->lightlevel = flick->maxlight - amount;
 
     flick->count = 4;
 }
 
 
 
 
 
 
 void P_SpawnFireFlicker (sector_t*	sector)
 {
     fireflicker_t*	flick;
 	
     
     
     sector->special = 0; 
 	
     flick = Z_Malloc ( sizeof(*flick), PU_LEVSPEC, 0);
 
     P_AddThinker (&flick->thinker);
 
     flick->thinker.function.acp1 = (actionf_p1) T_FireFlicker;
     flick->sector = sector;
     flick->maxlight = sector->lightlevel;
     flick->minlight = P_FindMinSurroundingLight(sector,sector->lightlevel)+16;
     flick->count = 4;
 }
 
 
 
 
 
 
 
 
 
 
 
 
 void T_LightFlash (lightflash_t* flash)
 {
     if (--flash->count)
 	return;
 	
     if (flash->sector->lightlevel == flash->maxlight)
     {
 	flash-> sector->lightlevel = flash->minlight;
 	flash->count = (P_Random()&flash->mintime)+1;
     }
     else
     {
 	flash-> sector->lightlevel = flash->maxlight;
 	flash->count = (P_Random()&flash->maxtime)+1;
     }
 
 }
 
 
 
 
 
 
 
 
 
 void P_SpawnLightFlash (sector_t*	sector)
 {
     lightflash_t*	flash;
 
     
     sector->special = 0;	
 	
     flash = Z_Malloc ( sizeof(*flash), PU_LEVSPEC, 0);
 
     P_AddThinker (&flash->thinker);
 
     flash->thinker.function.acp1 = (actionf_p1) T_LightFlash;
     flash->sector = sector;
     flash->maxlight = sector->lightlevel;
 
     flash->minlight = P_FindMinSurroundingLight(sector,sector->lightlevel);
     flash->maxtime = 64;
     flash->mintime = 7;
     flash->count = (P_Random()&flash->maxtime)+1;
 }
 
 
 
 
 
 
 
 
 
 
 
 void T_StrobeFlash (strobe_t*		flash)
 {
     if (--flash->count)
 	return;
 	
     if (flash->sector->lightlevel == flash->minlight)
     {
 	flash-> sector->lightlevel = flash->maxlight;
 	flash->count = flash->brighttime;
     }
     else
     {
 	flash-> sector->lightlevel = flash->minlight;
 	flash->count =flash->darktime;
     }
 
 }
 
 
 
 
 
 
 
 
 void
 P_SpawnStrobeFlash
 ( sector_t*	sector,
   int		fastOrSlow,
   int		inSync )
 {
     strobe_t*	flash;
 	
     flash = Z_Malloc ( sizeof(*flash), PU_LEVSPEC, 0);
 
     P_AddThinker (&flash->thinker);
 
     flash->sector = sector;
     flash->darktime = fastOrSlow;
     flash->brighttime = STROBEBRIGHT;
     flash->thinker.function.acp1 = (actionf_p1) T_StrobeFlash;
     flash->maxlight = sector->lightlevel;
     flash->minlight = P_FindMinSurroundingLight(sector, sector->lightlevel);
 		
     if (flash->minlight == flash->maxlight)
 	flash->minlight = 0;
 
     
     sector->special = 0;	
 
     if (!inSync)
 	flash->count = (P_Random()&7)+1;
     else
 	flash->count = 1;
 }
 
 
 
 
 
 void EV_StartLightStrobing(line_t*	line)
 {
     int		secnum;
     sector_t*	sec;
 	
     secnum = -1;
     while ((secnum = P_FindSectorFromLineTag(line,secnum)) >= 0)
     {
 	sec = &sectors[secnum];
 	if (sec->specialdata)
 	    continue;
 	
 	P_SpawnStrobeFlash (sec,SLOWDARK, 0);
     }
 }
 
 
 
 
 
 
 void EV_TurnTagLightsOff(line_t* line)
 {
     int			i;
     int			j;
     int			min;
     sector_t*		sector;
     sector_t*		tsec;
     line_t*		templine;
 	
     sector = sectors;
     
     for (j = 0;j < numsectors; j++, sector++)
     {
 	if (sector->tag == line->tag)
 	{
 	    min = sector->lightlevel;
 	    for (i = 0;i < sector->linecount; i++)
 	    {
 		templine = sector->lines[i];
 		tsec = getNextSector(templine,sector);
 		if (!tsec)
 		    continue;
 		if (tsec->lightlevel < min)
 		    min = tsec->lightlevel;
 	    }
 	    sector->lightlevel = min;
 	}
     }
 }
 
 
 
 
 
 void
 EV_LightTurnOn
 ( line_t*	line,
   int		bright )
 {
     int		i;
     int		j;
     sector_t*	sector;
     sector_t*	temp;
     line_t*	templine;
 	
     sector = sectors;
 	
     for (i=0;i<numsectors;i++, sector++)
     {
 	if (sector->tag == line->tag)
 	{
 	    
 	    
 	    
 	    if (!bright)
 	    {
 		for (j = 0;j < sector->linecount; j++)
 		{
 		    templine = sector->lines[j];
 		    temp = getNextSector(templine,sector);
 
 		    if (!temp)
 			continue;
 
 		    if (temp->lightlevel > bright)
 			bright = temp->lightlevel;
 		}
 	    }
 	    sector-> lightlevel = bright;
 	}
     }
 }
 
     
 
 
 
 
 void T_Glow(glow_t*	g)
 {
     switch(g->direction)
     {
       case -1:
 	
 	g->sector->lightlevel -= GLOWSPEED;
 	if (g->sector->lightlevel <= g->minlight)
 	{
 	    g->sector->lightlevel += GLOWSPEED;
 	    g->direction = 1;
 	}
 	break;
 	
       case 1:
 	
 	g->sector->lightlevel += GLOWSPEED;
 	if (g->sector->lightlevel >= g->maxlight)
 	{
 	    g->sector->lightlevel -= GLOWSPEED;
 	    g->direction = -1;
 	}
 	break;
     }
 }
 
 
 void P_SpawnGlowingLight(sector_t*	sector)
 {
     glow_t*	g;
 	
     g = Z_Malloc( sizeof(*g), PU_LEVSPEC, 0);
 
     P_AddThinker(&g->thinker);
 
     g->sector = sector;
     g->minlight = P_FindMinSurroundingLight(sector,sector->lightlevel);
     g->maxlight = sector->lightlevel;
     g->thinker.function.acp1 = (actionf_p1) T_Glow;
     g->direction = -1;
 
     sector->special = 0;
 }