DOOM-3-BFG

p_spec.cpp (26591B)

---

 /*
 ===========================================================================
 
 Doom 3 BFG Edition GPL Source Code
 Copyright (C) 1993-2012 id Software LLC, a ZeniMax Media company. 
 
 This file is part of the Doom 3 BFG Edition GPL Source Code ("Doom 3 BFG Edition Source Code").  
 
 Doom 3 BFG Edition Source Code is free software: you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation, either version 3 of the License, or
 (at your option) any later version.
 
 Doom 3 BFG Edition Source Code is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with Doom 3 BFG Edition Source Code.  If not, see <http://www.gnu.org/licenses/>.
 
 In addition, the Doom 3 BFG Edition Source Code is also subject to certain additional terms. You should have received a copy of these additional terms immediately following the terms and conditions of the GNU General Public License which accompanied the Doom 3 BFG Edition Source Code.  If not, please request a copy in writing from id Software at the address below.
 
 If you have questions concerning this license or the applicable additional terms, you may contact in writing id Software LLC, c/o ZeniMax Media Inc., Suite 120, Rockville, Maryland 20850 USA.
 
 ===========================================================================
 */
 
 #include "Precompiled.h"
 #include "globaldata.h"
 #include "Main.h"
 
 #include <stdlib.h>
 
 #include "doomdef.h"
 #include "doomstat.h"
 
 #include "i_system.h"
 #include "z_zone.h"
 #include "m_argv.h"
 #include "m_random.h"
 #include "w_wad.h"
 
 #include "r_local.h"
 #include "p_local.h"
 
 #include "g_game.h"
 
 #include "s_sound.h"
 
 // State.
 #include "r_state.h"
 
 // Data.
 #include "sounds.h"
 
 #include "../../neo/d3xp/Game_Local.h"
 
 //
 // Animating textures and planes
 // There is another anim_t used in wi_stuff, unrelated. BLAH!
 // we now use anim_t2
 //
 
 //
 //      source animation definition
 //
 
 
 
 
 
 //
 // P_InitPicAnims
 //
 
 // Floor/ceiling animation sequences,
 //  defined by first and last frame,
 //  i.e. the flat (64x64 tile) name to
 //  be used.
 // The full animation sequence is given
 //  using all the flats between the start
 //  and end entry, in the order found in
 //  the WAD file.
 //
 const animdef_t		animdefs[] =
 {
 	{false,	"NUKAGE3",	"NUKAGE1",	8},
 	{false,	"FWATER4",	"FWATER1",	8},
 	{false,	"SWATER4",	"SWATER1", 	8},
 	{false,	"LAVA4",	"LAVA1",	8},
 	{false,	"BLOOD3",	"BLOOD1",	8},
 
 	// DOOM II flat animations.
 	{false,	"RROCK08",	"RROCK05",	8},		
 	{false,	"SLIME04",	"SLIME01",	8},
 	{false,	"SLIME08",	"SLIME05",	8},
 	{false,	"SLIME12",	"SLIME09",	8},
 
 	{true,	"BLODGR4",	"BLODGR1",	8},
 	{true,	"SLADRIP3",	"SLADRIP1",	8},
 
 	{true,	"BLODRIP4",	"BLODRIP1",	8},
 	{true,	"FIREWALL",	"FIREWALA",	8},
 	{true,	"GSTFONT3",	"GSTFONT1",	8},
 	{true,	"FIRELAVA",	"FIRELAV3",	8},
 	{true,	"FIREMAG3",	"FIREMAG1",	8},
 	{true,	"FIREBLU2",	"FIREBLU1",	8},
 	{true,	"ROCKRED3",	"ROCKRED1",	8},
 
 	{true,	"BFALL4",	"BFALL1",	8},
 	{true,	"SFALL4",	"SFALL1",	8},
 	{true,	"WFALL4",	"WFALL1",	8},
 	{true,	"DBRAIN4",	"DBRAIN1",	8},
 
 	{-1}
 };
 
 
 
 //
 //      Animating line specials
 //
 
 
 
 
 void P_InitPicAnims (void)
 {
 	int		i;
 
 
 	//	Init animation
 	::g->lastanim = ::g->anims;
 	for (i=0 ; animdefs[i].istexture != (qboolean)-1 ; i++)
 	{
 		if (animdefs[i].istexture)
 		{
 			// different episode ?
 			if (R_CheckTextureNumForName(animdefs[i].startname) == -1)
 				continue;	
 
 			::g->lastanim->picnum = R_TextureNumForName (animdefs[i].endname);
 			::g->lastanim->basepic = R_TextureNumForName (animdefs[i].startname);
 		}
 		else
 		{
 			if (W_CheckNumForName(animdefs[i].startname) == -1)
 				continue;
 
 			::g->lastanim->picnum = R_FlatNumForName (animdefs[i].endname);
 			::g->lastanim->basepic = R_FlatNumForName (animdefs[i].startname);
 		}
 
 		::g->lastanim->istexture = animdefs[i].istexture;
 		::g->lastanim->numpics = ::g->lastanim->picnum - ::g->lastanim->basepic + 1;
 
 		if (::g->lastanim->numpics < 2)
 			I_Error ("P_InitPicAnims: bad cycle from %s to %s",
 			animdefs[i].startname,
 			animdefs[i].endname);
 
 		::g->lastanim->speed = animdefs[i].speed;
 		::g->lastanim++;
 	}
 
 }
 
 
 
 //
 // UTILITIES
 //
 
 
 
 //
 // getSide()
 // Will return a side_t*
 //  given the number of the current sector,
 //  the line number, and the side (0/1) that you want.
 //
 side_t*
 getSide
 ( int		currentSector,
  int		line,
  int		side )
 {
 	return &::g->sides[ (::g->sectors[currentSector].lines[line])->sidenum[side] ];
 }
 
 
 //
 // getSector()
 // Will return a sector_t*
 //  given the number of the current sector,
 //  the line number and the side (0/1) that you want.
 //
 sector_t*
 getSector
 ( int		currentSector,
  int		line,
  int		side )
 {
 	return ::g->sides[ (::g->sectors[currentSector].lines[line])->sidenum[side] ].sector;
 }
 
 
 //
 // twoSided()
 // Given the sector number and the line number,
 //  it will tell you whether the line is two-sided or not.
 //
 int
 twoSided
 ( int	sector,
  int	line )
 {
 	return (::g->sectors[sector].lines[line])->flags & ML_TWOSIDED;
 }
 
 
 
 
 //
 // getNextSector()
 // Return sector_t * of sector next to current.
 // NULL if not two-sided line
 //
 sector_t*
 getNextSector
 ( line_t*	line,
  sector_t*	sec )
 {
 	if (!(line->flags & ML_TWOSIDED))
 		return NULL;
 
 	if (line->frontsector == sec)
 		return line->backsector;
 
 	return line->frontsector;
 }
 
 
 
 //
 // P_FindLowestFloorSurrounding()
 // FIND LOWEST FLOOR HEIGHT IN SURROUNDING SECTORS
 //
 fixed_t	P_FindLowestFloorSurrounding(sector_t* sec)
 {
 	int			i;
 	line_t*		check;
 	sector_t*		other;
 	fixed_t		floor = sec->floorheight;
 
 	for (i=0 ;i < sec->linecount ; i++)
 	{
 		check = sec->lines[i];
 		other = getNextSector(check,sec);
 
 		if (!other)
 			continue;
 
 		if (other->floorheight < floor)
 			floor = other->floorheight;
 	}
 	return floor;
 }
 
 
 
 //
 // P_FindHighestFloorSurrounding()
 // FIND HIGHEST FLOOR HEIGHT IN SURROUNDING SECTORS
 //
 fixed_t	P_FindHighestFloorSurrounding(sector_t *sec)
 {
 	int			i;
 	line_t*		check;
 	sector_t*		other;
 	fixed_t		floor = -500*FRACUNIT;
 
 	for (i=0 ;i < sec->linecount ; i++)
 	{
 		check = sec->lines[i];
 		other = getNextSector(check,sec);
 
 		if (!other)
 			continue;
 
 		if (other->floorheight > floor)
 			floor = other->floorheight;
 	}
 	return floor;
 }
 
 
 
 //
 // P_FindNextHighestFloor
 // FIND NEXT HIGHEST FLOOR IN SURROUNDING SECTORS
 // Note: this should be doable w/o a fixed array.
 
 // 20 adjoining ::g->sectors max!
 
 fixed_t
 P_FindNextHighestFloor
 ( sector_t*	sec,
  int		currentheight )
 {
 	int			i;
 	int			h;
 	int			min;
 	line_t*		check;
 	sector_t*		other;
 	fixed_t		height = currentheight;
 
 
 	fixed_t		heightlist[MAX_ADJOINING_SECTORS];		
 
 	for (i=0, h=0 ;i < sec->linecount ; i++)
 	{
 		check = sec->lines[i];
 		other = getNextSector(check,sec);
 
 		if (!other)
 			continue;
 
 		if (other->floorheight > height)
 			heightlist[h++] = other->floorheight;
 
 		// Check for overflow. Exit.
 		if ( h >= MAX_ADJOINING_SECTORS )
 		{
 			I_PrintfE("Sector with more than 20 adjoining sectors\n" );
 			break;
 		}
 	}
 
 	// Find lowest height in list
 	if (!h)
 		return currentheight;
 
 	min = heightlist[0];
 
 	// Range checking? 
 	for (i = 1;i < h;i++)
 		if (heightlist[i] < min)
 			min = heightlist[i];
 
 	return min;
 }
 
 
 //
 // FIND LOWEST CEILING IN THE SURROUNDING SECTORS
 //
 fixed_t
 P_FindLowestCeilingSurrounding(sector_t* sec)
 {
 	int			i;
 	line_t*		check;
 	sector_t*		other;
 	fixed_t		height = MAXINT;
 
 	for (i=0 ;i < sec->linecount ; i++)
 	{
 		check = sec->lines[i];
 		other = getNextSector(check,sec);
 
 		if (!other)
 			continue;
 
 		if (other->ceilingheight < height)
 			height = other->ceilingheight;
 	}
 	return height;
 }
 
 
 //
 // FIND HIGHEST CEILING IN THE SURROUNDING SECTORS
 //
 fixed_t	P_FindHighestCeilingSurrounding(sector_t* sec)
 {
 	int		i;
 	line_t*	check;
 	sector_t*	other;
 	fixed_t	height = 0;
 
 	for (i=0 ;i < sec->linecount ; i++)
 	{
 		check = sec->lines[i];
 		other = getNextSector(check,sec);
 
 		if (!other)
 			continue;
 
 		if (other->ceilingheight > height)
 			height = other->ceilingheight;
 	}
 	return height;
 }
 
 
 
 //
 // RETURN NEXT SECTOR # THAT LINE TAG REFERS TO
 //
 int
 P_FindSectorFromLineTag
 ( line_t*	line,
  int		start )
 {
 	int	i;
 
 	for (i = start+1; i < ::g->numsectors; i++)
 		if (::g->sectors[i].tag == line->tag)
 			return i;
 
 	return -1;
 }
 
 
 
 
 //
 // Find minimum light from an adjacent sector
 //
 int
 P_FindMinSurroundingLight
 ( sector_t*	sector,
  int		max )
 {
 	int		i;
 	int		min;
 	line_t*	line;
 	sector_t*	check;
 
 	min = max;
 	for (i=0 ; i < sector->linecount ; i++)
 	{
 		line = sector->lines[i];
 		check = getNextSector(line,sector);
 
 		if (!check)
 			continue;
 
 		if (check->lightlevel < min)
 			min = check->lightlevel;
 	}
 	return min;
 }
 
 
 
 //
 // EVENTS
 // Events are operations triggered by using, crossing,
 // or shooting special ::g->lines, or by timed thinkers.
 //
 
 //
 // P_CrossSpecialLine - TRIGGER
 // Called every time a thing origin is about
 //  to cross a line with a non 0 special.
 //
 void
 P_CrossSpecialLine
 ( int		linenum,
  int		side,
  mobj_t*	thing )
 {
 	line_t*	line;
 	int		ok;
 
 	line = &::g->lines[linenum];
 
 	//	Triggers that other things can activate
 	if (!thing->player)
 	{
 		// Things that should NOT trigger specials...
 		switch(thing->type)
 		{
 		case MT_ROCKET:
 		case MT_PLASMA:
 		case MT_BFG:
 		case MT_TROOPSHOT:
 		case MT_HEADSHOT:
 		case MT_BRUISERSHOT:
 			return;
 			break;
 
 		default: break;
 		}
 
 		ok = 0;
 		switch(line->special)
 		{
 		case 39:	// TELEPORT TRIGGER
 		case 97:	// TELEPORT RETRIGGER
 		case 125:	// TELEPORT MONSTERONLY TRIGGER
 		case 126:	// TELEPORT MONSTERONLY RETRIGGER
 		case 4:	// RAISE DOOR
 		case 10:	// PLAT DOWN-WAIT-UP-STAY TRIGGER
 		case 88:	// PLAT DOWN-WAIT-UP-STAY RETRIGGER
 			ok = 1;
 			break;
 		}
 		if (!ok)
 			return;
 	}
 
 
 	// Note: could use some const's here.
 	switch (line->special)
 	{
 		// TRIGGERS.
 		// All from here to RETRIGGERS.
 	case 2:
 		// Open Door
 		EV_DoDoor(line,opened);
 		line->special = 0;
 		break;
 
 	case 3:
 		// Close Door
 		EV_DoDoor(line,closed);
 		line->special = 0;
 		break;
 
 	case 4:
 		// Raise Door
 		EV_DoDoor(line,normal);
 		line->special = 0;
 		break;
 
 	case 5:
 		// Raise Floor
 		EV_DoFloor(line,raiseFloor);
 		line->special = 0;
 		break;
 
 	case 6:
 		// Fast Ceiling Crush & Raise
 		EV_DoCeiling(line,fastCrushAndRaise);
 		line->special = 0;
 		break;
 
 	case 8:
 		// Build Stairs
 		EV_BuildStairs(line,build8);
 		line->special = 0;
 		break;
 
 	case 10:
 		// PlatDownWaitUp
 		EV_DoPlat(line,downWaitUpStay,0);
 		line->special = 0;
 		break;
 
 	case 12:
 		// Light Turn On - brightest near
 		EV_LightTurnOn(line,0);
 		line->special = 0;
 		break;
 
 	case 13:
 		// Light Turn On 255
 		EV_LightTurnOn(line,255);
 		line->special = 0;
 		break;
 
 	case 16:
 		// Close Door 30
 		EV_DoDoor(line,close30ThenOpen);
 		line->special = 0;
 		break;
 
 	case 17:
 		// Start Light Strobing
 		EV_StartLightStrobing(line);
 		line->special = 0;
 		break;
 
 	case 19:
 		// Lower Floor
 		EV_DoFloor(line,lowerFloor);
 		line->special = 0;
 		break;
 
 	case 22:
 		// Raise floor to nearest height and change texture
 		EV_DoPlat(line,raiseToNearestAndChange,0);
 		line->special = 0;
 		break;
 
 	case 25:
 		// Ceiling Crush and Raise
 		EV_DoCeiling(line,crushAndRaise);
 		line->special = 0;
 		break;
 
 	case 30:
 		// Raise floor to shortest texture height
 		//  on either side of ::g->lines.
 		EV_DoFloor(line,raiseToTexture);
 		line->special = 0;
 		break;
 
 	case 35:
 		// Lights Very Dark
 		EV_LightTurnOn(line,35);
 		line->special = 0;
 		break;
 
 	case 36:
 		// Lower Floor (TURBO)
 		EV_DoFloor(line,turboLower);
 		line->special = 0;
 		break;
 
 	case 37:
 		// LowerAndChange
 		EV_DoFloor(line,lowerAndChange);
 		line->special = 0;
 		break;
 
 	case 38:
 		// Lower Floor To Lowest
 		EV_DoFloor( line, lowerFloorToLowest );
 		line->special = 0;
 		break;
 
 	case 39:
 		// TELEPORT!
 		EV_Teleport( line, side, thing );
 		line->special = 0;
 		break;
 
 	case 40:
 		// RaiseCeilingLowerFloor
 		EV_DoCeiling( line, raiseToHighest );
 		EV_DoFloor( line, lowerFloorToLowest );
 		line->special = 0;
 		break;
 
 	case 44:
 		// Ceiling Crush
 		EV_DoCeiling( line, lowerAndCrush );
 		line->special = 0;
 		break;
 
 	case 52:
 		// EXIT!
 		// DHM - Nerve :: Don't exit level in death match, timelimit and fraglimit only
 		if ( !::g->deathmatch && ::g->gameaction != ga_completed ) {
 			G_ExitLevel();
 		}
 		break;
 
 	case 53:
 		// Perpetual Platform Raise
 		EV_DoPlat(line,perpetualRaise,0);
 		line->special = 0;
 		break;
 
 	case 54:
 		// Platform Stop
 		EV_StopPlat(line);
 		line->special = 0;
 		break;
 
 	case 56:
 		// Raise Floor Crush
 		EV_DoFloor(line,raiseFloorCrush);
 		line->special = 0;
 		break;
 
 	case 57:
 		// Ceiling Crush Stop
 		EV_CeilingCrushStop(line);
 		line->special = 0;
 		break;
 
 	case 58:
 		// Raise Floor 24
 		EV_DoFloor(line,raiseFloor24);
 		line->special = 0;
 		break;
 
 	case 59:
 		// Raise Floor 24 And Change
 		EV_DoFloor(line,raiseFloor24AndChange);
 		line->special = 0;
 		break;
 
 	case 104:
 		// Turn lights off in sector(tag)
 		EV_TurnTagLightsOff(line);
 		line->special = 0;
 		break;
 
 	case 108:
 		// Blazing Door Raise (faster than TURBO!)
 		EV_DoDoor (line,blazeRaise);
 		line->special = 0;
 		break;
 
 	case 109:
 		// Blazing Door Open (faster than TURBO!)
 		EV_DoDoor (line,blazeOpen);
 		line->special = 0;
 		break;
 
 	case 100:
 		// Build Stairs Turbo 16
 		EV_BuildStairs(line,turbo16);
 		line->special = 0;
 		break;
 
 	case 110:
 		// Blazing Door Close (faster than TURBO!)
 		EV_DoDoor (line,blazeClose);
 		line->special = 0;
 		break;
 
 	case 119:
 		// Raise floor to nearest surr. floor
 		EV_DoFloor(line,raiseFloorToNearest);
 		line->special = 0;
 		break;
 
 	case 121:
 		// Blazing PlatDownWaitUpStay
 		EV_DoPlat(line,blazeDWUS,0);
 		line->special = 0;
 		break;
 
 	case 124:
 		// Secret EXIT
 		if ( !::g->deathmatch && ::g->gameaction != ga_completed ) {
 			G_SecretExitLevel ();
 		}
 		break;
 
 	case 125:
 		// TELEPORT MonsterONLY
 		if (!thing->player)
 		{
 			EV_Teleport( line, side, thing );
 			line->special = 0;
 		}
 		break;
 
 	case 130:
 		// Raise Floor Turbo
 		EV_DoFloor(line,raiseFloorTurbo);
 		line->special = 0;
 		break;
 
 	case 141:
 		// Silent Ceiling Crush & Raise
 		EV_DoCeiling(line,silentCrushAndRaise);
 		line->special = 0;
 		break;
 
 		// RETRIGGERS.  All from here till end.
 	case 72:
 		// Ceiling Crush
 		EV_DoCeiling( line, lowerAndCrush );
 		break;
 
 	case 73:
 		// Ceiling Crush and Raise
 		EV_DoCeiling(line,crushAndRaise);
 		break;
 
 	case 74:
 		// Ceiling Crush Stop
 		EV_CeilingCrushStop(line);
 		break;
 
 	case 75:
 		// Close Door
 		EV_DoDoor(line,closed);
 		break;
 
 	case 76:
 		// Close Door 30
 		EV_DoDoor(line,close30ThenOpen);
 		break;
 
 	case 77:
 		// Fast Ceiling Crush & Raise
 		EV_DoCeiling(line,fastCrushAndRaise);
 		break;
 
 	case 79:
 		// Lights Very Dark
 		EV_LightTurnOn(line,35);
 		break;
 
 	case 80:
 		// Light Turn On - brightest near
 		EV_LightTurnOn(line,0);
 		break;
 
 	case 81:
 		// Light Turn On 255
 		EV_LightTurnOn(line,255);
 		break;
 
 	case 82:
 		// Lower Floor To Lowest
 		EV_DoFloor( line, lowerFloorToLowest );
 		break;
 
 	case 83:
 		// Lower Floor
 		EV_DoFloor(line,lowerFloor);
 		break;
 
 	case 84:
 		// LowerAndChange
 		EV_DoFloor(line,lowerAndChange);
 		break;
 
 	case 86:
 		// Open Door
 		EV_DoDoor(line,opened);
 		break;
 
 	case 87:
 		// Perpetual Platform Raise
 		EV_DoPlat(line,perpetualRaise,0);
 		break;
 
 	case 88:
 		// PlatDownWaitUp
 		EV_DoPlat(line,downWaitUpStay,0);
 		break;
 
 	case 89:
 		// Platform Stop
 		EV_StopPlat(line);
 		break;
 
 	case 90:
 		// Raise Door
 		EV_DoDoor(line,normal);
 		break;
 
 	case 91:
 		// Raise Floor
 		EV_DoFloor(line,raiseFloor);
 		break;
 
 	case 92:
 		// Raise Floor 24
 		EV_DoFloor(line,raiseFloor24);
 		break;
 
 	case 93:
 		// Raise Floor 24 And Change
 		EV_DoFloor(line,raiseFloor24AndChange);
 		break;
 
 	case 94:
 		// Raise Floor Crush
 		EV_DoFloor(line,raiseFloorCrush);
 		break;
 
 	case 95:
 		// Raise floor to nearest height
 		// and change texture.
 		EV_DoPlat(line,raiseToNearestAndChange,0);
 		break;
 
 	case 96:
 		// Raise floor to shortest texture height
 		// on either side of ::g->lines.
 		EV_DoFloor(line,raiseToTexture);
 		break;
 
 	case 97:
 		// TELEPORT!
 		EV_Teleport( line, side, thing );
 		break;
 
 	case 98:
 		// Lower Floor (TURBO)
 		EV_DoFloor(line,turboLower);
 		break;
 
 	case 105:
 		// Blazing Door Raise (faster than TURBO!)
 		EV_DoDoor (line,blazeRaise);
 		break;
 
 	case 106:
 		// Blazing Door Open (faster than TURBO!)
 		EV_DoDoor (line,blazeOpen);
 		break;
 
 	case 107:
 		// Blazing Door Close (faster than TURBO!)
 		EV_DoDoor (line,blazeClose);
 		break;
 
 	case 120:
 		// Blazing PlatDownWaitUpStay.
 		EV_DoPlat(line,blazeDWUS,0);
 		break;
 
 	case 126:
 		// TELEPORT MonsterONLY.
 		if (!thing->player)
 			EV_Teleport( line, side, thing );
 		break;
 
 	case 128:
 		// Raise To Nearest Floor
 		EV_DoFloor(line,raiseFloorToNearest);
 		break;
 
 	case 129:
 		// Raise Floor Turbo
 		EV_DoFloor(line,raiseFloorTurbo);
 		break;
 	}
 }
 
 
 
 //
 // P_ShootSpecialLine - IMPACT SPECIALS
 // Called when a thing shoots a special line.
 //
 void
 P_ShootSpecialLine
 ( mobj_t*	thing,
  line_t*	line )
 {
 	int		ok;
 
 	//	Impacts that other things can activate.
 	if (!thing->player)
 	{
 		ok = 0;
 		switch(line->special)
 		{
 		case 46:
 			// OPEN DOOR IMPACT
 			ok = 1;
 			break;
 		}
 		if (!ok)
 			return;
 	}
 
 	switch(line->special)
 	{
 	case 24:
 		// RAISE FLOOR
 		EV_DoFloor(line,raiseFloor);
 		P_ChangeSwitchTexture(line,0);
 		break;
 
 	case 46:
 		// OPEN DOOR
 		EV_DoDoor(line,opened);
 		P_ChangeSwitchTexture(line,1);
 		break;
 
 	case 47:
 		// RAISE FLOOR NEAR AND CHANGE
 		EV_DoPlat(line,raiseToNearestAndChange,0);
 		P_ChangeSwitchTexture(line,0);
 		break;
 	}
 }
 
 
 
 //
 // P_PlayerInSpecialSector
 // Called every tic frame
 //  that the player origin is in a special sector
 //
 void P_PlayerInSpecialSector (player_t* player)
 {
 	sector_t*	sector;
 
 	sector = player->mo->subsector->sector;
 
 	// Falling, not all the way down yet?
 	if (player->mo->z != sector->floorheight)
 		return;	
 
 	// Has hitten ground.
 	switch (sector->special)
 	{
 	case 5:
 		// HELLSLIME DAMAGE
 		if (!player->powers[pw_ironfeet])
 			if (!(::g->leveltime&0x1f))
 				P_DamageMobj (player->mo, NULL, NULL, 10);
 		break;
 
 	case 7:
 		// NUKAGE DAMAGE
 		if (!player->powers[pw_ironfeet])
 			if (!(::g->leveltime&0x1f))
 				P_DamageMobj (player->mo, NULL, NULL, 5);
 		break;
 
 	case 16:
 		// SUPER HELLSLIME DAMAGE
 	case 4:
 		// STROBE HURT
 		if (!player->powers[pw_ironfeet]
 		|| (P_Random()<5) )
 		{
 			if (!(::g->leveltime&0x1f))
 				P_DamageMobj (player->mo, NULL, NULL, 20);
 		}
 		break;
 
 	case 9:
 		// SECRET SECTOR
 		player->secretcount++;
 		sector->special = 0;
 
 
 		if ( !::g->demoplayback && ( ::g->usergame && !::g->netgame ) ) {
 			// DHM - Nerve :: Let's give achievements in real time in Doom 2
 			if ( !common->IsMultiplayer() ) {
 				switch( DoomLib::GetGameSKU() ) {
 					case GAME_SKU_DOOM1_BFG: {
 						// Removing trophies for DOOM and DOOM II BFG due to point limit.
 						//gameLocal->UnlockAchievement( Doom1BFG_Trophies::SCOUT_FIND_ANY_SECRET );
 						break;
 					}
 					case GAME_SKU_DOOM2_BFG: {
 						//gameLocal->UnlockAchievement( Doom2BFG_Trophies::IMPORTANT_LOOKING_DOOR_FIND_ANY_SECRET );
 						idAchievementManager::LocalUser_CompleteAchievement(ACHIEVEMENT_DOOM2_IMPORTANT_LOOKING_DOOR_FIND_ANY_SECRET );
 						break;
 					}
 					case GAME_SKU_DCC: {
 						// Not on PC.
 						//gameLocal->UnlockAchievement( DOOM_ACHIEVEMENT_FIND_SECRET );
 						break;
 					}
 					default: {
 						// No unlocks for other SKUs.
 						break;
 					}
 				}
 			}
 		}
 
 
 		break;
 
 	case 11:
 		// EXIT SUPER DAMAGE! (for E1M8 finale)
 		player->cheats &= ~CF_GODMODE;
 
 		if (!(::g->leveltime&0x1f))
 			P_DamageMobj (player->mo, NULL, NULL, 20);
 
 		if (player->health <= 10)
 			G_ExitLevel();
 		break;
 
 	default:
 		I_Error ("P_PlayerInSpecialSector: "
 			"unknown special %i",
 			sector->special);
 		break;
 	};
 }
 
 
 
 
 //
 // P_UpdateSpecials
 // Animate planes, scroll walls, etc.
 //
 int PlayerFrags( int playernum ) {
 	int	frags = 0;
 
 	for( int i=0 ; i<MAXPLAYERS ; i++) {
 		if ( i != playernum ) {
 			frags += ::g->players[playernum].frags[i];
 		}
 	}
 
 	frags -= ::g->players[playernum].frags[playernum];
 
 	return frags;
 }
 
 void P_UpdateSpecials (void)
 {
 	anim_t2*	anim;
 	int		pic;
 	int		i;
 	line_t*	line;
 
 
 	//	LEVEL TIMER
 	if (::g->levelTimer == true)
 	{
 		::g->levelTimeCount--;
 		if (!::g->levelTimeCount)
 			G_ExitLevel();
 	}
 
 	// DHM - Nerve :: FRAG COUNT
 	if ( ::g->deathmatch && ::g->levelFragCount > 0 ) {
 		bool fragCountHit = false;
 
 		for ( int i=0; i<MAXPLAYERS; i++ ) {
 			if ( ::g->playeringame[i] ) {
 				if ( PlayerFrags(i) >= ::g->levelFragCount ) {
 					fragCountHit = true;
 				}
 			}
 		}
 
 		if ( fragCountHit ) {
 			G_ExitLevel();
 		}
 	}
 
 	//	ANIMATE FLATS AND TEXTURES GLOBALLY
 	for (anim = ::g->anims ; anim < ::g->lastanim ; anim++)
 	{
 		for (i=anim->basepic ; i<anim->basepic+anim->numpics ; i++)
 		{
 			pic = anim->basepic + ( (::g->leveltime/anim->speed + i)%anim->numpics );
 			if (anim->istexture)
 				::g->texturetranslation[i] = pic;
 			else
 				::g->flattranslation[i] = pic;
 		}
 	}
 
 
 	//	ANIMATE LINE SPECIALS
 	for (i = 0; i < ::g->numlinespecials; i++)
 	{
 		line = ::g->linespeciallist[i];
 		switch(line->special)
 		{
 		case 48:
 			// EFFECT FIRSTCOL SCROLL +
 			::g->sides[line->sidenum[0]].textureoffset += FRACUNIT;
 			break;
 		}
 	}
 
 
 	//	DO BUTTONS
 	for (i = 0; i < MAXBUTTONS; i++)
 		if (::g->buttonlist[i].btimer)
 		{
 			::g->buttonlist[i].btimer--;
 			if (!::g->buttonlist[i].btimer)
 			{
 				switch(::g->buttonlist[i].where)
 				{
 				case top:
 					::g->sides[::g->buttonlist[i].line->sidenum[0]].toptexture =
 						::g->buttonlist[i].btexture;
 					break;
 
 				case middle:
 					::g->sides[::g->buttonlist[i].line->sidenum[0]].midtexture =
 						::g->buttonlist[i].btexture;
 					break;
 
 				case bottom:
 					::g->sides[::g->buttonlist[i].line->sidenum[0]].bottomtexture =
 						::g->buttonlist[i].btexture;
 					break;
 				}
 				S_StartSound((mobj_t *)&::g->buttonlist[i].soundorg,sfx_swtchn);
 				memset(&::g->buttonlist[i],0,sizeof(button_t));
 			}
 		}
 
 }
 
 
 
 //
 // Special Stuff that can not be categorized
 //
 int EV_DoDonut(line_t*	line)
 {
 	sector_t*		s1;
 	sector_t*		s2;
 	sector_t*		s3;
 	int			secnum;
 	int			rtn;
 	int			i;
 	floormove_t*	floor;
 
 	secnum = -1;
 	rtn = 0;
 	while ((secnum = P_FindSectorFromLineTag(line,secnum)) >= 0)
 	{
 		s1 = &::g->sectors[secnum];
 
 		// ALREADY MOVING?  IF SO, KEEP GOING...
 		if (s1->specialdata)
 			continue;
 
 		rtn = 1;
 		s2 = getNextSector(s1->lines[0],s1);
 		for (i = 0;i < s2->linecount;i++)
 		{
 			if ((!(s2->lines[i]->flags & ML_TWOSIDED)) ||
 				(s2->lines[i]->backsector == s1))
 				continue;
 			s3 = s2->lines[i]->backsector;
 
 			//	Spawn rising slime
 			floor = (floormove_t*)DoomLib::Z_Malloc (sizeof(*floor), PU_LEVEL, 0);
 			P_AddThinker (&floor->thinker);
 			s2->specialdata = floor;
 			floor->thinker.function.acp1 = (actionf_p1) T_MoveFloor;
 			floor->type = donutRaise;
 			floor->crush = false;
 			floor->direction = 1;
 			floor->sector = s2;
 			floor->speed = FLOORSPEED / 2;
 			floor->texture = s3->floorpic;
 			floor->newspecial = 0;
 			floor->floordestheight = s3->floorheight;
 
 			//	Spawn lowering donut-hole
 			floor = (floormove_t*)DoomLib::Z_Malloc (sizeof(*floor), PU_LEVEL, 0);
 			P_AddThinker (&floor->thinker);
 			s1->specialdata = floor;
 			floor->thinker.function.acp1 = (actionf_p1) T_MoveFloor;
 			floor->type = lowerFloor;
 			floor->crush = false;
 			floor->direction = -1;
 			floor->sector = s1;
 			floor->speed = FLOORSPEED / 2;
 			floor->floordestheight = s3->floorheight;
 			break;
 		}
 	}
 	return rtn;
 }
 
 
 
 //
 // SPECIAL SPAWNING
 //
 
 //
 // P_SpawnSpecials
 // After the map has been loaded, scan for specials
 //  that spawn thinkers
 //
 
 
 // Parses command line parameters.
 void P_SpawnSpecials (void)
 {
 	sector_t*	sector;
 	int		i;
 	int		episode;
 
 	episode = 1;
 	if (W_CheckNumForName("texture2") >= 0)
 		episode = 2;
 
 
 	// See if -TIMER needs to be used.
 	::g->levelTimer = false;
 
 	i = M_CheckParm("-avg");
 	if (i && ::g->deathmatch)
 	{
 		::g->levelTimer = true;
 		::g->levelTimeCount = 20 * 60 * TICRATE;
 	}
 
 	//i = M_CheckParm("-timer");
 	//if (i && ::g->deathmatch)
 #ifdef ID_ENABLE_DOOM_CLASSIC_NETWORKING
 	const int timeLimit = session->GetActingGameStateLobbyBase().GetMatchParms().gameTimeLimit;
 #else
 	const int timeLimit = 0;
 #endif
 	if (timeLimit != 0 && g->deathmatch)
 	{
 		int	time;
 		//time = atoi(::g->myargv[i+1]) * 60 * 35;
 		time = timeLimit * 60 * TICRATE;
 		::g->levelTimer = true;
 		::g->levelTimeCount = time;
 	}
 
 	//i = M_CheckParm("-fraglimit");
 	//if (i && ::g->deathmatch)
 #ifdef ID_ENABLE_DOOM_CLASSIC_NETWORKING
 	const int fragLimit = gameLocal->GetMatchParms().GetScoreLimit();
 #else
 	const int fragLimit = 0;
 #endif
 	if (fragLimit != 0 && ::g->deathmatch)
 	{
 		//::g->levelFragCount = atoi(::g->myargv[i+1]);
 		::g->levelFragCount = fragLimit;
 	} else {
 		::g->levelFragCount = 0;
 	}
 
 	//	Init special SECTORs.
 	sector = ::g->sectors;
 	for (i=0 ; i < ::g->numsectors ; i++, sector++)
 	{
 		if (!sector->special)
 			continue;
 
 		switch (sector->special)
 		{
 		case 1:
 			// FLICKERING LIGHTS
 			P_SpawnLightFlash (sector);
 			break;
 
 		case 2:
 			// STROBE FAST
 			P_SpawnStrobeFlash(sector,FASTDARK,0);
 			break;
 
 		case 3:
 			// STROBE SLOW
 			P_SpawnStrobeFlash(sector,SLOWDARK,0);
 			break;
 
 		case 4:
 			// STROBE FAST/DEATH SLIME
 			P_SpawnStrobeFlash(sector,FASTDARK,0);
 			sector->special = 4;
 			break;
 
 		case 8:
 			// GLOWING LIGHT
 			P_SpawnGlowingLight(sector);
 			break;
 		case 9:
 			// SECRET SECTOR
 			::g->totalsecret++;
 			break;
 
 		case 10:
 			// DOOR CLOSE IN 30 SECONDS
 			P_SpawnDoorCloseIn30 (sector);
 			break;
 
 		case 12:
 			// SYNC STROBE SLOW
 			P_SpawnStrobeFlash (sector, SLOWDARK, 1);
 			break;
 
 		case 13:
 			// SYNC STROBE FAST
 			P_SpawnStrobeFlash (sector, FASTDARK, 1);
 			break;
 
 		case 14:
 			// DOOR RAISE IN 5 MINUTES
 			P_SpawnDoorRaiseIn5Mins (sector, i);
 			break;
 
 		case 17:
 			P_SpawnFireFlicker(sector);
 			break;
 		}
 	}
 
 
 	//	Init line EFFECTs
 	::g->numlinespecials = 0;
 	for (i = 0;i < ::g->numlines; i++)
 	{
 		switch(::g->lines[i].special)
 		{
 		case 48:
 			// EFFECT FIRSTCOL SCROLL+
 			::g->linespeciallist[::g->numlinespecials] = &::g->lines[i];
 			::g->numlinespecials++;
 			break;
 		}
 	}
 
 
 	//	Init other misc stuff
 	for (i = 0;i < MAXCEILINGS;i++)
 		::g->activeceilings[i] = NULL;
 
 	for (i = 0;i < MAXPLATS;i++)
 		::g->activeplats[i] = NULL;
 
 	for (i = 0;i < MAXBUTTONS;i++)
 		memset(&::g->buttonlist[i],0,sizeof(button_t));
 
 	// UNUSED: no horizonal sliders.
 	//	P_InitSlidingDoorFrames();
 }