// Emacs style mode select   -*- C++ -*- 
//-----------------------------------------------------------------------------
//
// $Id:$
//
// Copyright (C) 1993-1996 by id Software, Inc.
//
// This source is available for distribution and/or modification
// only under the terms of the DOOM Source Code License as
// published by id Software. All rights reserved.
//
// The source is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// FITNESS FOR A PARTICULAR PURPOSE. See the DOOM Source Code License
// for more details.
//
// $Log:$
//
// DESCRIPTION: Door animation code (opening/closing)
//
//-----------------------------------------------------------------------------

//static const char 


#include "z_zone.h"
#include "doomdef.h"
#include "p_local.h"

//#include "s_sound.h"


// State.
#include "doomstat.h"
#include "r_state.h"

// Data.
#include "dstrings.h"
//#include "sounds.h"

//
// VERTICAL DOORS
//

//
// T_VerticalDoor
//
void T_VerticalDoor (vldoor_t* door)
{
  result_e	res;

  switch(door->direction)
  {
  case 0:
    // WAITING
    if (!--door->topcountdown)
    {
      switch(door->type)
      {
      case blazeRaise:
        door->direction = -1; // time to go back down
        break;

      case normal:
        door->direction = -1; // time to go back down
        break;

      case close30ThenOpen:
        door->direction = 1;
        break;

      default:
        break;
      }
    }
    break;

  case 2:
    //  INITIAL WAIT
    if (!--door->topcountdown)
    {
      switch(door->type)
      {
      case raiseIn5Mins:
        door->direction = 1;
        door->type = normal;
        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 blazeRaise:
      case blazeClose:
        door->sector->specialdata = NULL;
        P_RemoveThinker (&door->thinker);  // unlink and free
        break;

      case normal:
      case close:
        door->sector->specialdata = NULL;
        P_RemoveThinker (&door->thinker);  // unlink and free
        break;

      case close30ThenOpen:
        door->direction = 0;
        door->topcountdown = 35*30;
        break;

      default:
        break;
      }
    }
    else if (res == crushed)
    {
      switch(door->type)
      {
      case blazeClose:
      case close:		// DO NOT 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 == pastdest)
    {
      switch(door->type)
      {
      case blazeRaise:
      case normal:
        door->direction = 0; // wait at top
        door->topcountdown = door->topwait;
        break;

      case close30ThenOpen:
      case blazeOpen:
      case open:
        door->sector->specialdata = NULL;
        P_RemoveThinker (&door->thinker);  // unlink and free
        break;

      default:
        break;
      }
    }
    break;
  }
}


//
// EV_DoLockedDoor
// Move a locked door up/down
//

int EV_DoLockedDoor(line_t*	line, vldoor_e	type, mobj_t*	thing )
{
  player_t*	p;

  p = thing->player;

  if (!p)
    return 0;

  switch(line->special)
  {
  case 99:	// Blue Lock
  case 133:
    if ( !p )
      return 0;
    if (!p->cards[it_bluecard] && !p->cards[it_blueskull])
    {
      p->message = PD_BLUEO;
      return 0;
    }
    break;

  case 134: // Red Lock
  case 135:
    if ( !p )
      return 0;
    if (!p->cards[it_redcard] && !p->cards[it_redskull])
    {
      p->message = PD_REDO;
      return 0;
    }
    break;

  case 136:	// Yellow Lock
  case 137:
    if ( !p )
      return 0;
    if (!p->cards[it_yellowcard] &&
      !p->cards[it_yellowskull])
    {
      p->message = PD_YELLOWO;
      return 0;
    }
    break;
  }

  return EV_DoDoor(line,type);
}


int EV_DoDoor( line_t*	line, vldoor_e	type )
{
  int secnum,rtn;
  sector_t*	sec;
  vldoor_t*	door;

  secnum = -1;
  rtn = 0;

  while ((secnum = P_FindSectorFromLineTag(line,secnum)) >= 0)
  {
    sec = &sectors[secnum];
    if (sec->specialdata)
      continue;


    // new door thinker
    rtn = 1;
    door = (vldoor_t *)Z_Malloc (sizeof(*door), PU_LEVSPEC, 0);
    P_AddThinker (&door->thinker, door);
    sec->specialdata = door;

    door->thinker.function = TT_VerticalDoor;
    door->sector = sec;
    door->type = type;
    door->topwait = VDOORWAIT;
    door->speed = VDOORSPEED;

    switch(type)
    {
    case blazeClose:
      door->topheight = P_FindLowestCeilingSurrounding(sec);
      door->topheight -= 4*FRACUNIT;
      door->direction = -1;
      door->speed = VDOORSPEED * 4;
      break;

    case close:
      door->topheight = P_FindLowestCeilingSurrounding(sec);
      door->topheight -= 4*FRACUNIT;
      door->direction = -1;
      break;

    case close30ThenOpen:
      door->topheight = sec->ceilingheight;
      door->direction = -1;
      break;

    case blazeRaise:
    case blazeOpen:
      door->direction = 1;
      door->topheight = P_FindLowestCeilingSurrounding(sec);
      door->topheight -= 4*FRACUNIT;
      door->speed = VDOORSPEED * 4;
      break;

    case normal:
    case open:
      door->direction = 1;
      door->topheight = P_FindLowestCeilingSurrounding(sec);
      door->topheight -= 4*FRACUNIT;
      break;

    default:
      break;
    }
  }
  return rtn;
}


//
// EV_VerticalDoor : open a door manually, no tag value
//
void EV_VerticalDoor( line_t*	line,  mobj_t*	thing )
{
  player_t*	player;
  int		secnum;
  sector_t*	sec;
  vldoor_t*	door;
  int		side;

  side = 0;	// only front sides can be used

  //	Check for locks
  player = thing->player;

  switch(line->special)
  {
  case 26: // Blue Lock
  case 32:
    if ( !player )
      return;

    if (!player->cards[it_bluecard] && !player->cards[it_blueskull])
    {
      player->message = PD_BLUEK;
      return;
    }
    break;

  case 27: // Yellow Lock
  case 34:
    if ( !player )
      return;

    if (!player->cards[it_yellowcard] &&!player->cards[it_yellowskull])
    {
      player->message = PD_YELLOWK;
      return;
    }
    break;

  case 28: // Red Lock
  case 33:
    if ( !player )
      return;

    if (!player->cards[it_redcard] && !player->cards[it_redskull])
    {
      player->message = PD_REDK;
      return;
    }
    break;
  }

  // if the sector has an active thinker, use it
  sec = sides[ line->sidenum[side^1]] .sector;
  secnum = sec-sectors;

  if (sec->specialdata)
  {
    door = (vldoor_t *)sec->specialdata;
    switch(line->special)
    {
    case	1: // ONLY FOR "RAISE" DOORS, NOT "OPEN"s
    case	26:
    case	27:
    case	28:
    case	117:
      if (door->direction == -1)
        door->direction = 1;	// go back up
      else
      {
        if (!thing->player)
          return;     // JDC: bad guys never close doors

        door->direction = -1;	// start going down immediately
      }
      return;
    }
  }
  // new door thinker
  door = (vldoor_t *)Z_Malloc (sizeof(*door), PU_LEVSPEC, 0);
  P_AddThinker (&door->thinker, door);
  sec->specialdata = door;
  door->thinker.function = TT_VerticalDoor;
  door->sector = sec;
  door->direction = 1;
  door->speed = VDOORSPEED;
  door->topwait = VDOORWAIT;

  switch(line->special)
  {
  case 1:
  case 26:
  case 27:
  case 28:
    door->type = normal;
    break;

  case 31:
  case 32:
  case 33:
  case 34:
    door->type = open;
    line->special = 0;
    break;

  case 117:	// blazing door raise
    door->type = blazeRaise;
    door->speed = VDOORSPEED*4;
    break;
  case 118:	// blazing door open
    door->type = blazeOpen;
    line->special = 0;
    door->speed = VDOORSPEED*4;
    break;
  }

  // find the top and bottom of the movement range
  door->topheight = P_FindLowestCeilingSurrounding(sec);
  door->topheight -= 4*FRACUNIT;
}


//
// Spawn a door that closes after 30 seconds
//
void P_SpawnDoorCloseIn30 (sector_t* sec)
{
  vldoor_t*	door;

  door = (vldoor_t *)Z_Malloc ( sizeof(*door), PU_LEVSPEC, 0);

  P_AddThinker (&door->thinker,door);

  sec->specialdata = door;
  sec->special = 0;

  door->thinker.function = TT_VerticalDoor;
  door->sector = sec;
  door->direction = 0;
  door->type = normal;
  door->speed = VDOORSPEED;
  door->topcountdown = 30 * 35;
}

//
// Spawn a door that opens after 5 minutes
//
void P_SpawnDoorRaiseIn5Mins( sector_t*	sec, int secnum )
{
  vldoor_t*	door;

  door = (vldoor_t *)Z_Malloc ( sizeof(*door), PU_LEVSPEC, 0);

  P_AddThinker (&door->thinker, door);

  sec->specialdata = door;
  sec->special = 0;

  door->thinker.function = TT_VerticalDoor;
  door->sector = sec;
  door->direction = 2;
  door->type = raiseIn5Mins;
  door->speed = VDOORSPEED;
  door->topheight = P_FindLowestCeilingSurrounding(sec);
  door->topheight -= 4*FRACUNIT;
  door->topwait = VDOORWAIT;
  door->topcountdown = 5 * 60 * 35;

  secnum= 0; //Shut up, GCC
}