doom

p_ceilng.c (5054B)

---

 #include "z_zone.h"
 #include "doomdef.h"
 #include "p_local.h"
 
 #include "s_sound.h"
 
 
 #include "doomstat.h"
 #include "r_state.h"
 
 
 #include "sounds.h"
 
 
 
 
 
 
 ceiling_t*	activeceilings[MAXCEILINGS];
 
 
 
 
 
 
 void T_MoveCeiling (ceiling_t* ceiling)
 {
     result_e	res;
 	
     switch(ceiling->direction)
     {
       case 0:
 	
 	break;
       case 1:
 	
 	res = T_MovePlane(ceiling->sector,
 			  ceiling->speed,
 			  ceiling->topheight,
 			  false,1,ceiling->direction);
 	
 	if (!(leveltime&7))
 	{
 	    switch(ceiling->type)
 	    {
 	      case silentCrushAndRaise:
 		break;
 	      default:
 		S_StartSound((mobj_t *)&ceiling->sector->soundorg,
 			     sfx_stnmov);
 		
 		break;
 	    }
 	}
 	
 	if (res == pastdest)
 	{
 	    switch(ceiling->type)
 	    {
 	      case raiseToHighest:
 		P_RemoveActiveCeiling(ceiling);
 		break;
 		
 	      case silentCrushAndRaise:
 		S_StartSound((mobj_t *)&ceiling->sector->soundorg,
 			     sfx_pstop);
 	      case fastCrushAndRaise:
 	      case crushAndRaise:
 		ceiling->direction = -1;
 		break;
 		
 	      default:
 		break;
 	    }
 	    
 	}
 	break;
 	
       case -1:
 	
 	res = T_MovePlane(ceiling->sector,
 			  ceiling->speed,
 			  ceiling->bottomheight,
 			  ceiling->crush,1,ceiling->direction);
 	
 	if (!(leveltime&7))
 	{
 	    switch(ceiling->type)
 	    {
 	      case silentCrushAndRaise: break;
 	      default:
 		S_StartSound((mobj_t *)&ceiling->sector->soundorg,
 			     sfx_stnmov);
 	    }
 	}
 	
 	if (res == pastdest)
 	{
 	    switch(ceiling->type)
 	    {
 	      case silentCrushAndRaise:
 		S_StartSound((mobj_t *)&ceiling->sector->soundorg,
 			     sfx_pstop);
 	      case crushAndRaise:
 		ceiling->speed = CEILSPEED;
 	      case fastCrushAndRaise:
 		ceiling->direction = 1;
 		break;
 
 	      case lowerAndCrush:
 	      case lowerToFloor:
 		P_RemoveActiveCeiling(ceiling);
 		break;
 
 	      default:
 		break;
 	    }
 	}
 	else 
 	{
 	    if (res == crushed)
 	    {
 		switch(ceiling->type)
 		{
 		  case silentCrushAndRaise:
 		  case crushAndRaise:
 		  case lowerAndCrush:
 		    ceiling->speed = CEILSPEED / 8;
 		    break;
 
 		  default:
 		    break;
 		}
 	    }
 	}
 	break;
     }
 }
 
 
 
 
 
 
 int
 EV_DoCeiling
 ( line_t*	line,
   ceiling_e	type )
 {
     int		secnum;
     int		rtn;
     sector_t*	sec;
     ceiling_t*	ceiling;
 	
     secnum = -1;
     rtn = 0;
     
     
     switch(type)
     {
       case fastCrushAndRaise:
       case silentCrushAndRaise:
       case crushAndRaise:
 	P_ActivateInStasisCeiling(line);
       default:
 	break;
     }
 	
     while ((secnum = P_FindSectorFromLineTag(line,secnum)) >= 0)
     {
 	sec = &sectors[secnum];
 	if (sec->specialdata)
 	    continue;
 	
 	
 	rtn = 1;
 	ceiling = Z_Malloc (sizeof(*ceiling), PU_LEVSPEC, 0);
 	P_AddThinker (&ceiling->thinker);
 	sec->specialdata = ceiling;
 	ceiling->thinker.function.acp1 = (actionf_p1)T_MoveCeiling;
 	ceiling->sector = sec;
 	ceiling->crush = false;
 	
 	switch(type)
 	{
 	  case fastCrushAndRaise:
 	    ceiling->crush = true;
 	    ceiling->topheight = sec->ceilingheight;
 	    ceiling->bottomheight = sec->floorheight + (8*FRACUNIT);
 	    ceiling->direction = -1;
 	    ceiling->speed = CEILSPEED * 2;
 	    break;
 
 	  case silentCrushAndRaise:
 	  case crushAndRaise:
 	    ceiling->crush = true;
 	    ceiling->topheight = sec->ceilingheight;
 	  case lowerAndCrush:
 	  case lowerToFloor:
 	    ceiling->bottomheight = sec->floorheight;
 	    if (type != lowerToFloor)
 		ceiling->bottomheight += 8*FRACUNIT;
 	    ceiling->direction = -1;
 	    ceiling->speed = CEILSPEED;
 	    break;
 
 	  case raiseToHighest:
 	    ceiling->topheight = P_FindHighestCeilingSurrounding(sec);
 	    ceiling->direction = 1;
 	    ceiling->speed = CEILSPEED;
 	    break;
 	}
 		
 	ceiling->tag = sec->tag;
 	ceiling->type = type;
 	P_AddActiveCeiling(ceiling);
     }
     return rtn;
 }
 
 
 
 
 
 void P_AddActiveCeiling(ceiling_t* c)
 {
     int		i;
     
     for (i = 0; i < MAXCEILINGS;i++)
     {
 	if (activeceilings[i] == NULL)
 	{
 	    activeceilings[i] = c;
 	    return;
 	}
     }
 }
 
 
 
 
 
 
 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 P_ActivateInStasisCeiling(line_t* line)
 {
     int		i;
 	
     for (i = 0;i < MAXCEILINGS;i++)
     {
 	if (activeceilings[i]
 	    && (activeceilings[i]->tag == line->tag)
 	    && (activeceilings[i]->direction == 0))
 	{
 	    activeceilings[i]->direction = activeceilings[i]->olddirection;
 	    activeceilings[i]->thinker.function.acp1
 	      = (actionf_p1)T_MoveCeiling;
 	}
     }
 }
 
 
 
 
 
 
 
 int	EV_CeilingCrushStop(line_t	*line)
 {
     int		i;
     int		rtn;
 	
     rtn = 0;
     for (i = 0;i < MAXCEILINGS;i++)
     {
 	if (activeceilings[i]
 	    && (activeceilings[i]->tag == line->tag)
 	    && (activeceilings[i]->direction != 0))
 	{
 	    activeceilings[i]->olddirection = activeceilings[i]->direction;
 	    activeceilings[i]->thinker.function.acv = (actionf_v)NULL;
 	    activeceilings[i]->direction = 0;		
 	    rtn = 1;
 	}
     }
     
 
     return rtn;
 }