#include "doomdef.h"
#include "p_local.h"
#include "soundst.h"

#ifdef GL_HERETIC
#include "gl_struct.h"
#endif

/*
  //==================================================================
  //==================================================================
  //
  //			         FLOORS
  //
  //==================================================================
  //==================================================================
*/

/*
  //==================================================================
  //
  //	Move a plane (floor or ceiling) and check for crushing
  //
  //==================================================================
*/
result_e   T_MovePlane(sector_t *sector,fixed_t speed,
		       fixed_t dest,boolean crush,int floorOrCeiling,int direction)
{
  boolean	flag;
  fixed_t	lastpos;

#ifdef WALL_ARRAY
  sector->Prevfloorheight=sector->floorheight;
  sector->Prevceilingheight=sector->ceilingheight;
#endif

  switch(floorOrCeiling)
    {
    case 0:		/* FLOOR */
      switch(direction)
	{
	case -1:	/* DOWN */
	  if (sector->floorheight - speed < dest)
	    {
	      lastpos = sector->floorheight;
	      sector->floorheight = dest;
	      flag = P_ChangeSector(sector,crush);
	      if (flag == true)
		{
		  sector->floorheight =lastpos;
		  P_ChangeSector(sector,crush);
		  /*   return crushed;   */
		}
#ifdef GL_HERETIC
	      fn_vGLUpdateSector(sector);
#endif
	      return pastdest;
	    }
	  else
	    {
	      lastpos = sector->floorheight;
	      sector->floorheight -= speed;
	      flag = P_ChangeSector(sector,crush);
	      if (flag == true)
		{
		  sector->floorheight = lastpos;
		  P_ChangeSector(sector,crush);
#ifdef GL_HERETIC
		  fn_vGLUpdateSector(sector);
#endif
		  return crushed;
		}
	    }
	  break;
	  
	case 1:		/* UP */
	  if (sector->floorheight + speed > dest)
	    {
	      lastpos = sector->floorheight;
	      sector->floorheight = dest;
	      flag = P_ChangeSector(sector,crush);
	      if (flag == true)
		{
		  sector->floorheight = lastpos;
		  P_ChangeSector(sector,crush);
		  /*   return crushed;   */
		}
#ifdef GL_HERETIC
	      fn_vGLUpdateSector(sector);
#endif
	      return pastdest;
	    }
	  else	/* COULD GET CRUSHED */
	    {
	      lastpos = sector->floorheight;
	      sector->floorheight += speed;
	      flag = P_ChangeSector(sector,crush);
#ifdef GL_HERETIC
	      fn_vGLUpdateSector(sector);
#endif
	      if (flag == true)
		{
		  if (crush == true)
		    return crushed;
		  sector->floorheight = lastpos;
		  P_ChangeSector(sector,crush);
		  return crushed;
		}
	    }
	  break;
	}
      break;
      
    case 1:		/* CEILING */
      switch(direction)
	{
	case -1:	/* DOWN */
	  if (sector->ceilingheight - speed < dest)
	    {
	      lastpos = sector->ceilingheight;
	      sector->ceilingheight = dest;
	      flag = P_ChangeSector(sector,crush);
#ifdef GL_HERETIC
	      fn_vGLUpdateSector(sector);
#endif
	      if (flag == true)
		{
		  sector->ceilingheight = lastpos;
		  P_ChangeSector(sector,crush);
		  /*   return crushed;   */
		}
	      return pastdest;
	    }
	  else	/* COULD GET CRUSHED */
	    {
	      lastpos = sector->ceilingheight;
	      sector->ceilingheight -= speed;
	      flag = P_ChangeSector(sector,crush);
#ifdef GL_HERETIC
	      fn_vGLUpdateSector(sector);
#endif
	      if (flag == true)
		{
		  if (crush == true)
		    return crushed;
		  sector->ceilingheight = lastpos;
		  P_ChangeSector(sector,crush);
		  return crushed;
		}
	    }
	  break;
	  
	case 1:		/* UP */
	  if (sector->ceilingheight + speed > dest)
	    {
	      lastpos = sector->ceilingheight;
	      sector->ceilingheight = dest;
	      flag = P_ChangeSector(sector,crush);
#ifdef GL_HERETIC
	      fn_vGLUpdateSector(sector);
#endif
	      if (flag == true)
		{
		  sector->ceilingheight = lastpos;
		  P_ChangeSector(sector,crush);
		  /*   return crushed;   */
		}
	      return pastdest;
	    }
	  else
	    {
	      lastpos = sector->ceilingheight;
	      sector->ceilingheight += speed;
	      flag = P_ChangeSector(sector,crush);
#ifdef GL_HERETIC
	      fn_vGLUpdateSector(sector);
#endif

#if 0
	      if (flag == true)
		{
		  sector->ceilingheight = lastpos;
		  P_ChangeSector(sector,crush);
		  return crushed;
		}
#endif
	    }
	  break;
	}
      break;
      
    }
#ifdef GL_HERETIC
  fn_vGLUpdateSector(sector);
#endif
  return ok;
}


/*
  //==================================================================
  //
  //	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_dormov);
    }
  
  if (res == pastdest)
    {
      floor->sector->specialdata = NULL;
      if(floor->type == raiseBuildStep)
	{
	  S_StartSound((mobj_t *)&floor->sector->soundorg, sfx_pstop);
	}
      if (floor->direction == 1)
	switch(floor->type)
	  {
	  case donutRaise:
	    floor->sector->special = floor->newspecial;
	    floor->sector->floorpic = floor->texture;
#ifdef GL_HERETIC
	    GL_vSetFloorTexture(floor->sector->iSectorID,floor->texture);
#endif
	  default:
	    break;
	  }
      else if (floor->direction == -1)
	switch(floor->type)
	  {
	  case lowerAndChange:
	    floor->sector->special = floor->newspecial;
	    floor->sector->floorpic = floor->texture;
#ifdef GL_HERETIC
	    GL_vSetFloorTexture(floor->sector->iSectorID,floor->texture);
#endif
	  default:
	    break;
	  }
      P_RemoveThinker(&floor->thinker);
    }  
}


/*
  //==================================================================
  //
  //	HANDLE FLOOR TYPES
  //
  //==================================================================
*/
int EV_DoFloor(line_t *line,floor_e floortype)
{
  int			secnum;
  int			rtn;
  int			i;
  sector_t	        *sec;
  floormove_t	        *floor;
  
  secnum = -1;
  rtn = 0;
  while ((secnum = P_FindSectorFromLineTag(line,secnum)) >= 0)
    {
      sec = &sectors[secnum];
      
      /*	ALREADY MOVING?  IF SO, KEEP GOING... */
      if (sec->specialdata)
	continue;
      
      /*
       *	new floor thinker
       */
      rtn = 1;
      floor = Z_Malloc (sizeof(*floor), PU_LEVSPEC, 0);
      P_AddThinker (&floor->thinker);
      sec->specialdata = floor;
      floor->thinker.function.acp1 = (actionf_p1)T_MoveFloor;
      floor->type = floortype;
      floor->crush = false;
      switch(floortype)
	{
	case lowerFloor:
	  floor->direction = -1;
	  floor->sector = sec;
	  floor->speed = FLOORSPEED;
	  floor->floordestheight = 
	    P_FindHighestFloorSurrounding(sec);
	  break;
	case lowerFloorToLowest:
	  floor->direction = -1;
	  floor->sector = sec;
	  floor->speed = FLOORSPEED;
	  floor->floordestheight = 
	    P_FindLowestFloorSurrounding(sec);
	  break;
	case turboLower:
	  floor->direction = -1;
	  floor->sector = sec;
	  floor->speed = FLOORSPEED * 4;
	  floor->floordestheight = (8*FRACUNIT) + 
	    P_FindHighestFloorSurrounding(sec);
	  break;
	case raiseFloorCrush:
	  floor->crush = true;
	case raiseFloor:
	  floor->direction = 1;
	  floor->sector = sec;
	  floor->speed = FLOORSPEED;
	  floor->floordestheight = 
	    P_FindLowestCeilingSurrounding(sec);
	  if (floor->floordestheight > sec->ceilingheight)
	    floor->floordestheight = sec->ceilingheight;
	  floor->floordestheight -= (8*FRACUNIT)*
	    (floortype == raiseFloorCrush);
	  break;
	case raiseFloorToNearest:
	  floor->direction = 1;
	  floor->sector = sec;
	  floor->speed = FLOORSPEED;
	  floor->floordestheight = 
	    P_FindNextHighestFloor(sec,sec->floorheight);
	  break;
	case raiseFloor24:
	  floor->direction = 1;
	  floor->sector = sec;
	  floor->speed = FLOORSPEED;
	  floor->floordestheight = floor->sector->floorheight +
	    24 * FRACUNIT;
	  break;
	case raiseFloor24AndChange:
	  floor->direction = 1;
	  floor->sector = sec;
	  floor->speed = FLOORSPEED;
	  floor->floordestheight = floor->sector->floorheight +
	    24 * FRACUNIT;
	  sec->floorpic = line->frontsector->floorpic;
	  sec->special = line->frontsector->special;
	  break;
	case raiseToTexture:
	  {
	    int	minsize = MAXINT;
	    side_t	*side;
	    
	    floor->direction = 1;
	    floor->sector = sec;
	    floor->speed = FLOORSPEED;
	    for (i = 0; i < sec->linecount; i++)
	      if (twoSided (secnum, i) )
		{
		  side = getSide(secnum,i,0);
		  if (side->bottomtexture >= 0)
		    if (textureheight[side->bottomtexture] < 
			minsize)
		      minsize = 
			textureheight[side->bottomtexture];
		  side = getSide(secnum,i,1);
		  if (side->bottomtexture >= 0)
		    if (textureheight[side->bottomtexture] < 
			minsize)
		      minsize = 
			textureheight[side->bottomtexture];
		} 
	    floor->floordestheight = floor->sector->floorheight + 
	      minsize;
	  }
	  break;
	case lowerAndChange:
	  floor->direction = -1;
	  floor->sector = sec;
	  floor->speed = FLOORSPEED;
	  floor->floordestheight = 
	    P_FindLowestFloorSurrounding(sec);
	  floor->texture = sec->floorpic;
	  for (i = 0; i < sec->linecount; i++)
	    if ( twoSided(secnum, i) )
	      {
		if (getSide(secnum,i,0)->sector-sectors == secnum)
		  {
		    sec = getSector(secnum,i,1);
		    floor->texture = sec->floorpic;
		    floor->newspecial = sec->special;
		    break;
		  }
		else
		  {
		    sec = getSector(secnum,i,0);
		    floor->texture = sec->floorpic;
		    floor->newspecial = sec->special;
		    break;
		  }
	      }
	default:
	  break;
	}
    }
  return rtn;
}


/*
  //==================================================================
  //
  //	BUILD A STAIRCASE!
  //
  //==================================================================
*/
int EV_BuildStairs(line_t *line, fixed_t stepDelta)
{
  int		secnum;
  int		height;
  int		i;
  int		newsecnum;
  int		texture;
  int		ok;
  int		rtn;
  sector_t	*sec, *tsec;
  floormove_t	*floor;
  
  secnum = -1;
  rtn = 0;
  while ((secnum = P_FindSectorFromLineTag(line,secnum)) >= 0)
    {
      sec = &sectors[secnum];
      
      /* ALREADY MOVING?  IF SO, KEEP GOING... */
      if (sec->specialdata)
	continue;
      
      /*
       * new floor thinker
       */
      rtn = 1;
      height = sec->floorheight+stepDelta;
      floor = Z_Malloc (sizeof(*floor), PU_LEVSPEC, 0);
      P_AddThinker (&floor->thinker);
      sec->specialdata = floor;
      floor->thinker.function.acp1 = (actionf_p1)T_MoveFloor;
      floor->type = raiseBuildStep;
      floor->direction = 1;
      floor->sector = sec;
      floor->speed = FLOORSPEED;
      floor->floordestheight = height;
      
      texture = sec->floorpic;
      
      /*
       * Find next sector to raise
       * 1.	Find 2-sided line with same sector side[0]
       * 2.	Other side is the next sector to raise
       */
      do
	{
	  ok = 0;
	  for (i = 0;i < sec->linecount;i++)
	    {
	      if ( !((sec->lines[i])->flags & ML_TWOSIDED) )
		continue;
	      
	      tsec = (sec->lines[i])->frontsector;
	      newsecnum = tsec-sectors;
	      if (secnum != newsecnum)
		continue;
	      tsec = (sec->lines[i])->backsector;
	      newsecnum = tsec - sectors;
	      if (tsec->floorpic != texture)
		continue;
	      
	      height += stepDelta;
	      if (tsec->specialdata)
		continue;
	      
	      sec = tsec;
	      secnum = newsecnum;
	      floor = Z_Malloc (sizeof(*floor), PU_LEVSPEC, 0);
	      P_AddThinker (&floor->thinker);
	      sec->specialdata = floor;
	      floor->thinker.function.acp1 = (actionf_p1)T_MoveFloor;
	      floor->type = raiseBuildStep;
	      floor->direction = 1;
	      floor->sector = sec;
	      floor->speed = FLOORSPEED;
	      floor->floordestheight = height;
	      ok = 1;
	      break;
	    }
	} while(ok);
    }
  return(rtn);
}