/*
** p_lnspec.cpp
** Handles line specials
**
**---------------------------------------------------------------------------
** Copyright 1998-2007 Randy Heit
** All rights reserved.
**
** Redistribution and use in source and binary forms, with or without
** modification, are permitted provided that the following conditions
** are met:
**
** 1. Redistributions of source code must retain the above copyright
**    notice, this list of conditions and the following disclaimer.
** 2. Redistributions in binary form must reproduce the above copyright
**    notice, this list of conditions and the following disclaimer in the
**    documentation and/or other materials provided with the distribution.
** 3. The name of the author may not be used to endorse or promote products
**    derived from this software without specific prior written permission.
**
** THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
** IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
** OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
** IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
** INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
** NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
** THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
**---------------------------------------------------------------------------
**
** Each function returns true if it caused something to happen
** or false if it could not perform the desired action.
*/

#include "doomstat.h"
#include "p_local.h"
#include "p_lnspec.h"
#include "p_enemy.h"
#include "g_level.h"
#include "v_palette.h"
#include "a_sharedglobal.h"
#include "a_lightning.h"
#include "a_keys.h"
#include "gi.h"
#include "p_conversation.h"
#include "p_3dmidtex.h"
#include "d_net.h"
#include "d_event.h"
#include "gstrings.h"
#include "po_man.h"
#include "d_player.h"
#include "r_utility.h"
#include "fragglescript/t_fs.h"
#include "p_spec.h"
#include "g_levellocals.h"
#include "vm.h"
#include "p_destructible.h"
#include "s_sndseq.h"

// Remaps EE sector change types to Generic_Floor values. According to the Eternity Wiki:
/*
    0 : No texture or type change. ( = 0)
    1 : Copy texture, zero type; trigger model. ( = 1)
    2 : Copy texture, zero type; numeric model. ( = 1+4)
    3 : Copy texture, preserve type; trigger model. ( = 3)
    4 : Copy texture, preserve type; numeric model. ( = 3+4)
    5 : Copy texture and type; trigger model.  ( = 2)
    6 : Copy texture and type; numeric model.  ( = 2+4)
*/
static const uint8_t ChangeMap[8] = { 0, 1, 5, 3, 7, 2, 6, 0 };


#define FUNC(a) static int a (FLevelLocals *Level, line_t *ln, AActor *it, bool backSide, \
	int arg0, int arg1, int arg2, int arg3, int arg4)

#define SPEED(a)		((a) / 8.)
#define TICS(a)			(((a)*TICRATE)/35)
#define OCTICS(a)		(((a)*TICRATE)/8)
#define BYTEANGLE(a)	DAngle::fromDeg((a) * (360./256.))
#define CRUSH(a)		((a) > 0? (a) : -1)
#define CHANGE(a)		(((a) >= 0 && (a)<=7)? ChangeMap[a]:0)

static bool CRUSHTYPE(int a)
{
	return ((a) == 1 ? false : (a) == 2 ? true : gameinfo.gametype == GAME_Hexen);
}

static DCeiling::ECrushMode CRUSHTYPE(int a, bool withslowdown)
{
	static DCeiling::ECrushMode map[] = { DCeiling::ECrushMode::crushDoom, DCeiling::ECrushMode::crushHexen, DCeiling::ECrushMode::crushSlowdown };
	if (a >= 1 && a <= 3) return map[a - 1];
	if (gameinfo.gametype == GAME_Hexen) return DCeiling::ECrushMode::crushHexen;
	return withslowdown? DCeiling::ECrushMode::crushSlowdown : DCeiling::ECrushMode::crushDoom;
}

static FRandom pr_glass ("GlassBreak");

// There are aliases for the ACS specials that take names instead of numbers.
// This table maps them onto the real number-based specials.
uint8_t NamedACSToNormalACS[7] =
{
	ACS_Execute,
	ACS_Suspend,
	ACS_Terminate,
	ACS_LockedExecute,
	ACS_LockedExecuteDoor,
	ACS_ExecuteWithResult,
	ACS_ExecuteAlways,
};

FName MODtoDamageType (int mod)
{
	switch (mod)
	{
	default:	return NAME_None;			break;
	case 9:		return NAME_BFGSplash;		break;
	case 12:	return NAME_Drowning;		break;
	case 13:	return NAME_Slime;			break;
	case 14:	return NAME_Fire;			break;
	case 15:	return NAME_Crush;			break;
	case 16:	return NAME_Telefrag;		break;
	case 17:	return NAME_Falling;		break;
	case 18:	return NAME_Suicide;		break;
	case 20:	return NAME_Exit;			break;
	case 22:	return NAME_Melee;			break;
	case 23:	return NAME_Railgun;		break;
	case 24:	return NAME_Ice;			break;
	case 25:	return NAME_Disintegrate;	break;
	case 26:	return NAME_Poison;			break;
	case 27:	return NAME_Electric;		break;
	case 1000:	return NAME_Massacre;		break;
	}
}

FUNC(LS_NOP)
{
	return false;
}

FUNC(LS_Polyobj_RotateLeft)
// Polyobj_RotateLeft (po, speed, angle)
{
	return EV_RotatePoly (Level, ln, arg0, arg1, arg2, 1, false);
}

FUNC(LS_Polyobj_RotateRight)
// Polyobj_rotateRight (po, speed, angle)
{
	return EV_RotatePoly (Level, ln, arg0, arg1, arg2, -1, false);
}

FUNC(LS_Polyobj_Move)
// Polyobj_Move (po, speed, angle, distance)
{
	return EV_MovePoly (Level, ln, arg0, SPEED(arg1), BYTEANGLE(arg2), arg3, false);
}

FUNC(LS_Polyobj_MoveTimes8)
// Polyobj_MoveTimes8 (po, speed, angle, distance)
{
	return EV_MovePoly (Level, ln, arg0, SPEED(arg1), BYTEANGLE(arg2), arg3 * 8, false);
}

FUNC(LS_Polyobj_MoveTo)
// Polyobj_MoveTo (po, speed, x, y)
{
	return EV_MovePolyTo (Level, ln, arg0, SPEED(arg1), DVector2(arg2, arg3), false);
}

FUNC(LS_Polyobj_MoveToSpot)
// Polyobj_MoveToSpot (po, speed, tid)
{
	auto iterator = Level->GetActorIterator(arg2);
	AActor *spot = iterator.Next();
	if (spot == NULL) return false;
	return EV_MovePolyTo (Level, ln, arg0, SPEED(arg1), spot->Pos().XY(), false);
}

FUNC(LS_Polyobj_DoorSwing)
// Polyobj_DoorSwing (po, speed, angle, delay)
{
	return EV_OpenPolyDoor (Level, ln, arg0, arg1, BYTEANGLE(arg2), arg3, 0, PODOOR_SWING);
}

FUNC(LS_Polyobj_DoorSlide)
// Polyobj_DoorSlide (po, speed, angle, distance, delay)
{
	return EV_OpenPolyDoor (Level, ln, arg0, SPEED(arg1), BYTEANGLE(arg2), arg4, arg3, PODOOR_SLIDE);
}

FUNC(LS_Polyobj_OR_RotateLeft)
// Polyobj_OR_RotateLeft (po, speed, angle)
{
	return EV_RotatePoly (Level, ln, arg0, arg1, arg2, 1, true);
}

FUNC(LS_Polyobj_OR_RotateRight)
// Polyobj_OR_RotateRight (po, speed, angle)
{
	return EV_RotatePoly (Level, ln, arg0, arg1, arg2, -1, true);
}

FUNC(LS_Polyobj_OR_Move)
// Polyobj_OR_Move (po, speed, angle, distance)
{
	return EV_MovePoly (Level, ln, arg0, SPEED(arg1), BYTEANGLE(arg2), arg3, true);
}

FUNC(LS_Polyobj_OR_MoveTimes8)
// Polyobj_OR_MoveTimes8 (po, speed, angle, distance)
{
	return EV_MovePoly (Level, ln, arg0, SPEED(arg1), BYTEANGLE(arg2), arg3 * 8, true);
}

FUNC(LS_Polyobj_OR_MoveTo)
// Polyobj_OR_MoveTo (po, speed, x, y)
{
	return EV_MovePolyTo (Level, ln, arg0, SPEED(arg1), DVector2(arg2, arg3), true);
}

FUNC(LS_Polyobj_OR_MoveToSpot)
// Polyobj_OR_MoveToSpot (po, speed, tid)
{
	auto iterator = Level->GetActorIterator(arg2);
	AActor *spot = iterator.Next();
	if (spot == NULL) return false;
	return EV_MovePolyTo (Level, ln, arg0, SPEED(arg1), spot->Pos().XY(), true);
}

FUNC(LS_Polyobj_Stop)
// Polyobj_Stop (po)
{
	return EV_StopPoly (Level, arg0);
}

FUNC(LS_Polyobj_StopSound)
// Polyobj_StopSound (po)
{
	FPolyObj *poly;

	poly = Level->GetPolyobj(arg0);
	if (poly != nullptr)
	{
		SN_StopSequence(poly);
	}

	return true;
}

FUNC(LS_Door_Close)
// Door_Close (tag, speed, lighttag)
{
	return Level->EV_DoDoor (DDoor::doorClose, ln, it, arg0, SPEED(arg1), 0, 0, arg2);
}

FUNC(LS_Door_Open)
// Door_Open (tag, speed, lighttag)
{
	return Level->EV_DoDoor (DDoor::doorOpen, ln, it, arg0, SPEED(arg1), 0, 0, arg2);
}

FUNC(LS_Door_Raise)
// Door_Raise (tag, speed, delay, lighttag)
{
	return Level->EV_DoDoor (DDoor::doorRaise, ln, it, arg0, SPEED(arg1), TICS(arg2), 0, arg3);
}

FUNC(LS_Door_LockedRaise)
// Door_LockedRaise (tag, speed, delay, lock, lighttag)
{
#if 0
	// In Hexen this originally created a thinker running for nearly 4 years.
	// Let's not do this unless it becomes necessary because this can hang tagwait.
	return Level->EV_DoDoor (arg2 || (Level->flags2 & LEVEL2_HEXENHACK) ? DDoor::doorRaise : DDoor::doorOpen, ln, it,
#else
	return Level->EV_DoDoor (arg2 ? DDoor::doorRaise : DDoor::doorOpen, ln, it,
#endif
					  arg0, SPEED(arg1), TICS(arg2), arg3, arg4);
}

FUNC(LS_Door_CloseWaitOpen)
// Door_CloseWaitOpen (tag, speed, delay, lighttag)
{
	return Level->EV_DoDoor (DDoor::doorCloseWaitOpen, ln, it, arg0, SPEED(arg1), OCTICS(arg2), 0, arg3);
}

FUNC(LS_Door_WaitRaise)
// Door_WaitRaise(tag, speed, delay, wait, lighttag)
{
	return Level->EV_DoDoor(DDoor::doorWaitRaise, ln, it, arg0, SPEED(arg1), TICS(arg2), 0, arg4, false, TICS(arg3));
}

FUNC(LS_Door_WaitClose)
// Door_WaitRaise(tag, speed, wait, lighttag)
{
	return Level->EV_DoDoor(DDoor::doorWaitClose, ln, it, arg0, SPEED(arg1), 0, 0, arg3, false, TICS(arg2));
}

FUNC(LS_Door_Animated)
// Door_Animated (tag, speed, delay, lock)
{
	if (arg3 != 0 && !P_CheckKeys (it, arg3, arg0 != 0))
		return false;

	return Level->EV_SlidingDoor (ln, it, arg0, arg1, arg2, DAnimatedDoor::adOpenClose);
}

FUNC(LS_Door_AnimatedClose)
// Door_AnimatedClose (tag, speed)
{
	return Level->EV_SlidingDoor(ln, it, arg0, arg1, -1, DAnimatedDoor::adClose);
}

FUNC(LS_Generic_Door)
// Generic_Door (tag, speed, kind, delay, lock)
{
	int tag, lightTag;
	DDoor::EVlDoor type;
	bool boomgen = false;

	switch (arg2 & 63)
	{
		case 0: type = DDoor::doorRaise;			break;
		case 1: type = DDoor::doorOpen;				break;
		case 2: type = DDoor::doorCloseWaitOpen;	break;
		case 3: type = DDoor::doorClose;			break;
		default: return false;
	}
	// Boom doesn't allow manual generalized doors to be activated while they move
	if (arg2 & 64) boomgen = true;
	if (arg2 & 128)
	{
		// New for 2.0.58: Finally support BOOM's local door light effect
		tag = 0;
		lightTag = arg0;
	}
	else
	{
		tag = arg0;
		lightTag = 0;
	}
	return Level->EV_DoDoor (type, ln, it, tag, SPEED(arg1), OCTICS(arg3), arg4, lightTag, boomgen);
}

FUNC(LS_Floor_LowerByValue)
// Floor_LowerByValue (tag, speed, height, change)
{
	return Level->EV_DoFloor (DFloor::floorLowerByValue, ln, arg0, SPEED(arg1), arg2, -1, CHANGE(arg3), false);
}

FUNC(LS_Floor_LowerToLowest)
// Floor_LowerToLowest (tag, speed, change)
{
	return Level->EV_DoFloor (DFloor::floorLowerToLowest, ln, arg0, SPEED(arg1), 0, -1, CHANGE(arg2), false);
}

FUNC(LS_Floor_LowerToHighest)
// Floor_LowerToHighest (tag, speed, adjust, hereticlower)
{
	return Level->EV_DoFloor (DFloor::floorLowerToHighest, ln, arg0, SPEED(arg1), (arg2-128), -1, 0, false, arg3==1);
}

FUNC(LS_Floor_LowerToHighestEE)
// Floor_LowerToHighestEE (tag, speed, change)
{
	return Level->EV_DoFloor (DFloor::floorLowerToHighest, ln, arg0, SPEED(arg1), 0, -1, CHANGE(arg2), false);
}

FUNC(LS_Floor_LowerToNearest)
// Floor_LowerToNearest (tag, speed, change)
{
	return Level->EV_DoFloor (DFloor::floorLowerToNearest, ln, arg0, SPEED(arg1), 0, -1, CHANGE(arg2), false);
}

FUNC(LS_Floor_RaiseByValue)
// Floor_RaiseByValue (tag, speed, height, change, crush)
{
	return Level->EV_DoFloor (DFloor::floorRaiseByValue, ln, arg0, SPEED(arg1), arg2, CRUSH(arg4), CHANGE(arg3), true);
}

FUNC(LS_Floor_RaiseToHighest)
// Floor_RaiseToHighest (tag, speed, change, crush)
{
	return Level->EV_DoFloor (DFloor::floorRaiseToHighest, ln, arg0, SPEED(arg1), 0, CRUSH(arg3), CHANGE(arg2), true);
}

FUNC(LS_Floor_RaiseToNearest)
// Floor_RaiseToNearest (tag, speed, change, crush)
{
	return Level->EV_DoFloor (DFloor::floorRaiseToNearest, ln, arg0, SPEED(arg1), 0, CRUSH(arg3), CHANGE(arg2), true);
}

FUNC(LS_Floor_RaiseToLowest)
// Floor_RaiseToLowest (tag, change, crush)
{
	// This is merely done for completeness as it's a rather pointless addition.
	return Level->EV_DoFloor (DFloor::floorRaiseToLowest, ln, arg0, 2., 0, CRUSH(arg3), CHANGE(arg2), true);
}

FUNC(LS_Floor_RaiseAndCrush)
// Floor_RaiseAndCrush (tag, speed, crush, crushmode)
{
	return Level->EV_DoFloor (DFloor::floorRaiseAndCrush, ln, arg0, SPEED(arg1), 0, arg2, 0, CRUSHTYPE(arg3));
}

FUNC(LS_Floor_RaiseAndCrushDoom)
// Floor_RaiseAndCrushDoom (tag, speed, crush, crushmode)
{
	return Level->EV_DoFloor (DFloor::floorRaiseAndCrushDoom, ln, arg0, SPEED(arg1), 0, arg2, 0, CRUSHTYPE(arg3));
}

FUNC(LS_Floor_RaiseByValueTimes8)
// FLoor_RaiseByValueTimes8 (tag, speed, height, change, crush)
{
	return Level->EV_DoFloor (DFloor::floorRaiseByValue, ln, arg0, SPEED(arg1), arg2*8, CRUSH(arg4), CHANGE(arg3), true);
}

FUNC(LS_Floor_LowerByValueTimes8)
// Floor_LowerByValueTimes8 (tag, speed, height, change)
{
	return Level->EV_DoFloor (DFloor::floorLowerByValue, ln, arg0, SPEED(arg1), arg2*8, -1, CHANGE(arg3), false);
}

FUNC(LS_Floor_CrushStop)
// Floor_CrushStop (tag)
{
	return Level->EV_FloorCrushStop (arg0, ln);
}

FUNC(LS_Floor_LowerInstant)
// Floor_LowerInstant (tag, unused, height, change)
{
	return Level->EV_DoFloor (DFloor::floorLowerInstant, ln, arg0, 0., arg2*8, -1, CHANGE(arg3), false);
}

FUNC(LS_Floor_RaiseInstant)
// Floor_RaiseInstant (tag, unused, height, change, crush)
{
	return Level->EV_DoFloor (DFloor::floorRaiseInstant, ln, arg0, 0., arg2*8, CRUSH(arg4), CHANGE(arg3), true);
}

FUNC(LS_Floor_ToCeilingInstant)
// Floor_ToCeilingInstant (tag, change, crush, gap)
{
	return Level->EV_DoFloor (DFloor::floorLowerToCeiling, ln, arg0, 0, arg3, CRUSH(arg2), CHANGE(arg1), true);
}

FUNC(LS_Floor_MoveToValueTimes8)
// Floor_MoveToValueTimes8 (tag, speed, height, negative, change)
{
	return Level->EV_DoFloor (DFloor::floorMoveToValue, ln, arg0, SPEED(arg1),
					   arg2*8*(arg3?-1:1), -1, CHANGE(arg4), false);
}

FUNC(LS_Floor_MoveToValue)
// Floor_MoveToValue (tag, speed, height, negative, change)
{
	return Level->EV_DoFloor (DFloor::floorMoveToValue, ln, arg0, SPEED(arg1),
					   arg2*(arg3?-1:1), -1, CHANGE(arg4), false);
}

FUNC(LS_Floor_MoveToValueAndCrush)
// Floor_MoveToValueAndCrush (tag, speed, height, crush, crushmode)
{
	return Level->EV_DoFloor(DFloor::floorMoveToValue, ln, arg0, SPEED(arg1),
		arg2, CRUSH(arg3) -1, 0, CRUSHTYPE(arg4), false);
}

FUNC(LS_Floor_RaiseToLowestCeiling)
// Floor_RaiseToLowestCeiling (tag, speed, change, crush)
{
	return Level->EV_DoFloor (DFloor::floorRaiseToLowestCeiling, ln, arg0, SPEED(arg1), 0, CRUSH(arg3), CHANGE(arg2), true);
}

FUNC(LS_Floor_LowerToLowestCeiling)
// Floor_LowerToLowestCeiling (tag, speed, change)
{
	return Level->EV_DoFloor (DFloor::floorLowerToLowestCeiling, ln, arg0, SPEED(arg1), arg4, -1, CHANGE(arg2), true);
}

FUNC(LS_Floor_RaiseByTexture)
// Floor_RaiseByTexture (tag, speed, change, crush)
{
	return Level->EV_DoFloor (DFloor::floorRaiseByTexture, ln, arg0, SPEED(arg1), 0, CRUSH(arg3), CHANGE(arg2), true);
}

FUNC(LS_Floor_LowerByTexture)
// Floor_LowerByTexture (tag, speed, change, crush)
{
	return Level->EV_DoFloor (DFloor::floorLowerByTexture, ln, arg0, SPEED(arg1), 0, -1, CHANGE(arg2), true);
}

FUNC(LS_Floor_RaiseToCeiling)
// Floor_RaiseToCeiling (tag, speed, change, crush, gap)
{
	return Level->EV_DoFloor (DFloor::floorRaiseToCeiling, ln, arg0, SPEED(arg1), arg4, CRUSH(arg3), CHANGE(arg2), true);
}

FUNC(LS_Floor_RaiseByValueTxTy)
// Floor_RaiseByValueTxTy (tag, speed, height)
{
	return Level->EV_DoFloor (DFloor::floorRaiseAndChange, ln, arg0, SPEED(arg1), arg2, -1, 0, false);
}

FUNC(LS_Floor_LowerToLowestTxTy)
// Floor_LowerToLowestTxTy (tag, speed)
{
	return Level->EV_DoFloor (DFloor::floorLowerAndChange, ln, arg0, SPEED(arg1), arg2, -1, 0, false);
}

FUNC(LS_Floor_Waggle)
// Floor_Waggle (tag, amplitude, frequency, delay, time)
{
	return Level->EV_StartWaggle (arg0, ln, arg1, arg2, arg3, arg4, false);
}

FUNC(LS_Ceiling_Waggle)
// Ceiling_Waggle (tag, amplitude, frequency, delay, time)
{
	return Level->EV_StartWaggle (arg0, ln, arg1, arg2, arg3, arg4, true);
}

FUNC(LS_Floor_TransferTrigger)
// Floor_TransferTrigger (tag)
{
	return Level->EV_DoChange (ln, trigChangeOnly, arg0);
}

FUNC(LS_Floor_TransferNumeric)
// Floor_TransferNumeric (tag)
{
	return Level->EV_DoChange (ln, numChangeOnly, arg0);
}

FUNC(LS_Floor_Donut)
// Floor_Donut (pillartag, pillarspeed, slimespeed)
{
	return Level->EV_DoDonut (arg0, ln, SPEED(arg1), SPEED(arg2));
}

FUNC(LS_Generic_Floor)
// Generic_Floor (tag, speed, height, target, change/model/direct/crush)
{
	DFloor::EFloor type;

	if (arg4 & 8)
	{
		switch (arg3)
		{
			case 1: type = DFloor::floorRaiseToHighest;			break;
			case 2: type = DFloor::floorRaiseToLowest;			break;
			case 3: type = DFloor::floorRaiseToNearest;			break;
			case 4: type = DFloor::floorRaiseToLowestCeiling;	break;
			case 5: type = DFloor::floorRaiseToCeiling;			break;
			case 6: type = DFloor::floorRaiseByTexture;			break;
			default:type = DFloor::floorRaiseByValue;			break;
		}
	}
	else
	{
		switch (arg3)
		{
			case 1: type = DFloor::floorLowerToHighest;			break;
			case 2: type = DFloor::floorLowerToLowest;			break;
			case 3: type = DFloor::floorLowerToNearest;			break;
			case 4: type = DFloor::floorLowerToLowestCeiling;	break;
			case 5: type = DFloor::floorLowerToCeiling;			break;
			case 6: type = DFloor::floorLowerByTexture;			break;
			default:type = DFloor::floorLowerByValue;			break;
		}
	}

	return Level->EV_DoFloor (type, ln, arg0, SPEED(arg1), arg2,
					   (arg4 & 16) ? 20 : -1, arg4 & 7, true);
					   
}

FUNC(LS_Floor_Stop)
// Floor_Stop (tag)
{
	return Level->EV_StopFloor(arg0, ln);
}


FUNC(LS_Stairs_BuildDown)
// Stair_BuildDown (tag, speed, height, delay, reset)
{
	return Level->EV_BuildStairs (arg0, DFloor::buildDown, ln,
						   arg2, SPEED(arg1), TICS(arg3), arg4, 0, DFloor::stairUseSpecials);
}

FUNC(LS_Stairs_BuildUp)
// Stairs_BuildUp (tag, speed, height, delay, reset)
{
	return Level->EV_BuildStairs (arg0, DFloor::buildUp, ln,
						   arg2, SPEED(arg1), TICS(arg3), arg4, 0, DFloor::stairUseSpecials);
}

FUNC(LS_Stairs_BuildDownSync)
// Stairs_BuildDownSync (tag, speed, height, reset)
{
	return Level->EV_BuildStairs (arg0, DFloor::buildDown, ln,
						   arg2, SPEED(arg1), 0, arg3, 0, DFloor::stairUseSpecials|DFloor::stairSync);
}

FUNC(LS_Stairs_BuildUpSync)
// Stairs_BuildUpSync (tag, speed, height, reset)
{
	return Level->EV_BuildStairs (arg0, DFloor::buildUp, ln,
						   arg2, SPEED(arg1), 0, arg3, 0, DFloor::stairUseSpecials|DFloor::stairSync);
}

FUNC(LS_Stairs_BuildUpDoom)
// Stairs_BuildUpDoom (tag, speed, height, delay, reset)
{
	return Level->EV_BuildStairs (arg0, DFloor::buildUp, ln,
						   arg2, SPEED(arg1), TICS(arg3), arg4, 0, 0);
}

FUNC(LS_Stairs_BuildUpDoomCrush)
// Stairs_BuildUpDoom (tag, speed, height, delay, reset)
{
	return Level->EV_BuildStairs(arg0, DFloor::buildUp, ln,
		arg2, SPEED(arg1), TICS(arg3), arg4, 0, DFloor::stairCrush);
}

FUNC(LS_Stairs_BuildDownDoom)
// Stair_BuildDownDoom (tag, speed, height, delay, reset)
{
	return Level->EV_BuildStairs (arg0, DFloor::buildDown, ln,
						   arg2, SPEED(arg1), TICS(arg3), arg4, 0, 0);
}

FUNC(LS_Stairs_BuildDownDoomSync)
// Stairs_BuildDownDoomSync (tag, speed, height, reset)
{
	return Level->EV_BuildStairs (arg0, DFloor::buildDown, ln,
						   arg2, SPEED(arg1), 0, arg3, 0, DFloor::stairSync);
}

FUNC(LS_Stairs_BuildUpDoomSync)
// Stairs_BuildUpDoomSync (tag, speed, height, reset)
{
	return Level->EV_BuildStairs (arg0, DFloor::buildUp, ln,
						   arg2, SPEED(arg1), 0, arg3, 0, DFloor::stairSync);
}


FUNC(LS_Generic_Stairs)
// Generic_Stairs (tag, speed, step, dir/igntxt, reset)
{
	DFloor::EStair type = (arg3 & 1) ? DFloor::buildUp : DFloor::buildDown;
	bool res = Level->EV_BuildStairs (arg0, type, ln,
							   arg2, SPEED(arg1), 0, arg4, arg3 & 2, 0);

	if (res && ln && (ln->flags & ML_REPEAT_SPECIAL) && ln->special == Generic_Stairs)
		// Toggle direction of next activation of repeatable stairs
		ln->args[3] ^= 1;

	return res;
}

FUNC(LS_Pillar_Build)
// Pillar_Build (tag, speed, height)
{
	return Level->EV_DoPillar (DPillar::pillarBuild, ln, arg0, SPEED(arg1), arg2, 0, -1, false);
}

FUNC(LS_Pillar_BuildAndCrush)
// Pillar_BuildAndCrush (tag, speed, height, crush, crushtype)
{
	return Level->EV_DoPillar (DPillar::pillarBuild, ln, arg0, SPEED(arg1), arg2, 0, arg3, CRUSHTYPE(arg4));
}

FUNC(LS_Pillar_Open)
// Pillar_Open (tag, speed, f_height, c_height)
{
	return Level->EV_DoPillar (DPillar::pillarOpen, ln, arg0, SPEED(arg1), arg2, arg3, -1, false);
}

FUNC(LS_Ceiling_LowerByValue)
// Ceiling_LowerByValue (tag, speed, height, change, crush)
{
	return Level->EV_DoCeiling (DCeiling::ceilLowerByValue, ln, arg0, SPEED(arg1), 0, arg2, CRUSH(arg4), 0, CHANGE(arg3));
}

FUNC(LS_Ceiling_RaiseByValue)
// Ceiling_RaiseByValue (tag, speed, height, change)
{
	return Level->EV_DoCeiling (DCeiling::ceilRaiseByValue, ln, arg0, SPEED(arg1), 0, arg2, CRUSH(arg4), 0, CHANGE(arg3));
}

FUNC(LS_Ceiling_LowerByValueTimes8)
// Ceiling_LowerByValueTimes8 (tag, speed, height, change, crush)
{
	return Level->EV_DoCeiling (DCeiling::ceilLowerByValue, ln, arg0, SPEED(arg1), 0, arg2*8, -1, 0, CHANGE(arg3));
}

FUNC(LS_Ceiling_RaiseByValueTimes8)
// Ceiling_RaiseByValueTimes8 (tag, speed, height, change)
{
	return Level->EV_DoCeiling (DCeiling::ceilRaiseByValue, ln, arg0, SPEED(arg1), 0, arg2*8, -1, 0, CHANGE(arg3));
}

FUNC(LS_Ceiling_CrushAndRaise)
// Ceiling_CrushAndRaise (tag, speed, crush, crushtype)
{
	return Level->EV_DoCeiling (DCeiling::ceilCrushAndRaise, ln, arg0, SPEED(arg1), SPEED(arg1)/2, 8, arg2, 0, 0, CRUSHTYPE(arg3, false));
}

FUNC(LS_Ceiling_LowerAndCrush)
// Ceiling_LowerAndCrush (tag, speed, crush, crushtype)
{
	return Level->EV_DoCeiling (DCeiling::ceilLowerAndCrush, ln, arg0, SPEED(arg1), SPEED(arg1), 8, arg2, 0, 0, CRUSHTYPE(arg3, arg1 == 8));
}

FUNC(LS_Ceiling_LowerAndCrushDist)
// Ceiling_LowerAndCrush (tag, speed, crush, dist, crushtype)
{
	return Level->EV_DoCeiling (DCeiling::ceilLowerAndCrush, ln, arg0, SPEED(arg1), SPEED(arg1), arg3, arg2, 0, 0, CRUSHTYPE(arg4, arg1 == 8));
}

FUNC(LS_Ceiling_CrushStop)
// Ceiling_CrushStop (tag, remove)
{
	bool remove;
	switch (arg1)
	{
	case 1:
		remove = false;
		break;
	case 2:
		remove = true;
		break;
	default:
		remove = gameinfo.gametype == GAME_Hexen;
		break;
	}
	return Level->EV_CeilingCrushStop (arg0, remove);
}

FUNC(LS_Ceiling_CrushRaiseAndStay)
// Ceiling_CrushRaiseAndStay (tag, speed, crush, crushtype)
{
	return Level->EV_DoCeiling (DCeiling::ceilCrushRaiseAndStay, ln, arg0, SPEED(arg1), SPEED(arg1)/2, 8, arg2, 0, 0, CRUSHTYPE(arg3, false));
}

FUNC(LS_Ceiling_MoveToValueTimes8)
// Ceiling_MoveToValueTimes8 (tag, speed, height, negative, change)
{
	return Level->EV_DoCeiling (DCeiling::ceilMoveToValue, ln, arg0, SPEED(arg1), 0,
						 arg2*8*((arg3) ? -1 : 1), -1, 0, CHANGE(arg4));
}

FUNC(LS_Ceiling_MoveToValue)
// Ceiling_MoveToValue (tag, speed, height, negative, change)
{
	return Level->EV_DoCeiling (DCeiling::ceilMoveToValue, ln, arg0, SPEED(arg1), 0,
						 arg2*((arg3) ? -1 : 1), -1, 0, CHANGE(arg4));
}

FUNC(LS_Ceiling_MoveToValueAndCrush)
// Ceiling_MoveToValueAndCrush (tag, speed, height, crush, crushmode)
{
	return Level->EV_DoCeiling (DCeiling::ceilMoveToValue, ln, arg0, SPEED(arg1), 0,
						 arg2, CRUSH(arg3), 0, 0, CRUSHTYPE(arg4, arg1 == 8));
}

FUNC(LS_Ceiling_LowerToHighestFloor)
// Ceiling_LowerToHighestFloor (tag, speed, change, crush, gap)
{
	return Level->EV_DoCeiling (DCeiling::ceilLowerToHighestFloor, ln, arg0, SPEED(arg1), 0, arg4, CRUSH(arg3), 0, CHANGE(arg2));
}

FUNC(LS_Ceiling_LowerInstant)
// Ceiling_LowerInstant (tag, unused, height, change, crush)
{
	return Level->EV_DoCeiling (DCeiling::ceilLowerInstant, ln, arg0, 0, 0, arg2*8, CRUSH(arg4), 0, CHANGE(arg3));
}

FUNC(LS_Ceiling_RaiseInstant)
// Ceiling_RaiseInstant (tag, unused, height, change)
{
	return Level->EV_DoCeiling (DCeiling::ceilRaiseInstant, ln, arg0, 0, 0, arg2*8, -1, 0, CHANGE(arg3));
}

FUNC(LS_Ceiling_CrushRaiseAndStayA)
// Ceiling_CrushRaiseAndStayA (tag, dnspeed, upspeed, damage, crushtype)
{
	return Level->EV_DoCeiling (DCeiling::ceilCrushRaiseAndStay, ln, arg0, SPEED(arg1), SPEED(arg2), 0, arg3, 0, 0, CRUSHTYPE(arg4, false));
}

FUNC(LS_Ceiling_CrushRaiseAndStaySilA)
// Ceiling_CrushRaiseAndStaySilA (tag, dnspeed, upspeed, damage, crushtype)
{
	return Level->EV_DoCeiling (DCeiling::ceilCrushRaiseAndStay, ln, arg0, SPEED(arg1), SPEED(arg2), 0, arg3, 1, 0, CRUSHTYPE(arg4, false));
}

FUNC(LS_Ceiling_CrushAndRaiseA)
// Ceiling_CrushAndRaiseA (tag, dnspeed, upspeed, damage, crushtype)
{
	return Level->EV_DoCeiling (DCeiling::ceilCrushAndRaise, ln, arg0, SPEED(arg1), SPEED(arg2), 0, arg3, 0, 0, CRUSHTYPE(arg4, arg1 == 8 && arg2 == 8));
}

FUNC(LS_Ceiling_CrushAndRaiseDist)
// Ceiling_CrushAndRaiseDist (tag, dist, speed, damage, crushtype)
{
	return Level->EV_DoCeiling (DCeiling::ceilCrushAndRaise, ln, arg0, SPEED(arg2), SPEED(arg2), arg1, arg3, 0, 0, CRUSHTYPE(arg4, arg2 == 8));
}

FUNC(LS_Ceiling_CrushAndRaiseSilentA)
// Ceiling_CrushAndRaiseSilentA (tag, dnspeed, upspeed, damage, crushtype)
{
	return Level->EV_DoCeiling (DCeiling::ceilCrushAndRaise, ln, arg0, SPEED(arg1), SPEED(arg2), 0, arg3, 1, 0, CRUSHTYPE(arg4, arg1 == 8 && arg2 == 8));
}

FUNC(LS_Ceiling_CrushAndRaiseSilentDist)
// Ceiling_CrushAndRaiseSilentDist (tag, dist, upspeed, damage, crushtype)
{
	return Level->EV_DoCeiling (DCeiling::ceilCrushAndRaise, ln, arg0, SPEED(arg2), SPEED(arg2), arg1, arg3, 1, 0, CRUSHTYPE(arg4, arg2 == 8));
}

FUNC(LS_Ceiling_RaiseToNearest)
// Ceiling_RaiseToNearest (tag, speed, change)
{
	return Level->EV_DoCeiling (DCeiling::ceilRaiseToNearest, ln, arg0, SPEED(arg1), 0, 0, -1, CHANGE(arg2), 0);
}

FUNC(LS_Ceiling_RaiseToHighest)
// Ceiling_RaiseToHighest (tag, speed, change)
{
	return Level->EV_DoCeiling (DCeiling::ceilRaiseToHighest, ln, arg0, SPEED(arg1), 0, 0, -1, CHANGE(arg2), 0);
}

FUNC(LS_Ceiling_RaiseToLowest)
// Ceiling_RaiseToLowest (tag, speed, change)
{
	return Level->EV_DoCeiling (DCeiling::ceilRaiseToLowest, ln, arg0, SPEED(arg1), 0, 0, -1, CHANGE(arg2), 0);
}

FUNC(LS_Ceiling_RaiseToHighestFloor)
// Ceiling_RaiseToHighestFloor (tag, speed, change)
{
	return Level->EV_DoCeiling (DCeiling::ceilRaiseToHighestFloor, ln, arg0, SPEED(arg1), 0, 0, -1, CHANGE(arg2), 0);
}

FUNC(LS_Ceiling_RaiseByTexture)
// Ceiling_RaiseByTexture (tag, speed, change)
{
	return Level->EV_DoCeiling (DCeiling::ceilRaiseByTexture, ln, arg0, SPEED(arg1), 0, 0, -1, CHANGE(arg2), 0);
}

FUNC(LS_Ceiling_LowerToLowest)
// Ceiling_LowerToLowest (tag, speed, change, crush)
{
	return Level->EV_DoCeiling (DCeiling::ceilLowerToLowest, ln, arg0, SPEED(arg1), 0, 0, CRUSH(arg3), 0, CHANGE(arg2));
}

FUNC(LS_Ceiling_LowerToNearest)
// Ceiling_LowerToNearest (tag, speed, change, crush)
{
	return Level->EV_DoCeiling (DCeiling::ceilLowerToNearest, ln, arg0, SPEED(arg1), 0, 0, CRUSH(arg3), 0, CHANGE(arg2));
}

FUNC(LS_Ceiling_ToHighestInstant)
// Ceiling_ToHighestInstant (tag, change, crush)
{
	return Level->EV_DoCeiling (DCeiling::ceilLowerToHighest, ln, arg0, 2, 0, 0, CRUSH(arg2), 0, CHANGE(arg1));
}

FUNC(LS_Ceiling_ToFloorInstant)
// Ceiling_ToFloorInstant (tag, change, crush, gap)
{
	return Level->EV_DoCeiling (DCeiling::ceilRaiseToFloor, ln, arg0, 2, 0, arg3, CRUSH(arg2), 0, CHANGE(arg1));
}

FUNC(LS_Ceiling_LowerToFloor)
// Ceiling_LowerToFloor (tag, speed, change, crush, gap)
{
	return Level->EV_DoCeiling (DCeiling::ceilLowerToFloor, ln, arg0, SPEED(arg1), 0, arg4, CRUSH(arg3), 0, CHANGE(arg2));
}

FUNC(LS_Ceiling_LowerByTexture)
// Ceiling_LowerByTexture (tag, speed, change, crush)
{
	return Level->EV_DoCeiling (DCeiling::ceilLowerByTexture, ln, arg0, SPEED(arg1), 0, 0, CRUSH(arg3), 0, CHANGE(arg2));
}

FUNC(LS_Ceiling_Stop)
// Ceiling_Stop (tag)
{
	return Level->EV_StopCeiling(arg0, ln);
}


FUNC(LS_Generic_Ceiling)
// Generic_Ceiling (tag, speed, height, target, change/model/direct/crush)
{
	DCeiling::ECeiling type;

	if (arg4 & 8) {
		switch (arg3) {
			case 1:  type = DCeiling::ceilRaiseToHighest;		break;
			case 2:  type = DCeiling::ceilRaiseToLowest;		break;
			case 3:  type = DCeiling::ceilRaiseToNearest;		break;
			case 4:  type = DCeiling::ceilRaiseToHighestFloor;	break;
			case 5:  type = DCeiling::ceilRaiseToFloor;			break;
			case 6:  type = DCeiling::ceilRaiseByTexture;		break;
			default: type = DCeiling::ceilRaiseByValue;			break;
		}
	} else {
		switch (arg3) {
			case 1:  type = DCeiling::ceilLowerToHighest;		break;
			case 2:  type = DCeiling::ceilLowerToLowest;		break;
			case 3:  type = DCeiling::ceilLowerToNearest;		break;
			case 4:  type = DCeiling::ceilLowerToHighestFloor;	break;
			case 5:  type = DCeiling::ceilLowerToFloor;			break;
			case 6:  type = DCeiling::ceilLowerByTexture;		break;
			default: type = DCeiling::ceilLowerByValue;			break;
		}
	}

	return Level->EV_DoCeiling (type, ln, arg0, SPEED(arg1), SPEED(arg1), arg2,
						 (arg4 & 16) ? 20 : -1, 0, arg4 & 7);
}

FUNC(LS_Generic_Crusher)
// Generic_Crusher (tag, dnspeed, upspeed, silent, damage)
{
	return Level->EV_DoCeiling (DCeiling::ceilCrushAndRaise, ln, arg0, SPEED(arg1),
						 SPEED(arg2), 0, arg4, arg3 ? 2 : 0, 0, (arg1 <= 24 && arg2 <= 24)? DCeiling::ECrushMode::crushSlowdown : DCeiling::ECrushMode::crushDoom);
}

FUNC(LS_Generic_Crusher2)
// Generic_Crusher2 (tag, dnspeed, upspeed, silent, damage)
{
	// same as above but uses Hexen's crushing method.
	return Level->EV_DoCeiling (DCeiling::ceilCrushAndRaise, ln, arg0, SPEED(arg1),
						 SPEED(arg2), 0, arg4, arg3 ? 2 : 0, 0, DCeiling::ECrushMode::crushHexen);
}

FUNC(LS_Generic_CrusherDist)
// Generic_CrusherDist (tag, dnspeed, upspeed, silent, damage)
{
	return Level->EV_DoCeiling(DCeiling::ceilCrushAndRaise, ln, arg0, SPEED(arg1),
		SPEED(arg2), 8, arg4, arg3 ? 2 : 0, 0, (arg1 <= 24 && arg2 <= 24) ? DCeiling::ECrushMode::crushSlowdown : DCeiling::ECrushMode::crushDoom);
}

FUNC(LS_Plat_PerpetualRaise)
// Plat_PerpetualRaise (tag, speed, delay)
{
	return Level->EV_DoPlat (arg0, ln, DPlat::platPerpetualRaise, 0, SPEED(arg1), TICS(arg2), 8, 0);
}

FUNC(LS_Plat_PerpetualRaiseLip)
// Plat_PerpetualRaiseLip (tag, speed, delay, lip)
{
	return Level->EV_DoPlat (arg0, ln, DPlat::platPerpetualRaise, 0, SPEED(arg1), TICS(arg2), arg3, 0);
}

FUNC(LS_Plat_Stop)
// Plat_Stop (tag, remove?)
{
	bool remove;
	switch (arg3)
	{
	case 1:
		remove = false;
		break;
	case 2:
		remove = true;
		break;
	default:
		remove = gameinfo.gametype == GAME_Hexen;
		break;
	}
	Level->EV_StopPlat(arg0, remove);
	return true;
}

FUNC(LS_Plat_DownWaitUpStay)
// Plat_DownWaitUpStay (tag, speed, delay)
{
	return Level->EV_DoPlat (arg0, ln, DPlat::platDownWaitUpStay, 0, SPEED(arg1), TICS(arg2), 8, 0);
}

FUNC(LS_Plat_DownWaitUpStayLip)
// Plat_DownWaitUpStayLip (tag, speed, delay, lip, floor-sound?)
{
	return Level->EV_DoPlat (arg0, ln,
		arg4 ? DPlat::platDownWaitUpStayStone : DPlat::platDownWaitUpStay,
		0, SPEED(arg1), TICS(arg2), arg3, 0);
}

FUNC(LS_Plat_DownByValue)
// Plat_DownByValue (tag, speed, delay, height)
{
	return Level->EV_DoPlat (arg0, ln, DPlat::platDownByValue, arg3*8, SPEED(arg1), TICS(arg2), 0, 0);
}

FUNC(LS_Plat_UpByValue)
// Plat_UpByValue (tag, speed, delay, height)
{
	return Level->EV_DoPlat (arg0, ln, DPlat::platUpByValue, arg3*8, SPEED(arg1), TICS(arg2), 0, 0);
}

FUNC(LS_Plat_UpWaitDownStay)
// Plat_UpWaitDownStay (tag, speed, delay)
{
	return Level->EV_DoPlat (arg0, ln, DPlat::platUpWaitDownStay, 0, SPEED(arg1), TICS(arg2), 0, 0);
}

FUNC(LS_Plat_UpNearestWaitDownStay)
// Plat_UpNearestWaitDownStay (tag, speed, delay)
{
	return Level->EV_DoPlat (arg0, ln, DPlat::platUpNearestWaitDownStay, 0, SPEED(arg1), TICS(arg2), 0, 0);
}

FUNC(LS_Plat_RaiseAndStayTx0)
// Plat_RaiseAndStayTx0 (tag, speed, lockout)
{
	DPlat::EPlatType type;

	switch (arg3)
	{
		case 1:
			type = DPlat::platRaiseAndStay;
			break;
		case 2:
			type = DPlat::platRaiseAndStayLockout;
			break;
		default:
			type = gameinfo.gametype == GAME_Heretic? DPlat::platRaiseAndStayLockout : DPlat::platRaiseAndStay;
			break;
	}


	return Level->EV_DoPlat (arg0, ln, type, 0, SPEED(arg1), 0, 0, 1);
}

FUNC(LS_Plat_UpByValueStayTx)
// Plat_UpByValueStayTx (tag, speed, height)
{
	return Level->EV_DoPlat (arg0, ln, DPlat::platUpByValueStay, arg2*8, SPEED(arg1), 0, 0, 2);
}

FUNC(LS_Plat_ToggleCeiling)
// Plat_ToggleCeiling (tag)
{
	return Level->EV_DoPlat (arg0, ln, DPlat::platToggle, 0, 0, 0, 0, 0);
}

FUNC(LS_Generic_Lift)
// Generic_Lift (tag, speed, delay, target, height)
{
	DPlat::EPlatType type;

	switch (arg3)
	{
		case 1:
			type = DPlat::platDownWaitUpStay;
			break;
		case 2:
			type = DPlat::platDownToNearestFloor;
			break;
		case 3:
			type = DPlat::platDownToLowestCeiling;
			break;
		case 4:
			type = DPlat::platPerpetualRaise;
			break;
		default:
			type = DPlat::platUpByValue;
			break;
	}

	return Level->EV_DoPlat (arg0, ln, type, arg4*8, SPEED(arg1), OCTICS(arg2), 0, 0);
}

FUNC(LS_Exit_Normal)
// Exit_Normal (position)
{
	if (Level->CheckIfExitIsGood (it, FindLevelInfo(Level->NextMap.GetChars())))
	{
		Level->ExitLevel (arg0, false);
		return true;
	}
	return false;
}

FUNC(LS_Exit_Secret)
// Exit_Secret (position)
{
	if (Level->CheckIfExitIsGood (it, FindLevelInfo(Level->GetSecretExitMap())))
	{
		Level->SecretExitLevel (arg0);
		return true;
	}
	return false;
}

FUNC(LS_Teleport_NewMap)
// Teleport_NewMap (map, position, keepFacing?)
{
	if (backSide == 0 || gameinfo.gametype == GAME_Strife)
	{
		level_info_t *info = FindLevelByNum (arg0);

		if (info && Level->CheckIfExitIsGood (it, info))
		{
			Level->ChangeLevel(info->MapName.GetChars(), arg1, arg2 ? CHANGELEVEL_KEEPFACING : 0);
			return true;
		}
	}
	return false;
}

FUNC(LS_Teleport)
// Teleport (tid, sectortag, bNoSourceFog)
{
	int flags = TELF_DESTFOG | TELF_FDCOMPAT;
	if (!arg2)
	{
		flags |= TELF_SOURCEFOG;
	}
	return Level->EV_Teleport (arg0, arg1, ln, backSide, it, flags);
}

FUNC( LS_Teleport_NoStop )
// Teleport_NoStop (tid, sectortag, bNoSourceFog)
{
	int flags = TELF_DESTFOG | TELF_KEEPVELOCITY;
	if (!arg2)
	{
		flags |= TELF_SOURCEFOG;
	}
	return Level->EV_Teleport( arg0, arg1, ln, backSide, it, flags);
}

FUNC(LS_Teleport_NoFog)
// Teleport_NoFog (tid, useang, sectortag, keepheight)
{
	int flags = 0;
	switch (arg1)
	{
	case 0:
		flags |= TELF_KEEPORIENTATION;
		break;

	default:
	case 1:
		break;

	case 2:
		if (ln != NULL) flags |= TELF_KEEPORIENTATION | TELF_ROTATEBOOM;	// adjust to exit thing like Boom (i.e. with incorrect reversed angle)
		break;

	case 3:
		if (ln != NULL) flags |= TELF_KEEPORIENTATION | TELF_ROTATEBOOMINVERSE;	// adjust to exit thing correctly
		break;
	}

	if (arg3)
	{
		flags |= TELF_KEEPHEIGHT;
	}
	return Level->EV_Teleport (arg0, arg2, ln, backSide, it, flags);
}

FUNC(LS_Teleport_ZombieChanger)
// Teleport_ZombieChanger (tid, sectortag)
{
	// This is practically useless outside of Strife, but oh well.
	if (it != NULL)
	{
		Level->EV_Teleport (arg0, arg1, ln, backSide, it, 0);
		if (it->health >= 0) it->SetState (it->FindState(NAME_Pain));
		return true;
	}
	return false;
}

FUNC(LS_TeleportOther)
// TeleportOther (other_tid, dest_tid, fog?)
{
	return Level->EV_TeleportOther (arg0, arg1, arg2?true:false);
}

FUNC(LS_TeleportGroup)
// TeleportGroup (group_tid, source_tid, dest_tid, move_source?, fog?)
{
	return Level->EV_TeleportGroup (arg0, it, arg1, arg2, arg3?true:false, arg4?true:false);
}

FUNC(LS_TeleportInSector)
// TeleportInSector (tag, source_tid, dest_tid, bFog, group_tid)
{
	return Level->EV_TeleportSector (arg0, arg1, arg2, arg3?true:false, arg4);
}

FUNC(LS_Teleport_EndGame)
// Teleport_EndGame ()
{
	if (!backSide && Level->CheckIfExitIsGood (it, NULL))
	{
		Level->ChangeLevel(NULL, 0, 0);
		return true;
	}
	return false;
}

FUNC(LS_Teleport_Line)
// Teleport_Line (thisid, destid, reversed)
{
	return Level->EV_SilentLineTeleport (ln, backSide, it, arg1, arg2);
}

static void ThrustThingHelper(AActor *it, DAngle angle, double force, INTBOOL nolimit)
{
	it->Thrust(angle, force);
	if (!nolimit)
	{
		it->Vel.X = clamp(it->Vel.X, -MAXMOVE, MAXMOVE);
		it->Vel.Y = clamp(it->Vel.Y, -MAXMOVE, MAXMOVE);
	}
}

FUNC(LS_ThrustThing)
// ThrustThing (angle, force, nolimit, tid)
{
	if (arg3 != 0)
	{
		auto iterator = Level->GetActorIterator(arg3);
		while ((it = iterator.Next()) != NULL)
		{
			ThrustThingHelper (it, BYTEANGLE(arg0), arg1, arg2);
		}
		return true;
	}
	else if (it)
	{
		if (Level->flags2 & LEVEL2_HEXENHACK && backSide)
		{
			return false;
		}
		ThrustThingHelper (it, BYTEANGLE(arg0), arg1, arg2);
		return true;
	}
	return false;
}

FUNC(LS_ThrustThingZ)	// [BC]
// ThrustThingZ (tid, zthrust, down/up, set)
{
	AActor *victim;
	double thrust = arg1/4.;

	// [BC] Up is default
	if (arg2)
		thrust = -thrust;

	if (arg0 != 0)
	{
		auto iterator = Level->GetActorIterator(arg0);

		while ( (victim = iterator.Next ()) )
		{
			if (!arg3)
				victim->Vel.Z = thrust;
			else
				victim->Vel.Z += thrust;
		}
		return true;
	}
	else if (it)
	{
		if (!arg3)
			it->Vel.Z = thrust;
		else
			it->Vel.Z += thrust;
		return true;
	}
	return false;
}

FUNC(LS_Thing_SetSpecial)	// [BC]
// Thing_SetSpecial (tid, special, arg1, arg2, arg3)
// [RH] Use the SetThingSpecial ACS command instead.
// It can set all args and not just the first three.
{
	if (arg0 == 0)
	{
		if (it != NULL)
		{
			it->special = arg1;
			it->args[0] = arg2;
			it->args[1] = arg3;
			it->args[2] = arg4;
		}
	}
	else
	{
		AActor *actor;
		auto iterator = Level->GetActorIterator(arg0);

		while ( (actor = iterator.Next ()) )
		{
			actor->special = arg1;
			actor->args[0] = arg2;
			actor->args[1] = arg3;
			actor->args[2] = arg4;
		}
	}
	return true;
}

FUNC(LS_Thing_ChangeTID)
// Thing_ChangeTID (oldtid, newtid)
{
	if (arg0 == 0)
	{
		if (it != nullptr)
		{
			it->SetTID(arg1);
		}
	}
	else
	{
		auto iterator = Level->GetActorIterator(arg0);
		AActor *actor, *next;

		next = iterator.Next ();
		while (next != NULL)
		{
			actor = next;
			next = iterator.Next ();

			actor->SetTID(arg1);
		}
	}
	return true;
}

FUNC(LS_DamageThing)
// DamageThing (damage, mod)
{
	if (it)
	{
		if (arg0 < 0)
		{ // Negative damages mean healing
			if (it->player)
			{
				P_GiveBody (it, -arg0);
			}
			else
			{
				it->health -= arg0;
				if (it->SpawnHealth() < it->health)
					it->health = it->SpawnHealth();
			}
		}
		else if (arg0 > 0)
		{
			P_DamageMobj (it, NULL, NULL, arg0, MODtoDamageType (arg1));
		}
		else
		{ // If zero damage, guarantee a kill
			P_DamageMobj (it, NULL, NULL, TELEFRAG_DAMAGE, MODtoDamageType (arg1));
		}
	}

	return it ? true : false;
}

FUNC(LS_HealThing)
// HealThing (amount, max)
{
	if (it)
	{
		int max = arg1;

		if (max == 0 || it->player == NULL)
		{
			P_GiveBody(it, arg0);
			return true;
		}
		else if (max == 1)
		{
			max = deh.MaxSoulsphere;
		}

		// If health is already above max, do nothing
		if (it->health < max)
		{
			it->health += arg0;
			if (it->health > max && max > 0)
			{
				it->health = max;
			}
			if (it->player)
			{
				it->player->health = it->health;
			}
		}
	}

	return it ? true : false;
}

// So that things activated/deactivated by ACS or DECORATE *and* by 
// the BUMPSPECIAL or USESPECIAL flags work correctly both ways.
void DoActivateThing(AActor * thing, AActor * activator)
{
	if (thing->activationtype & THINGSPEC_Activate)
	{
		thing->activationtype &= ~THINGSPEC_Activate; // Clear flag
		if (thing->activationtype & THINGSPEC_Switch) // Set other flag if switching
			thing->activationtype |= THINGSPEC_Deactivate;
	}
	thing->CallActivate (activator);
}

void DoDeactivateThing(AActor * thing, AActor * activator)
{
	if (thing->activationtype & THINGSPEC_Deactivate)
	{
		thing->activationtype &= ~THINGSPEC_Deactivate; // Clear flag
		if (thing->activationtype & THINGSPEC_Switch) // Set other flag if switching
			thing->activationtype |= THINGSPEC_Activate;
	}
	thing->CallDeactivate (activator);
}

FUNC(LS_Thing_Activate)
// Thing_Activate (tid)
{
	if (arg0 != 0)
	{
		AActor *actor;
		auto iterator = Level->GetActorIterator(arg0);
		int count = 0;

		actor = iterator.Next ();
		while (actor)
		{
			// Actor might remove itself as part of activation, so get next
			// one before activating it.
			AActor *temp = iterator.Next ();
			DoActivateThing(actor, it);
			actor = temp;
			count++;
		}

		return count != 0;
	}
	else if (it != NULL)
	{
		DoActivateThing(it, it);
		return true;
	}
	return false;
}

FUNC(LS_Thing_Deactivate)
// Thing_Deactivate (tid)
{
	if (arg0 != 0)
	{
		AActor *actor;
		auto iterator = Level->GetActorIterator(arg0);
		int count = 0;
	
		actor = iterator.Next ();
		while (actor)
		{
			// Actor might removes itself as part of deactivation, so get next
			// one before we activate it.
			AActor *temp = iterator.Next ();
			DoDeactivateThing(actor, it);
			actor = temp;
			count++;
		}
	
		return count != 0;
	}
	else if (it != NULL)
	{
		DoDeactivateThing(it, it);
		return true;
	}
	return false;
}

FUNC(LS_Thing_Remove)
// Thing_Remove (tid)
{
	if (arg0 != 0)
	{
		auto iterator = Level->GetActorIterator(arg0);
		AActor *actor;

		actor = iterator.Next ();
		while (actor)
		{
			AActor *temp = iterator.Next ();

			P_RemoveThing(actor);
			actor = temp;
		}
	}
	else if (it != NULL)
	{
		P_RemoveThing(it);
	}

	return true;
}

FUNC(LS_Thing_Destroy)
// Thing_Destroy (tid, extreme, tag)
{
	AActor *actor;

	if (arg0 == 0 && arg2 == 0)
	{
		Level->Massacre ();
	}
	else if (arg0 == 0)
	{
		auto iterator = Level->GetThinkerIterator<AActor>();
		
		actor = iterator.Next ();
		while (actor)
		{
			AActor *temp = iterator.Next ();
			if (actor->flags & MF_SHOOTABLE && Level->SectorHasTag(actor->Sector, arg2))
				P_DamageMobj (actor, NULL, it, arg1 ? TELEFRAG_DAMAGE : actor->health, NAME_None);
			actor = temp;
		}
	}
	else
	{
		auto iterator = Level->GetActorIterator(arg0);

		actor = iterator.Next ();
		while (actor)
		{
			AActor *temp = iterator.Next ();
			if (actor->flags & MF_SHOOTABLE && (arg2 == 0 || Level->SectorHasTag(actor->Sector, arg2)))
				P_DamageMobj (actor, NULL, it, arg1 ? TELEFRAG_DAMAGE : actor->health, NAME_None);
			actor = temp;
		}
	}
	return true;
}

FUNC(LS_Thing_Damage)
// Thing_Damage (tid, amount, MOD)
{
	Level->EV_Thing_Damage (arg0, it, arg1, MODtoDamageType (arg2));
	return true;
}

FUNC(LS_Thing_Projectile)
// Thing_Projectile (tid, type, angle, speed, vspeed)
{
	return Level->EV_Thing_Projectile (arg0, it, arg1, NULL, BYTEANGLE(arg2), SPEED(arg3),
		SPEED(arg4), 0, NULL, 0, 0, false);
}

FUNC(LS_Thing_ProjectileGravity)
// Thing_ProjectileGravity (tid, type, angle, speed, vspeed)
{
	return Level->EV_Thing_Projectile (arg0, it, arg1, NULL, BYTEANGLE(arg2), SPEED(arg3),
		SPEED(arg4), 0, NULL, 1, 0, false);
}

FUNC(LS_Thing_Hate)
// Thing_Hate (hater, hatee, group/"xray"?)
{
	AActor *hater, *hatee = nullptr;
	auto haterIt = Level->GetActorIterator(arg0);
	auto hateeIt = Level->GetActorIterator(arg1);
	bool nothingToHate = false;

	if (arg1 != 0)
	{
		while ((hatee = hateeIt.Next ()))
		{
			if (hatee->flags & MF_SHOOTABLE	&&	// can't hate nonshootable things
				hatee->health > 0 &&			// can't hate dead things
				!(hatee->flags2 & MF2_DORMANT))	// can't target dormant things
			{
				break;
			}
		}
		if (hatee == NULL)
		{ // Nothing to hate
			nothingToHate = true;
		}
	}

	if (arg0 == 0)
	{
		if (it != NULL && it->player != NULL)
		{
			// Players cannot have their attitudes set
			return false;
		}
		else
		{
			hater = it;
		}
	}
	else
	{
		while ((hater = haterIt.Next ()))
		{
			if (hater->health > 0 && hater->flags & MF_SHOOTABLE)
			{
				break;
			}
		}
	}
	while (hater != NULL)
	{
		// Can't hate if can't attack.
		if (hater->SeeState != NULL)
		{
			// If hating a group of things, record the TID and NULL
			// the target (if its TID doesn't match). A_Look will
			// find an appropriate thing to go chase after.
			if (arg2 != 0)
			{
				hater->TIDtoHate = arg1;
				hater->LastLookActor = nullptr;

				// If the TID to hate is 0, then don't forget the target and
				// lastenemy fields.
				if (arg1 != 0)
				{
					if (hater->target != NULL && hater->target->tid != arg1)
					{
						hater->target = nullptr;
					}
					if (hater->lastenemy != NULL && hater->lastenemy->tid != arg1)
					{
						hater->lastenemy = nullptr;
					}
				}
			}
			// Hate types for arg2:
			//
			// 0 - Just hate one specific actor
			// 1 - Hate actors with given TID and attack players when shot
			// 2 - Same as 1, but will go after enemies without seeing them first
			// 3 - Hunt actors with given TID and also players
			// 4 - Same as 3, but will go after monsters without seeing them first
			// 5 - Hate actors with given TID and ignore player attacks
			// 6 - Same as 5, but will go after enemies without seeing them first

			// Note here: If you use Thing_Hate (tid, 0, 2), you can make
			// a monster go after a player without seeing him first.
			if (arg2 == 2 || arg2 == 4 || arg2 == 6)
			{
				hater->flags3 |= MF3_NOSIGHTCHECK;
			}
			else
			{
				hater->flags3 &= ~MF3_NOSIGHTCHECK;
			}
			if (arg2 == 3 || arg2 == 4)
			{
				hater->flags3 |= MF3_HUNTPLAYERS;
			}
			else
			{
				hater->flags3 &= ~MF3_HUNTPLAYERS;
			}
			if (arg2 == 5 || arg2 == 6)
			{
				hater->flags4 |= MF4_NOHATEPLAYERS;
			}
			else
			{
				hater->flags4 &= ~MF4_NOHATEPLAYERS;
			}

			if (arg1 == 0)
			{
				hatee = it;
			}
			else if (nothingToHate)
			{
				hatee = NULL;
			}
			else if (arg2 != 0)
			{
				do
				{
					hatee = hateeIt.Next ();
				}
				while ( hatee == NULL ||
						hatee == hater ||					// can't hate self
						!(hatee->flags & MF_SHOOTABLE) ||	// can't hate nonshootable things
						hatee->health <= 0 ||				// can't hate dead things
						(hatee->flags2 & MF2_DORMANT));	
			}

			if (hatee != NULL && hatee != hater && (arg2 == 0 || (hater->goal != NULL && hater->target != hater->goal)))
			{
				if (hater->target)
				{
					hater->lastenemy = hater->target;
				}
				hater->target = hatee;
				if (!(hater->flags2 & MF2_DORMANT))
				{
					if (hater->health > 0) hater->SetState (hater->SeeState);
				}
			}
		}
		if (arg0 != 0)
		{
			while ((hater = haterIt.Next ()))
			{
				if (hater->health > 0 && hater->flags & MF_SHOOTABLE)
				{
					break;
				}
			}
		}
		else
		{
			hater = NULL;
		}
	}
	return true;
}

FUNC(LS_Thing_ProjectileAimed)
// Thing_ProjectileAimed (tid, type, speed, target, newtid)
{
	return Level->EV_Thing_Projectile (arg0, it, arg1, NULL, nullAngle, SPEED(arg2), 0, arg3, it, 0, arg4, false);
}

FUNC(LS_Thing_ProjectileIntercept)
// Thing_ProjectileIntercept (tid, type, speed, target, newtid)
{
	return Level->EV_Thing_Projectile (arg0, it, arg1, NULL, nullAngle, SPEED(arg2), 0, arg3, it, 0, arg4, true);
}

// [BC] added newtid for next two
FUNC(LS_Thing_Spawn)
// Thing_Spawn (tid, type, angle, newtid)
{
	return Level->EV_Thing_Spawn (arg0, it, arg1, BYTEANGLE(arg2), true, arg3);
}

FUNC(LS_Thing_SpawnNoFog)
// Thing_SpawnNoFog (tid, type, angle, newtid)
{
	return Level->EV_Thing_Spawn (arg0, it, arg1, BYTEANGLE(arg2), false, arg3);
}

FUNC(LS_Thing_SpawnFacing)
// Thing_SpawnFacing (tid, type, nofog, newtid)
{
	return Level->EV_Thing_Spawn (arg0, it, arg1, DAngle::fromDeg(1000000.), arg2 ? false : true, arg3);
}

FUNC(LS_Thing_Raise)
// Thing_Raise(tid, nocheck)
{
	AActor * target;
	bool ok = false;

	if (arg0==0)
	{
		ok = P_Thing_Raise (it, it, arg1);
	}
	else
	{
		auto iterator = Level->GetActorIterator(arg0);

		while ( (target = iterator.Next ()) )
		{
			ok |= P_Thing_Raise(target, target, arg1);
		}
	}
	return ok;
}

FUNC(LS_Thing_Stop)
// Thing_Stop(tid)
{
	AActor * target;
	bool ok = false;

	if (arg0==0)
	{
		if (it != NULL)
		{
			it->Vel.Zero();
			if (it->player != NULL) it->player->Vel.Zero();
			ok = true;
		}
	}
	else
	{
		auto iterator = Level->GetActorIterator(arg0);

		while ( (target = iterator.Next ()) )
		{
			target->Vel.Zero();
			if (target->player != NULL) target->player->Vel.Zero();
			ok = true;
		}
	}
	return ok;
}


FUNC(LS_Thing_SetGoal)
// Thing_SetGoal (tid, goal, delay, chasegoal)
{
	auto selfiterator = Level->GetActorIterator(arg0);
	auto goaliterator = Level->GetActorIterator(NAME_PatrolPoint, arg1);
	AActor *self;
	AActor *goal = goaliterator.Next ();
	bool ok = false;

	while ( (self = selfiterator.Next ()) )
	{
		ok = true;
		if (self->flags & MF_SHOOTABLE)
		{
			if (self->target == self->goal)
			{ // Targeting a goal already? -> don't target it anymore.
			  // A_Look will set it to the goal, presuming no real targets
			  // come into view by then.
				self->target = nullptr;
			}
			self->goal = goal;
			if (arg3 == 0)
			{
				self->flags5 &= ~MF5_CHASEGOAL;
			}
			else
			{
				self->flags5 |= MF5_CHASEGOAL;
			}
			if (self->target == NULL)
			{
				self->reactiontime = arg2 * TICRATE;
			}
		}
	}

	return ok;
}

FUNC(LS_Thing_Move)		// [BC]
// Thing_Move (tid, mapspot, nofog)
{
	return Level->EV_Thing_Move (arg0, it, arg1, arg2 ? false : true);
}

enum
{
	TRANSLATION_ICE = 0x100007
};

FUNC(LS_Thing_SetTranslation)
// Thing_SetTranslation (tid, range)
{
	auto iterator = Level->GetActorIterator(arg0);
	FTranslationID range;
	AActor *target;
	bool ok = false;

	if (arg1 == -1 && it != NULL)
	{
		range = it->Translation;
	}
	else if (arg1 >= 1 && arg1 < MAX_ACS_TRANSLATIONS)
	{
		range = TRANSLATION(TRANSLATION_LevelScripted, (arg1-1));
	}
	else if (arg1 == TRANSLATION_ICE)
	{
		range = TRANSLATION(TRANSLATION_Standard, 7);
	}
	else
	{
		range = NO_TRANSLATION;
	}

	if (arg0 == 0)
	{
		if (it != NULL)
		{
			ok = true;
			it->Translation = range == NO_TRANSLATION ? it->GetDefault()->Translation : range;
		}
	}
	else
	{
		while ( (target = iterator.Next ()) )
		{
			ok = true;
			target->Translation = range == NO_TRANSLATION ? target->GetDefault()->Translation : range;
		}
	}

	return ok;
}

FUNC(LS_ACS_Execute)
// ACS_Execute (script, map, s_arg1, s_arg2, s_arg3)
{
	level_info_t *info;
	const char *mapname = NULL;
	int args[3] = { arg2, arg3, arg4 };
	int flags = (backSide ? ACS_BACKSIDE : 0);

	if (arg1 == 0)
	{
		mapname = Level->MapName.GetChars();
	}
	else if ((info = FindLevelByNum(arg1)) != NULL)
	{
		mapname = info->MapName.GetChars();
	}
	else
	{
		return false;
	}
	return P_StartScript(Level, it, ln, arg0, mapname, args, 3, flags);
}

FUNC(LS_ACS_ExecuteAlways)
// ACS_ExecuteAlways (script, map, s_arg1, s_arg2, s_arg3)
{
	level_info_t *info;
	const char *mapname = NULL;
	int args[3] = { arg2, arg3, arg4 };
	int flags = (backSide ? ACS_BACKSIDE : 0) | ACS_ALWAYS;

	if (arg1 == 0)
	{
		mapname = Level->MapName.GetChars();
	}
	else if ((info = FindLevelByNum(arg1)) != NULL)
	{
		mapname = info->MapName.GetChars();
	}
	else
	{
		return false;
	}
	return P_StartScript(Level, it, ln, arg0, mapname, args, 3, flags);
}

FUNC(LS_ACS_LockedExecute)
// ACS_LockedExecute (script, map, s_arg1, s_arg2, lock)
{
	if (arg4 && !P_CheckKeys (it, arg4, true))
		return false;
	else
		return LS_ACS_Execute (Level, ln, it, backSide, arg0, arg1, arg2, arg3, 0);
}

FUNC(LS_ACS_LockedExecuteDoor)
// ACS_LockedExecuteDoor (script, map, s_arg1, s_arg2, lock)
{
	if (arg4 && !P_CheckKeys (it, arg4, false))
		return false;
	else
		return LS_ACS_Execute (Level, ln, it, backSide, arg0, arg1, arg2, arg3, 0);
}

FUNC(LS_ACS_ExecuteWithResult)
// ACS_ExecuteWithResult (script, s_arg1, s_arg2, s_arg3, s_arg4)
{
	// This is like ACS_ExecuteAlways, except the script is always run on
	// the current map, and the return value is whatever the script sets
	// with SetResultValue.
	int args[4] = { arg1, arg2, arg3, arg4 };
	int flags = (backSide ? ACS_BACKSIDE : 0) | ACS_ALWAYS | ACS_WANTRESULT;

	return P_StartScript (Level, it, ln, arg0, Level->MapName.GetChars(), args, 4, flags);
}

FUNC(LS_ACS_Suspend)
// ACS_Suspend (script, map)
{
	level_info_t *info;

	if (arg1 == 0)
		P_SuspendScript (Level, arg0, Level->MapName.GetChars());
	else if ((info = FindLevelByNum (arg1)) )
		P_SuspendScript (Level, arg0, info->MapName.GetChars());

	return true;
}

FUNC(LS_ACS_Terminate)
// ACS_Terminate (script, map)
{
	level_info_t *info;

	if (arg1 == 0)
		P_TerminateScript (Level, arg0, Level->MapName.GetChars());
	else if ((info = FindLevelByNum (arg1)) )
		P_TerminateScript (Level, arg0, info->MapName.GetChars());

	return true;
}

//==========================================================================
//
//
//
//==========================================================================

FUNC(LS_FS_Execute)
// FS_Execute(script#,firstsideonly,lock,msgtype)
{
	if (arg1 && ln && backSide) return false;
	if (arg2!=0 && !P_CheckKeys(it, arg2, !!arg3)) return false;
	return T_RunScript(Level, arg0, it);
}



FUNC(LS_FloorAndCeiling_LowerByValue)
// FloorAndCeiling_LowerByValue (tag, speed, height)
{
	return Level->EV_DoElevator (ln, DElevator::elevateLower, SPEED(arg1), arg2, arg0);
}

FUNC(LS_FloorAndCeiling_RaiseByValue)
// FloorAndCeiling_RaiseByValue (tag, speed, height)
{
	return Level->EV_DoElevator (ln, DElevator::elevateRaise, SPEED(arg1), arg2, arg0);
}

FUNC(LS_FloorAndCeiling_LowerRaise)
// FloorAndCeiling_LowerRaise (tag, fspeed, cspeed, boomemu)
{
	bool res = Level->EV_DoCeiling (DCeiling::ceilRaiseToHighest, ln, arg0, SPEED(arg2), 0, 0, 0, 0, 0);
	// The switch based Boom equivalents of FloorandCeiling_LowerRaise do incorrect checks
	// which cause the floor only to move when the ceiling fails to do so.
	// To avoid problems with maps that have incorrect args this only uses a 
	// more or less unintuitive value for the fourth arg to trigger Boom's broken behavior
	if (arg3 != 1998 || !res)	// (1998 for the year in which Boom was released... :P)
	{
		res |= Level->EV_DoFloor (DFloor::floorLowerToLowest, ln, arg0, SPEED(arg1), 0, -1, 0, false);
	}
	return res;
}

FUNC(LS_Elevator_MoveToFloor)
// Elevator_MoveToFloor (tag, speed)
{
	return Level->EV_DoElevator (ln, DElevator::elevateCurrent, SPEED(arg1), 0, arg0);
}

FUNC(LS_Elevator_RaiseToNearest)
// Elevator_RaiseToNearest (tag, speed)
{
	return Level->EV_DoElevator (ln, DElevator::elevateUp, SPEED(arg1), 0, arg0);
}

FUNC(LS_Elevator_LowerToNearest)
// Elevator_LowerToNearest (tag, speed)
{
	return Level->EV_DoElevator (ln, DElevator::elevateDown, SPEED(arg1), 0, arg0);
}

FUNC(LS_Light_ForceLightning)
// Light_ForceLightning (mode)
{
	Level->ForceLightning (arg0);
	return true;
}

FUNC(LS_Light_RaiseByValue)
// Light_RaiseByValue (tag, value)
{
	Level->EV_LightChange (arg0, arg1);
	return true;
}

FUNC(LS_Light_LowerByValue)
// Light_LowerByValue (tag, value)
{
	Level->EV_LightChange (arg0, -arg1);
	return true;
}

FUNC(LS_Light_ChangeToValue)
// Light_ChangeToValue (tag, value)
{
	Level->EV_LightTurnOn (arg0, arg1);
	return true;
}

FUNC(LS_Light_Fade)
// Light_Fade (tag, value, tics);
{
	Level->EV_StartLightFading (arg0, arg1, TICS(arg2));
	return true;
}

FUNC(LS_Light_Glow)
// Light_Glow (tag, upper, lower, tics)
{
	Level->EV_StartLightGlowing (arg0, arg1, arg2, TICS(arg3));
	return true;
}

FUNC(LS_Light_Flicker)
// Light_Flicker (tag, upper, lower)
{
	Level->EV_StartLightFlickering (arg0, arg1, arg2);
	return true;
}

FUNC(LS_Light_Strobe)
// Light_Strobe (tag, upper, lower, u-tics, l-tics)
{
	Level->EV_StartLightStrobing (arg0, arg1, arg2, TICS(arg3), TICS(arg4));
	return true;
}

FUNC(LS_Light_StrobeDoom)
// Light_StrobeDoom (tag, u-tics, l-tics)
{
	Level->EV_StartLightStrobing (arg0, TICS(arg1), TICS(arg2));
	return true;
}

FUNC(LS_Light_MinNeighbor)
// Light_MinNeighbor (tag)
{
	Level->EV_TurnTagLightsOff (arg0);
	return true;
}

FUNC(LS_Light_MaxNeighbor)
// Light_MaxNeighbor (tag)
{
	Level->EV_LightTurnOn (arg0, -1);
	return true;
}

FUNC(LS_Light_Stop)
// Light_Stop (tag)
{
	Level->EV_StopLightEffect (arg0);
	return true;
}

FUNC(LS_Radius_Quake)
// Radius_Quake (intensity, duration, damrad, tremrad, tid)
{
	return P_StartQuake (Level, it, arg4, (double)arg0, arg1, arg2*64, arg3*64, S_FindSound("world/quake"));
}

FUNC(LS_UsePuzzleItem)
// UsePuzzleItem (item, script)
{
	AActor *item;

	if (!it) return false;

	// Check player's inventory for puzzle item
	for (item = it->Inventory; item != NULL; item = item->Inventory)
	{
		if (item->IsKindOf (NAME_PuzzleItem))
		{
			if (item->IntVar(NAME_PuzzleItemNumber) == arg0)
			{
				if (it->UseInventory (item))
				{
					return true;
				}
				break;
			}
		}
	}

	// [RH] Say "hmm" if you don't have the puzzle item
	S_Sound (it, CHAN_VOICE, 0, "*puzzfail", 1, ATTN_IDLE);
	return false;
}

FUNC(LS_Sector_ChangeSound)
// Sector_ChangeSound (tag, sound)
{
	int secNum;
	bool rtn;

	if (!arg0)
		return false;

	rtn = false;
	auto itr = Level->GetSectorTagIterator(arg0);
	while ((secNum = itr.Next()) >= 0)
	{
		Level->sectors[secNum].seqType = arg1;
		rtn = true;
	}
	return rtn;
}

FUNC(LS_Sector_ChangeFlags)
// Sector_ChangeFlags (tag, set, clear)
{
	int secNum;
	bool rtn;

	if (!arg0)
		return false;

	rtn = false;
	auto itr = Level->GetSectorTagIterator(arg0);
	// exclude protected flags
	arg1 &= ~SECF_NOMODIFY;
	arg2 &= ~SECF_NOMODIFY;
	while ((secNum = itr.Next()) >= 0)
	{
		Level->sectors[secNum].Flags = (Level->sectors[secNum].Flags | arg1) & ~arg2;
		rtn = true;
	}
	return rtn;
}




FUNC(LS_Sector_SetWind)
// Sector_SetWind (tag, amount, angle)
{
	if (arg3)
		return false;

	Level->AdjustPusher (arg0, arg1, arg2, true);
	return true;
}

FUNC(LS_Sector_SetCurrent)
// Sector_SetCurrent (tag, amount, angle)
{
	if (arg3)
		return false;

	Level->AdjustPusher (arg0, arg1, arg2, false);
	return true;
}

FUNC(LS_Sector_SetFriction)
// Sector_SetFriction (tag, amount)
{
	P_SetSectorFriction (Level, arg0, arg1, true);
	return true;
}

FUNC(LS_Sector_SetTranslucent)
// Sector_SetTranslucent (tag, plane, amount, type)
{
	if (arg0 != 0)
	{
		int secnum;
		auto itr = Level->GetSectorTagIterator(arg0);
		while ((secnum = itr.Next()) >= 0)
		{
			Level->sectors[secnum].SetAlpha(arg1, clamp(arg2, 0, 255) / 255.);
			Level->sectors[secnum].ChangeFlags(arg1, ~PLANEF_ADDITIVE, arg3? PLANEF_ADDITIVE:0);
		}
		return true;
	}
	return false;
}

FUNC(LS_Sector_SetLink)
// Sector_SetLink (controltag, linktag, floor/ceiling, movetype)
{
	if (arg0 != 0)	// control tag == 0 is for static initialization and must not be handled here
	{
		int control = Level->FindFirstSectorFromTag(arg0);
		if (control >= 0)
		{
			return P_AddSectorLinks(&Level->sectors[control], arg1, arg2, arg3);
		}
	}
	return false;
}

void SetWallScroller(FLevelLocals *Level, int id, int sidechoice, double dx, double dy, EScrollPos Where);
void SetScroller(FLevelLocals *Level, int tag, EScroll type, double dx, double dy);


FUNC(LS_Scroll_Texture_Both)
// Scroll_Texture_Both (id, left, right, up, down)
{
	if (arg0 == 0)
		return false;

	double dx = (arg1 - arg2) / 64.;
	double dy = (arg4 - arg3) / 64.;
	int sidechoice;

	if (arg0 < 0)
	{
		sidechoice = 1;
		arg0 = -arg0;
	}
	else
	{
		sidechoice = 0;
	}

	SetWallScroller (Level, arg0, sidechoice, dx, dy, scw_all);

	return true;
}

FUNC(LS_Scroll_Wall)
// Scroll_Wall (id, x, y, side, flags)
{
	if (arg0 == 0)
		return false;

	SetWallScroller (Level, arg0, !!arg3, arg1 / 65536., arg2 / 65536., EScrollPos(arg4));
	return true;
}

// NOTE: For the next two functions, x-move and y-move are
// 0-based, not 128-based as they are if they appear on lines.
// Note also that parameter ordering is different.

FUNC(LS_Scroll_Floor)
// Scroll_Floor (tag, x-move, y-move, s/c)
{
	double dx = arg1 / 32.;
	double dy = arg2 / 32.;

	if (arg3 == 0 || arg3 == 2)
	{
		SetScroller (Level, arg0, EScroll::sc_floor, -dx, dy);
	}
	else
	{
		SetScroller (Level, arg0, EScroll::sc_floor, 0, 0);
	}
	if (arg3 > 0)
	{
		SetScroller (Level, arg0, EScroll::sc_carry, dx, dy);
	}
	else
	{
		SetScroller (Level, arg0, EScroll::sc_carry, 0, 0);
	}
	return true;
}

FUNC(LS_Scroll_Ceiling)
// Scroll_Ceiling (tag, x-move, y-move, 0)
{
	double dx = arg1 / 32.;
	double dy = arg2 / 32.;

	SetScroller (Level, arg0, EScroll::sc_ceiling, -dx, dy);
	return true;
}

FUNC(LS_PointPush_SetForce)
// PointPush_SetForce ()
{
	return false;
}

FUNC(LS_Sector_SetDamage)
// Sector_SetDamage (tag, amount, mod, interval, leaky)
{
	// The sector still stores the mod in its old format because
	// adding an FName to the sector_t structure might cause
	// problems by adding an unwanted constructor.
	// Since it doesn't really matter whether the type is translated
	// here or in P_PlayerInSpecialSector I think it's the best solution.
	auto itr = Level->GetSectorTagIterator(arg0);
	int secnum;
	while ((secnum = itr.Next()) >= 0)
	{
		if (arg3 <= 0)	// emulate old and hacky method to handle leakiness.
		{
			if (arg1 < 20)
			{
				arg4 = 0;
				arg3 = 32;
			}
			else if (arg1 < 50)
			{
				arg4 = 5;
				arg3 = 32;
			}
			else
			{
				arg4 = 256;
				arg3 = 1;
			}
		}
		Level->sectors[secnum].damageamount = (short)arg1;
		Level->sectors[secnum].damagetype = MODtoDamageType(arg2);
		Level->sectors[secnum].damageinterval = (short)arg3;
		Level->sectors[secnum].leakydamage = (short)arg4;
	}
	return true;
}

FUNC(LS_Sector_SetGravity)
// Sector_SetGravity (tag, intpart, fracpart)
{
	double gravity;

	if (arg2 > 99)
		arg2 = 99;
	gravity = (double)arg1 + (double)arg2 * 0.01;

	auto itr = Level->GetSectorTagIterator(arg0);
	int secnum;
	while ((secnum = itr.Next()) >= 0)
		Level->sectors[secnum].gravity = gravity;

	return true;
}

FUNC(LS_Sector_SetColor)
// Sector_SetColor (tag, r, g, b, desaturate)
{
	auto itr = Level->GetSectorTagIterator(arg0);
	int secnum;
	while ((secnum = itr.Next()) >= 0)
	{
		Level->sectors[secnum].SetColor(PalEntry(arg1, arg2, arg3), arg4);
	}

	return true;
}

FUNC(LS_Sector_SetFade)
// Sector_SetFade (tag, r, g, b)
{
	auto itr = Level->GetSectorTagIterator(arg0);
	int secnum;
	while ((secnum = itr.Next()) >= 0)
	{
		Level->sectors[secnum].SetFade(PalEntry(arg1, arg2, arg3));
	}
	return true;
}

FUNC(LS_Sector_SetCeilingPanning)
// Sector_SetCeilingPanning (tag, x-int, x-frac, y-int, y-frac)
{
	double xofs = arg1 + arg2 / 100.;
	double yofs = arg3 + arg4 / 100.;

	auto itr = Level->GetSectorTagIterator(arg0);
	int secnum;
	while ((secnum = itr.Next()) >= 0)
	{
		Level->sectors[secnum].SetXOffset(sector_t::ceiling, xofs);
		Level->sectors[secnum].SetYOffset(sector_t::ceiling, yofs);
	}
	return true;
}

FUNC(LS_Sector_SetFloorPanning)
// Sector_SetFloorPanning (tag, x-int, x-frac, y-int, y-frac)
{
	double xofs = arg1 + arg2 / 100.;
	double yofs = arg3 + arg4 / 100.;

	auto itr = Level->GetSectorTagIterator(arg0);
	int secnum;
	while ((secnum = itr.Next()) >= 0)
	{
		Level->sectors[secnum].SetXOffset(sector_t::floor, xofs);
		Level->sectors[secnum].SetYOffset(sector_t::floor, yofs);
	}
	return true;
}

FUNC(LS_Sector_SetFloorScale)
// Sector_SetFloorScale (tag, x-int, x-frac, y-int, y-frac)
{
	double xscale = arg1 + arg2 / 100.;
	double yscale = arg3 + arg4 / 100.;

	if (xscale)
		xscale = 1. / xscale;
	if (yscale)
		yscale = 1. / yscale;

	auto itr = Level->GetSectorTagIterator(arg0);
	int secnum;
	while ((secnum = itr.Next()) >= 0)
	{
		if (xscale)
			Level->sectors[secnum].SetXScale(sector_t::floor, xscale);
		if (yscale)
			Level->sectors[secnum].SetYScale(sector_t::floor, yscale);
	}
	return true;
}

FUNC(LS_Sector_SetCeilingScale)
// Sector_SetCeilingScale (tag, x-int, x-frac, y-int, y-frac)
{
	double xscale = arg1 + arg2 / 100.;
	double yscale = arg3 + arg4 / 100.;

	if (xscale)
		xscale = 1. / xscale;
	if (yscale)
		yscale = 1. / yscale;

	auto itr = Level->GetSectorTagIterator(arg0);
	int secnum;
	while ((secnum = itr.Next()) >= 0)
	{
		if (xscale)
			Level->sectors[secnum].SetXScale(sector_t::ceiling, xscale);
		if (yscale)
			Level->sectors[secnum].SetYScale(sector_t::ceiling, yscale);
	}
	return true;
}

FUNC(LS_Sector_SetFloorScale2)
// Sector_SetFloorScale2 (tag, x-factor, y-factor)
{
	double xscale = arg1 / 65536., yscale = arg2 / 65536.;

	if (xscale)
		xscale = 1. / xscale;
	if (yscale)
		yscale = 1. / yscale;

	auto itr = Level->GetSectorTagIterator(arg0);
	int secnum;
	while ((secnum = itr.Next()) >= 0)
	{
		if (arg1)
			Level->sectors[secnum].SetXScale(sector_t::floor, xscale);
		if (arg2)
			Level->sectors[secnum].SetYScale(sector_t::floor, yscale);
	}
	return true;
}

FUNC(LS_Sector_SetCeilingScale2)
// Sector_SetFloorScale2 (tag, x-factor, y-factor)
{
	double xscale = arg1 / 65536., yscale = arg2 / 65536.;

	if (xscale)
		xscale = 1. / xscale;
	if (yscale)
		yscale = 1. / yscale;

	auto itr = Level->GetSectorTagIterator(arg0);
	int secnum;
	while ((secnum = itr.Next()) >= 0)
	{
		if (arg1)
			Level->sectors[secnum].SetXScale(sector_t::ceiling, xscale);
		if (arg2)
			Level->sectors[secnum].SetYScale(sector_t::ceiling, yscale);
	}
	return true;
}

FUNC(LS_Sector_SetRotation)
// Sector_SetRotation (tag, floor-angle, ceiling-angle)
{
	DAngle ceiling = DAngle::fromDeg(arg2);
	DAngle floor = DAngle::fromDeg(arg1);

	auto itr = Level->GetSectorTagIterator(arg0);
	int secnum;
	while ((secnum = itr.Next()) >= 0)
	{
		Level->sectors[secnum].SetAngle(sector_t::floor, floor);
		Level->sectors[secnum].SetAngle(sector_t::ceiling, ceiling);
	}
	return true;
}

FUNC(LS_Line_AlignCeiling)
// Line_AlignCeiling (lineid, side)
{
	bool ret = 0;

	auto itr = Level->GetLineIdIterator(arg0);
	int line;
	while ((line = itr.Next()) >= 0)
	{
		ret |= Level->AlignFlat (line, !!arg1, 1);
	}
	return ret;
}

FUNC(LS_Line_AlignFloor)
// Line_AlignFloor (lineid, side)
{
	bool ret = 0;

	auto itr = Level->GetLineIdIterator(arg0);
	int line;
	while ((line = itr.Next()) >= 0)
	{
		ret |= Level->AlignFlat (line, !!arg1, 0);
	}
	return ret;
}

FUNC(LS_Line_SetTextureOffset)
// Line_SetTextureOffset (id, x, y, side, flags)
{
	const int NO_CHANGE = 32767 << 16;
	double farg1 = arg1 / 65536.;
	double farg2 = arg2 / 65536.;

	if (arg0 == 0 || arg3 < 0 || arg3 > 1)
		return false;

	auto itr = Level->GetLineIdIterator(arg0);
	int line;
	while ((line = itr.Next()) >= 0)
	{
		side_t *side = Level->lines[line].sidedef[arg3];
		if (side != NULL)
		{

			if ((arg4&8)==0)
			{
				// set
				if (arg1 != NO_CHANGE)
				{
					if (arg4&1) side->SetTextureXOffset(side_t::top, farg1);
					if (arg4&2) side->SetTextureXOffset(side_t::mid, farg1);
					if (arg4&4) side->SetTextureXOffset(side_t::bottom, farg1);
				}
				if (arg2 != NO_CHANGE)
				{
					if (arg4&1) side->SetTextureYOffset(side_t::top, farg2);
					if (arg4&2) side->SetTextureYOffset(side_t::mid, farg2);
					if (arg4&4) side->SetTextureYOffset(side_t::bottom, farg2);
				}
			}
			else
			{
				// add
				if (arg1 != NO_CHANGE)
				{
					if (arg4&1) side->AddTextureXOffset(side_t::top, farg1);
					if (arg4&2) side->AddTextureXOffset(side_t::mid, farg1);
					if (arg4&4) side->AddTextureXOffset(side_t::bottom, farg1);
				}
				if (arg2 != NO_CHANGE)
				{
					if (arg4&1) side->AddTextureYOffset(side_t::top, farg2);
					if (arg4&2) side->AddTextureYOffset(side_t::mid, farg2);
					if (arg4&4) side->AddTextureYOffset(side_t::bottom, farg2);
				}
			}
		}
	}
	return true;
}

FUNC(LS_Line_SetTextureScale)
// Line_SetTextureScale (id, x, y, side, flags)
{
	const int NO_CHANGE = 32767 << 16;
	double farg1 = arg1 / 65536.;
	double farg2 = arg2 / 65536.;

	if (arg0 == 0 || arg3 < 0 || arg3 > 1)
		return false;

	auto itr = Level->GetLineIdIterator(arg0);
	int line;
	while ((line = itr.Next()) >= 0)
	{
		side_t *side = Level->lines[line].sidedef[arg3];
		if (side != NULL)
		{
			if ((arg4&8)==0)
			{
				// set
				if (arg1 != NO_CHANGE)
				{
					if (arg4&1) side->SetTextureXScale(side_t::top, farg1);
					if (arg4&2) side->SetTextureXScale(side_t::mid, farg1);
					if (arg4&4) side->SetTextureXScale(side_t::bottom, farg1);
				}
				if (arg2 != NO_CHANGE)
				{
					if (arg4&1) side->SetTextureYScale(side_t::top, farg2);
					if (arg4&2) side->SetTextureYScale(side_t::mid, farg2);
					if (arg4&4) side->SetTextureYScale(side_t::bottom, farg2);
				}
			}
			else
			{
				// add
				if (arg1 != NO_CHANGE)
				{
					if (arg4&1) side->MultiplyTextureXScale(side_t::top, farg1);
					if (arg4&2) side->MultiplyTextureXScale(side_t::mid, farg1);
					if (arg4&4) side->MultiplyTextureXScale(side_t::bottom, farg1);
				}
				if (arg2 != NO_CHANGE)
				{
					if (arg4&1) side->MultiplyTextureYScale(side_t::top, farg2);
					if (arg4&2) side->MultiplyTextureYScale(side_t::mid, farg2);
					if (arg4&4) side->MultiplyTextureYScale(side_t::bottom, farg2);
				}
			}
		}
	}
	return true;
}

FUNC(LS_Line_SetBlocking)
// Line_SetBlocking (id, setflags, clearflags)
{
    struct FlagTransEntry
    {
        int fieldIndex, bitmask;
    };

    static const FlagTransEntry flagtrans[] =
    {
        {0, ML_BLOCKING},
        {0, ML_BLOCKMONSTERS},
        {0, ML_BLOCK_PLAYERS},
        {0, ML_BLOCK_FLOATERS},
        {0, ML_BLOCKPROJECTILE},
        {0, ML_BLOCKEVERYTHING},
        {0, ML_RAILING},
        {0, ML_BLOCKUSE},
        {0, ML_BLOCKSIGHT},
        {0, ML_BLOCKHITSCAN},
        {0, ML_SOUNDBLOCK},
        {1, ML2_BLOCKLANDMONSTERS},
        {-1, -1},
    };

    if (arg0 == 0) return false;

    int setflags[2] = {};
    int clearflags[2] = {};

    for (int i = 0; flagtrans[i].bitmask != -1; i++, arg1 >>= 1, arg2 >>= 1)
    {
        if (arg1 & 1) setflags[flagtrans[i].fieldIndex] |= flagtrans[i].bitmask;
        if (arg2 & 1) clearflags[flagtrans[i].fieldIndex] |= flagtrans[i].bitmask;
    }

    auto itr = Level->GetLineIdIterator(arg0);
    int line;
    while ((line = itr.Next()) >= 0)
    {
        Level->lines[line].flags = (Level->lines[line].flags & ~clearflags[0]) | setflags[0];
        Level->lines[line].flags2 = (Level->lines[line].flags2 & ~clearflags[1]) | setflags[1];
    }
    return true;
}

FUNC(LS_Line_SetAutomapFlags)
// Line_SetAutomapFlags (id, setflags, clearflags)
{
	static const int flagtrans[] =
	{
		ML_SECRET,
		ML_DONTDRAW,
		ML_MAPPED,
		ML_REVEALED,
		-1
	};

	if (arg0 == 0) return false;

	int setflags = 0;
	int clearflags = 0;

	for (int i = 0; flagtrans[i] != -1; i++, arg1 >>= 1, arg2 >>= 1)
	{
		if (arg1 & 1) setflags |= flagtrans[i];
		if (arg2 & 1) clearflags |= flagtrans[i];
	}

	auto itr = Level->GetLineIdIterator(arg0);
	int line;
	while ((line = itr.Next()) >= 0)
	{
		Level->lines[line].flags = (Level->lines[line].flags & ~clearflags) | setflags;
	}

	return true;
}

FUNC(LS_Line_SetAutomapStyle)
// Line_SetAutomapStyle (id, style)
{
	if (arg1 < AMLS_COUNT && arg1 >= 0)
	{
		auto itr = Level->GetLineIdIterator(arg0);
		int line;
		while ((line = itr.Next()) >= 0)
		{
			Level->lines[line].automapstyle = (AutomapLineStyle) arg1;
		}

		return true;
	}
	return false;
}


FUNC(LS_ChangeCamera)
// ChangeCamera (tid, who, revert?)
{
	AActor *camera;
	if (arg0 != 0)
	{
		auto iterator = Level->GetActorIterator(arg0);
		camera = iterator.Next ();
	}
	else
	{
		camera = NULL;
	}

	if (!it || !it->player || arg1)
	{
		int i;

		for (i = 0; i < MAXPLAYERS; i++)
		{
			if (!Level->PlayerInGame(i))
				continue;

			auto p = Level->Players[i];
			AActor *oldcamera = p->camera;
			if (camera)
			{
				p->camera = camera;
				if (arg2)
					p->cheats |= CF_REVERTPLEASE;
			}
			else
			{
				p->camera = p->mo;
				p->cheats &= ~CF_REVERTPLEASE;
			}
			if (oldcamera != p->camera)
			{
				R_ClearPastViewer (p->camera);
			}
		}
	}
	else
	{
		AActor *oldcamera = it->player->camera;
		if (camera)
		{
			it->player->camera = camera;
			if (arg2)
				it->player->cheats |= CF_REVERTPLEASE;
		}
		else
		{
			it->player->camera = it;
			it->player->cheats &= ~CF_REVERTPLEASE;
		}
		if (oldcamera != it->player->camera)
		{
			R_ClearPastViewer (it->player->camera);
		}
	}

	return true;
}

enum
{
	PROP_FROZEN,
	PROP_NOTARGET,
	PROP_INSTANTWEAPONSWITCH,
	PROP_FLY,
	PROP_TOTALLYFROZEN,

	PROP_INVULNERABILITY,
	PROP_STRENGTH,
	PROP_INVISIBILITY,
	PROP_RADIATIONSUIT,
	PROP_ALLMAP,
	PROP_INFRARED,
	PROP_WEAPONLEVEL2,
	PROP_FLIGHT,
	PROP_UNUSED1,
	PROP_UNUSED2,
	PROP_SPEED,

	PROP_BUDDHA,
	PROP_BUDDHA2,
	PROP_FRIGHTENING,
	PROP_NOCLIP,
	PROP_NOCLIP2,
	PROP_GODMODE,
	PROP_GODMODE2,
};

FUNC(LS_SetPlayerProperty)
// SetPlayerProperty (who, value, which)
// who == 0: set activator's property
// who == 1: set every player's property
{
	int mask = 0;

	if ((!it || !it->player) && !arg0)
		return false;

	// Add or remove a power
	if (arg2 >= PROP_INVULNERABILITY && arg2 <= PROP_SPEED)
	{
		static ENamedName powers[14] =
		{
			NAME_PowerInvulnerable,
			NAME_PowerStrength,
			NAME_PowerInvisibility,
			NAME_PowerIronFeet,
			NAME_None,
			NAME_PowerLightAmp,
			NAME_PowerWeaponLevel2,
			NAME_PowerFlight,
			NAME_None,
			NAME_None,
			NAME_PowerSpeed,
			NAME_PowerInfiniteAmmo,
			NAME_PowerDoubleFiringSpeed,
			NAME_PowerBuddha
		};
		int power = arg2 - PROP_INVULNERABILITY;

		if (power > 4 && powers[power] == NAME_None)
		{
			return false;
		}

		if (arg0 == 0)
		{
			if (arg1)
			{ // Give power to activator
				if (power != 4)
				{
					auto item = it->GiveInventoryType(PClass::FindActor(powers[power]));
					if (item != NULL && power == 0 && arg1 == 1) 
					{
						item->ColorVar(NAME_BlendColor) = MakeSpecialColormap(INVERSECOLORMAP);
					}
				}
				else if (it->player && it->player == Level->GetConsolePlayer())
				{
					Level->flags2 |= LEVEL2_ALLMAP;
				}
			}
			else
			{ // Take power from activator
				if (power != 4)
				{
					auto item = it->FindInventory(powers[power], true);
					if (item != NULL)
					{
						item->Destroy ();
					}
				}
				else if (it->player && it->player == Level->GetConsolePlayer())
				{
					Level->flags2 &= ~LEVEL2_ALLMAP;
				}
			}
		}
		else
		{
			int i;

			for (i = 0; i < MAXPLAYERS; i++)
			{
				auto p = Level->Players[i];
				if (!Level->PlayerInGame(i) || p->mo == nullptr)
					continue;

				if (arg1)
				{ // Give power
					if (power != 4)
					{
						auto item = p->mo->GiveInventoryType ((PClass::FindActor(powers[power])));
						if (item != NULL && power == 0 && arg1 == 1) 
						{
							item->ColorVar(NAME_BlendColor) = MakeSpecialColormap(INVERSECOLORMAP);
						}
					}
					else if (p == Level->GetConsolePlayer())
					{
						Level->flags2 |= LEVEL2_ALLMAP;
					}
				}
				else
				{ // Take power
					if (power != 4)
					{
						auto item = p->mo->FindInventory (PClass::FindActor(powers[power]));
						if (item != NULL)
						{
							item->Destroy ();
						}
					}
					else if (p == Level->GetConsolePlayer())
					{
						Level->flags2 &= ~LEVEL2_ALLMAP;
					}
				}
			}
		}
		return true;
	}

	// Set or clear a flag
	switch (arg2)
	{
		case PROP_BUDDHA:
			mask = CF_BUDDHA;
			break;
		case PROP_BUDDHA2:
			mask = CF_BUDDHA2;
			break;
		case PROP_FROZEN:
			mask = CF_FROZEN;
			break;
		case PROP_NOTARGET:
			mask = CF_NOTARGET;
			break;
		case PROP_INSTANTWEAPONSWITCH:
			mask = CF_INSTANTWEAPSWITCH;
			break;
		//CF_FLY has special handling
		case PROP_FLY:
			//mask = CF_FLY;
			break;
		case PROP_TOTALLYFROZEN:
			mask = CF_TOTALLYFROZEN;
			break;
		case PROP_FRIGHTENING:
			mask = CF_FRIGHTENING;
			break;
		case PROP_NOCLIP:
			mask = CF_NOCLIP;
			break;
		case PROP_NOCLIP2:
			mask = CF_NOCLIP|CF_NOCLIP2; //Both must be on.
			break;
		case PROP_GODMODE:
			mask = CF_GODMODE;
			break;
		case PROP_GODMODE2:
			mask = CF_GODMODE2;
			break;
	}

	if (arg0 == 0)
	{
		if (arg1)
		{
			it->player->cheats |= mask;
			if (arg2 == PROP_FLY)
			{
				it->flags7 |= MF7_FLYCHEAT;
				it->flags2 |= MF2_FLY;
				it->flags |= MF_NOGRAVITY;
			}
		}
		else
		{
			it->player->cheats &= ~mask;
			if (arg2 == PROP_FLY)
			{
				it->flags7 &= ~MF7_FLYCHEAT;
				it->flags2 &= ~MF2_FLY;
				it->flags &= ~MF_NOGRAVITY;
			}
		}
	}
	else
	{
		int i;

		if ((Level->ib_compatflags & BCOMPATF_LINKFROZENPROPS) && (mask & (CF_FROZEN | CF_TOTALLYFROZEN)))
		{ // Clearing one of these properties clears both of them (if the compat flag is set.)
			mask = CF_FROZEN | CF_TOTALLYFROZEN;
		}

		for (i = 0; i < MAXPLAYERS; i++)
		{
			if (!Level->PlayerInGame(i))
				continue;

			auto p = Level->Players[i];
			if (arg1)
			{
				p->cheats |= mask;
				if (arg2 == PROP_FLY)
				{
					p->mo->flags2 |= MF2_FLY;
					p->mo->flags |= MF_NOGRAVITY;
				}
			}
			else
			{
				p->cheats &= ~mask;
				if (arg2 == PROP_FLY)
				{
					p->mo->flags2 &= ~MF2_FLY;
					p->mo->flags &= ~MF_NOGRAVITY;
				}
			}
		}
	}

	return !!mask;
}

FUNC(LS_TranslucentLine)
// TranslucentLine (id, amount, type)
{
	auto itr = Level->GetLineIdIterator(arg0);
	int linenum;
	while ((linenum = itr.Next()) >= 0)
	{
		Level->lines[linenum].alpha = clamp(arg1, 0, 255) / 255.;
		if (arg2 == 0)
		{
			Level->lines[linenum].flags &= ~ML_ADDTRANS;
		}
		else if (arg2 == 1)
		{
			Level->lines[linenum].flags |= ML_ADDTRANS;
		}
		else
		{
			Printf ("Unknown translucency type used with TranslucentLine\n");
		}
	}

	return true;
}

FUNC(LS_Autosave)
{
	if (gameaction != ga_savegame && gameaction != ga_quicksave)
	{
		Level->flags2 &= ~LEVEL2_NOAUTOSAVEHINT;
		Net_WriteInt8 (DEM_CHECKAUTOSAVE);
	}
	return true;
}

FUNC(LS_ChangeSkill)
{
	if ((unsigned)arg0 >= AllSkills.Size())
	{
		NextSkill = -1;
	}
	else
	{
		NextSkill = arg0;
	}
	return true;
}

FUNC(LS_NoiseAlert)
// NoiseAlert (TID of target, TID of emitter)
{
	AActor *target, *emitter;

	if (arg0 == 0)
	{
		target = it;
	}
	else
	{
		auto iter = Level->GetActorIterator(arg0);
		target = iter.Next();
	}

	if (arg1 == 0)
	{
		emitter = it;
	}
	else if (arg1 == arg0)
	{
		emitter = target;
	}
	else
	{
		auto iter = Level->GetActorIterator(arg1);
		emitter = iter.Next();
	}

	P_NoiseAlert (emitter, target);
	return true;
}

FUNC(LS_SendToCommunicator)
// SendToCommunicator (voc #, front-only, identify, nolog)
{
	// This obviously isn't going to work for co-op.
	if (arg1 && backSide)
		return false;

	if (it != NULL && it->player != NULL && it->FindInventory(NAME_Communicator))
	{
		char name[32];									   
		mysnprintf (name, countof(name), "svox/voc%d", arg0);

		if (!arg3)
		{
			it->player->SetLogNumber (arg0);
		}

		if (it->CheckLocalView())
		{
			S_StopSound (CHAN_VOICE);
			auto snd = S_FindSound(name);
			it->player->SetSubtitle(arg0, snd);
			S_Sound (CHAN_VOICE, 0, snd, 1, ATTN_NORM);

			// Get the message from the LANGUAGE lump.
			FString msg;
			msg.Format("TXT_COMM%d", arg2);
			const char *str = GStrings.CheckString(msg.GetChars());
			if (str != NULL)
			{
				Printf (PRINT_CHAT, "%s\n", str);
			}
		}
		return true;
	}
	return false;
}

FUNC(LS_ForceField)
// ForceField ()
{
	if (it != NULL)
	{
		P_DamageMobj (it, NULL, NULL, 16, NAME_None);
		it->Thrust(it->Angles.Yaw + DAngle::fromDeg(180), 7.8125);
	}
	return true;
}

FUNC(LS_ClearForceField)
// ClearForceField (tag)
{
	bool rtn = false;

	auto itr = Level->GetSectorTagIterator(arg0);
	int secnum;
	while ((secnum = itr.Next()) >= 0)
	{
		sector_t *sec = &Level->sectors[secnum];
		rtn = true;

		sec->RemoveForceField();
	}
	return rtn;
}

FUNC(LS_GlassBreak)
// GlassBreak (bNoJunk, junkID)
{
	bool switched;
	bool quest1, quest2;

	ln->flags &= ~(ML_BLOCKING|ML_BLOCKEVERYTHING);
	switched = P_ChangeSwitchTexture (ln->sidedef[0], false, 0, &quest1);
	ln->special = 0;
	if (ln->sidedef[1] != NULL)
	{
		switched |= P_ChangeSwitchTexture (ln->sidedef[1], false, 0, &quest2);
	}
	else
	{
		quest2 = quest1;
	}
	if (switched)
	{
		if (!arg0)
		{ // Break some glass

			DVector2 linemid((ln->v1->fX() + ln->v2->fX()) / 2, (ln->v1->fY() + ln->v2->fY()) / 2);

			// remove dependence on sector size and always spawn 2 map units in front of the line.
			DVector2 normal(ln->Delta().Y, -ln->Delta().X);
			linemid += normal.Unit() * 2;
			/* old code:
			x += (ln->frontsector->centerspot.x - x) / 5;
			y += (ln->frontsector->centerspot.y - y) / 5;
			*/

			auto type = SpawnableThings.CheckKey(arg1);
			for (int i = 0; i < 7; ++i)
			{
				AActor *glass = nullptr;
				if (arg1 > 0)
				{
					if (type != nullptr)
					{
						glass = Spawn(Level, *type, DVector3(linemid, ONFLOORZ), ALLOW_REPLACE);
						glass->AddZ(24.);
					}
				}
				else
				{
					glass = Spawn(Level, "GlassJunk", DVector3(linemid, ONFLOORZ), ALLOW_REPLACE);
					glass->AddZ(24.);
					glass->SetState(glass->SpawnState + (pr_glass() % glass->health));
				}
				if (glass != nullptr)
				{
					glass->Angles.Yaw = DAngle::fromDeg(pr_glass() * (360 / 256.));
					glass->VelFromAngle(pr_glass() & 3);
					glass->Vel.Z = (pr_glass() & 7);
					// [RH] Let the shards stick around longer than they did in Strife.
					glass->tics += pr_glass();
				}
			}
		}
		if (quest1 || quest2)
		{ // Up stats and signal this mission is complete
			if (it == NULL)
			{
				for (int i = 0; i < MAXPLAYERS; ++i)
				{
					if (Level->PlayerInGame(i))
					{
						it = Level->Players[i]->mo;
						break;
					}
				}
			}
			if (it != NULL)
			{
				it->GiveInventoryType (PClass::FindActor("QuestItem29"));
				it->GiveInventoryType (PClass::FindActor("UpgradeAccuracy"));
				it->GiveInventoryType (PClass::FindActor("UpgradeStamina"));
			}
		}
	}
	// We already changed the switch texture, so don't make the main code switch it back.
	return false;
}

FUNC(LS_StartConversation)
// StartConversation (tid, facetalker)
{
	auto iterator = Level->GetActorIterator(arg0);

	AActor *target = iterator.Next();

	// Nothing to talk to
	if (target == NULL)
	{
		return false;
	}
	
	// Only living players are allowed to start conversations
	if (it == NULL || it->player == NULL || it->player->mo != it || it->health<=0)
	{
		return false;
	}

	// Dead things can't talk.
	if (target->health <= 0)
	{
		return false;
	}
	// Fighting things don't talk either.
	if (target->flags4 & MF4_INCOMBAT)
	{
		return false;
	}
	if (target->Conversation != NULL)
	{
		// Give the NPC a chance to play a brief animation
		target->ConversationAnimation (0);
		P_StartConversation (target, it, !!arg1, true);
		return true;
	}
	return false;
}

FUNC(LS_Thing_SetConversation)
// Thing_SetConversation (tid, dlg_id)
{
	int dlg_index = -1;
	FStrifeDialogueNode *node = NULL;

	if (arg1 != 0)
	{
		dlg_index = Level->GetConversation(arg1);
		if (dlg_index == -1) return false;
		node = Level->StrifeDialogues[dlg_index];
	}

	if (arg0 != 0)
	{
		auto iterator = Level->GetActorIterator(arg0);
		while ((it = iterator.Next()) != NULL)
		{
			it->ConversationRoot = dlg_index;
			it->Conversation = node;
		}
	}
	else if (it)
	{
		it->ConversationRoot = dlg_index;
		it->Conversation = node;
	}
	return true;
}

FUNC(LS_Line_SetPortalTarget)
// Line_SetPortalTarget(thisid, destid)
{
	return Level->ChangePortal(ln, arg0, arg1);
}

FUNC(LS_Sector_SetPlaneReflection)
// Sector_SetPlaneReflection (tag, floor, ceiling)
{
	int secnum;
	auto itr = Level->GetSectorTagIterator(arg0);

	while ((secnum = itr.Next()) >= 0)
	{
		sector_t * s = &Level->sectors[secnum];
		if (!s->floorplane.isSlope()) s->reflect[sector_t::floor] = arg1 / 255.f;
		if (!s->ceilingplane.isSlope()) Level->sectors[secnum].reflect[sector_t::ceiling] = arg2 / 255.f;
	}

	return true;
}


FUNC(LS_SetGlobalFogParameter)
// SetGlobalFogParameter (type, value)
{
	switch (arg0)
	{
	case 0:
		Level->fogdensity = arg1 >> 1;
		return true;

	case 1:
		Level->outsidefogdensity = arg1 >> 1;
		return true;

	case 2:
		Level->skyfog = arg1;
		return true;

	default:
		return false;
	}
}

FUNC(LS_Sector_SetFloorGlow)
// Sector_SetFloorGlow(tag, height, r, g, b)
{
	int secnum;
	PalEntry color(arg2, arg3, arg4);
	if (arg1 < 0) color = -1;	// negative height invalidates the glow.
	auto itr = Level->GetSectorTagIterator(arg0);

	while ((secnum = itr.Next()) >= 0)
	{
		sector_t * s = &Level->sectors[secnum];
		s->SetGlowColor(sector_t::floor, color);
		s->SetGlowHeight(sector_t::floor, float(arg1));
	}
	return true;
}

FUNC(LS_Sector_SetCeilingGlow)
// Sector_SetCeilingGlow(tag, height, r, g, b)
{
	int secnum;
	PalEntry color(arg2, arg3, arg4);
	if (arg1 < 0) color = -1;	// negative height invalidates the glow.
	auto itr = Level->GetSectorTagIterator(arg0);

	while ((secnum = itr.Next()) >= 0)
	{
		sector_t * s = &Level->sectors[secnum];
		s->SetGlowColor(sector_t::ceiling, color);
		s->SetGlowHeight(sector_t::ceiling, float(arg1));
	}
	return true;
}

FUNC(LS_Line_SetHealth)
// Line_SetHealth(id, health)
{
	auto itr = Level->GetLineIdIterator(arg0);
	int l;

	if (arg1 < 0)
		arg1 = 0;

	while ((l = itr.Next()) >= 0)
	{
		line_t* line = &Level->lines[l];
		line->health = arg1;
		if (line->healthgroup)
			P_SetHealthGroupHealth(Level, line->healthgroup, arg1);
	}
	return true;
}

FUNC(LS_Sector_SetHealth)
// Sector_SetHealth(id, part, health)
{
	auto itr = Level->GetSectorTagIterator(arg0);
	int s;

	if (arg2 < 0)
		arg2 = 0;

	while ((s = itr.Next()) >= 0)
	{
		sector_t* sector = &Level->sectors[s];
		if (arg1 == SECPART_Ceiling)
		{
			sector->healthceiling = arg2;
			if (sector->healthceilinggroup)
				P_SetHealthGroupHealth(Level, sector->healthceilinggroup, arg2);
		}
		else if (arg1 == SECPART_Floor)
		{
			sector->healthfloor = arg2;
			if (sector->healthfloorgroup)
				P_SetHealthGroupHealth(Level, sector->healthfloorgroup, arg2);
		}
		else if (arg1 == SECPART_3D)
		{
			sector->health3d = arg2;
			if (sector->health3dgroup)
				P_SetHealthGroupHealth(Level, sector->health3dgroup, arg2);
		}
	}
	return true;
}

static lnSpecFunc LineSpecials[] =
{
	/*   0 */ LS_NOP,
	/*   1 */ LS_NOP,		// Polyobj_StartLine,
	/*   2 */ LS_Polyobj_RotateLeft,
	/*   3 */ LS_Polyobj_RotateRight,
	/*   4 */ LS_Polyobj_Move,
	/*   5 */ LS_NOP,		// Polyobj_ExplicitLine
	/*   6 */ LS_Polyobj_MoveTimes8,
	/*   7 */ LS_Polyobj_DoorSwing,
	/*   8 */ LS_Polyobj_DoorSlide,
	/*   9 */ LS_NOP,		// Line_Horizon
	/*  10 */ LS_Door_Close,
	/*  11 */ LS_Door_Open,
	/*  12 */ LS_Door_Raise,
	/*  13 */ LS_Door_LockedRaise,
	/*  14 */ LS_Door_Animated,
	/*  15 */ LS_Autosave,
	/*  16 */ LS_NOP,		// Transfer_WallLight
	/*  17 */ LS_Thing_Raise,
	/*  18 */ LS_StartConversation,
	/*  19 */ LS_Thing_Stop,
	/*  20 */ LS_Floor_LowerByValue,
	/*  21 */ LS_Floor_LowerToLowest,
	/*  22 */ LS_Floor_LowerToNearest,
	/*  23 */ LS_Floor_RaiseByValue,
	/*  24 */ LS_Floor_RaiseToHighest,
	/*  25 */ LS_Floor_RaiseToNearest,
	/*  26 */ LS_Stairs_BuildDown,
	/*  27 */ LS_Stairs_BuildUp,
	/*  28 */ LS_Floor_RaiseAndCrush,
	/*  29 */ LS_Pillar_Build,
	/*  30 */ LS_Pillar_Open,
	/*  31 */ LS_Stairs_BuildDownSync,
	/*  32 */ LS_Stairs_BuildUpSync,
	/*  33 */ LS_ForceField,
	/*  34 */ LS_ClearForceField,
	/*  35 */ LS_Floor_RaiseByValueTimes8,
	/*  36 */ LS_Floor_LowerByValueTimes8,
	/*  37 */ LS_Floor_MoveToValue,
	/*  38 */ LS_Ceiling_Waggle,
	/*  39 */ LS_Teleport_ZombieChanger,
	/*  40 */ LS_Ceiling_LowerByValue,
	/*  41 */ LS_Ceiling_RaiseByValue,
	/*  42 */ LS_Ceiling_CrushAndRaise,
	/*  43 */ LS_Ceiling_LowerAndCrush,
	/*  44 */ LS_Ceiling_CrushStop,
	/*  45 */ LS_Ceiling_CrushRaiseAndStay,
	/*  46 */ LS_Floor_CrushStop,
	/*  47 */ LS_Ceiling_MoveToValue,
	/*  48 */ LS_NOP,		// Sector_Attach3dMidtex
	/*  49 */ LS_GlassBreak,
	/*  50 */ LS_NOP,		// ExtraFloor_LightOnly
	/*  51 */ LS_Sector_SetLink,
	/*  52 */ LS_Scroll_Wall,
	/*  53 */ LS_Line_SetTextureOffset,
	/*  54 */ LS_Sector_ChangeFlags,
	/*  55 */ LS_Line_SetBlocking,
	/*  56 */ LS_Line_SetTextureScale,
	/*  57 */ LS_NOP,		// Sector_SetPortal
	/*  58 */ LS_NOP,		// Sector_CopyScroller
	/*  59 */ LS_Polyobj_OR_MoveToSpot,
	/*  60 */ LS_Plat_PerpetualRaise,
	/*  61 */ LS_Plat_Stop,
	/*  62 */ LS_Plat_DownWaitUpStay,
	/*  63 */ LS_Plat_DownByValue,
	/*  64 */ LS_Plat_UpWaitDownStay,
	/*  65 */ LS_Plat_UpByValue,
	/*  66 */ LS_Floor_LowerInstant,
	/*  67 */ LS_Floor_RaiseInstant,
	/*  68 */ LS_Floor_MoveToValueTimes8,
	/*  69 */ LS_Ceiling_MoveToValueTimes8,
	/*  70 */ LS_Teleport,
	/*  71 */ LS_Teleport_NoFog,
	/*  72 */ LS_ThrustThing,
	/*  73 */ LS_DamageThing,
	/*  74 */ LS_Teleport_NewMap,
	/*  75 */ LS_Teleport_EndGame,
	/*  76 */ LS_TeleportOther,
	/*  77 */ LS_TeleportGroup,
	/*  78 */ LS_TeleportInSector,
	/*  79 */ LS_Thing_SetConversation,
	/*  80 */ LS_ACS_Execute,
	/*  81 */ LS_ACS_Suspend,
	/*  82 */ LS_ACS_Terminate,
	/*  83 */ LS_ACS_LockedExecute,
	/*  84 */ LS_ACS_ExecuteWithResult,
	/*  85 */ LS_ACS_LockedExecuteDoor,
	/*  86 */ LS_Polyobj_MoveToSpot,
	/*  87 */ LS_Polyobj_Stop,
	/*  88 */ LS_Polyobj_MoveTo,
	/*  89 */ LS_Polyobj_OR_MoveTo,
	/*  90 */ LS_Polyobj_OR_RotateLeft,
	/*  91 */ LS_Polyobj_OR_RotateRight,
	/*  92 */ LS_Polyobj_OR_Move,
	/*  93 */ LS_Polyobj_OR_MoveTimes8,
	/*  94 */ LS_Pillar_BuildAndCrush,
	/*  95 */ LS_FloorAndCeiling_LowerByValue,
	/*  96 */ LS_FloorAndCeiling_RaiseByValue,
	/*  97 */ LS_Ceiling_LowerAndCrushDist,
	/*  98 */ LS_Sector_SetTranslucent,
	/*  99 */ LS_Floor_RaiseAndCrushDoom,
	/* 100 */ LS_NOP,		// Scroll_Texture_Left
	/* 101 */ LS_NOP,		// Scroll_Texture_Right
	/* 102 */ LS_NOP,		// Scroll_Texture_Up
	/* 103 */ LS_NOP,		// Scroll_Texture_Down
	/* 104 */ LS_Ceiling_CrushAndRaiseSilentDist,
	/* 105 */ LS_Door_WaitRaise,
	/* 106 */ LS_Door_WaitClose,
	/* 107 */ LS_Line_SetPortalTarget,
	/* 108 */ LS_NOP,
	/* 109 */ LS_Light_ForceLightning,
	/* 110 */ LS_Light_RaiseByValue,
	/* 111 */ LS_Light_LowerByValue,
	/* 112 */ LS_Light_ChangeToValue,
	/* 113 */ LS_Light_Fade,
	/* 114 */ LS_Light_Glow,
	/* 115 */ LS_Light_Flicker,
	/* 116 */ LS_Light_Strobe,
	/* 117 */ LS_Light_Stop,
	/* 118 */ LS_NOP,		// Plane_Copy
	/* 119 */ LS_Thing_Damage,
	/* 120 */ LS_Radius_Quake,
	/* 121 */ LS_NOP,		// Line_SetIdentification
	/* 122 */ LS_NOP,
	/* 123 */ LS_NOP,
	/* 124 */ LS_NOP,
	/* 125 */ LS_Thing_Move,
	/* 126 */ LS_NOP,
	/* 127 */ LS_Thing_SetSpecial,
	/* 128 */ LS_ThrustThingZ,
	/* 129 */ LS_UsePuzzleItem,
	/* 130 */ LS_Thing_Activate,
	/* 131 */ LS_Thing_Deactivate,
	/* 132 */ LS_Thing_Remove,
	/* 133 */ LS_Thing_Destroy,
	/* 134 */ LS_Thing_Projectile,
	/* 135 */ LS_Thing_Spawn,
	/* 136 */ LS_Thing_ProjectileGravity,
	/* 137 */ LS_Thing_SpawnNoFog,
	/* 138 */ LS_Floor_Waggle,
	/* 139 */ LS_Thing_SpawnFacing,
	/* 140 */ LS_Sector_ChangeSound,
	/* 141 */ LS_NOP,
	/* 142 */ LS_NOP,
	/* 143 */ LS_NOP,
	/* 144 */ LS_NOP,
	/* 145 */ LS_NOP,		// 145 Player_SetTeam
	/* 146 */ LS_NOP,
	/* 147 */ LS_NOP,
	/* 148 */ LS_NOP,
	/* 149 */ LS_NOP,
	/* 150 */ LS_Line_SetHealth,
	/* 151 */ LS_Sector_SetHealth,
	/* 152 */ LS_NOP,		// 152 Team_Score
	/* 153 */ LS_NOP,		// 153 Team_GivePoints
	/* 154 */ LS_Teleport_NoStop,
	/* 155 */ LS_NOP,
	/* 156 */ LS_NOP,
	/* 157 */ LS_SetGlobalFogParameter,
	/* 158 */ LS_FS_Execute,
	/* 159 */ LS_Sector_SetPlaneReflection,
	/* 160 */ LS_NOP,		// Sector_Set3DFloor
	/* 161 */ LS_NOP,		// Sector_SetContents
	/* 162 */ LS_NOP,		// Reserved Doom64 branch
	/* 163 */ LS_NOP,		// Reserved Doom64 branch
	/* 164 */ LS_NOP,		// Reserved Doom64 branch
	/* 165 */ LS_NOP,		// Reserved Doom64 branch
	/* 166 */ LS_NOP,		// Reserved Doom64 branch
	/* 167 */ LS_NOP,		// Reserved Doom64 branch
	/* 168 */ LS_Ceiling_CrushAndRaiseDist,
	/* 169 */ LS_Generic_Crusher2,
	/* 170 */ LS_Sector_SetCeilingScale2,
	/* 171 */ LS_Sector_SetFloorScale2,
	/* 172 */ LS_Plat_UpNearestWaitDownStay,
	/* 173 */ LS_NoiseAlert,
	/* 174 */ LS_SendToCommunicator,
	/* 175 */ LS_Thing_ProjectileIntercept,
	/* 176 */ LS_Thing_ChangeTID,
	/* 177 */ LS_Thing_Hate,
	/* 178 */ LS_Thing_ProjectileAimed,
	/* 179 */ LS_ChangeSkill,
	/* 180 */ LS_Thing_SetTranslation,
	/* 181 */ LS_NOP,		// Plane_Align
	/* 182 */ LS_NOP,		// Line_Mirror
	/* 183 */ LS_Line_AlignCeiling,
	/* 184 */ LS_Line_AlignFloor,
	/* 185 */ LS_Sector_SetRotation,
	/* 186 */ LS_Sector_SetCeilingPanning,
	/* 187 */ LS_Sector_SetFloorPanning,
	/* 188 */ LS_Sector_SetCeilingScale,
	/* 189 */ LS_Sector_SetFloorScale,
	/* 190 */ LS_NOP,		// Static_Init
	/* 191 */ LS_SetPlayerProperty,
	/* 192 */ LS_Ceiling_LowerToHighestFloor,
	/* 193 */ LS_Ceiling_LowerInstant,
	/* 194 */ LS_Ceiling_RaiseInstant,
	/* 195 */ LS_Ceiling_CrushRaiseAndStayA,
	/* 196 */ LS_Ceiling_CrushAndRaiseA,
	/* 197 */ LS_Ceiling_CrushAndRaiseSilentA,
	/* 198 */ LS_Ceiling_RaiseByValueTimes8,
	/* 199 */ LS_Ceiling_LowerByValueTimes8,
	/* 200 */ LS_Generic_Floor,
	/* 201 */ LS_Generic_Ceiling,
	/* 202 */ LS_Generic_Door,
	/* 203 */ LS_Generic_Lift,
	/* 204 */ LS_Generic_Stairs,
	/* 205 */ LS_Generic_Crusher,
	/* 206 */ LS_Plat_DownWaitUpStayLip,
	/* 207 */ LS_Plat_PerpetualRaiseLip,
	/* 208 */ LS_TranslucentLine,
	/* 209 */ LS_NOP,		// Transfer_Heights
	/* 210 */ LS_NOP,		// Transfer_FloorLight
	/* 211 */ LS_NOP,		// Transfer_CeilingLight
	/* 212 */ LS_Sector_SetColor,
	/* 213 */ LS_Sector_SetFade,
	/* 214 */ LS_Sector_SetDamage,
	/* 215 */ LS_Teleport_Line,
	/* 216 */ LS_Sector_SetGravity,
	/* 217 */ LS_Stairs_BuildUpDoom,
	/* 218 */ LS_Sector_SetWind,
	/* 219 */ LS_Sector_SetFriction,
	/* 220 */ LS_Sector_SetCurrent,
	/* 221 */ LS_Scroll_Texture_Both,
	/* 222 */ LS_NOP,		// Scroll_Texture_Model
	/* 223 */ LS_Scroll_Floor,
	/* 224 */ LS_Scroll_Ceiling,
	/* 225 */ LS_NOP,		// Scroll_Texture_Offsets
	/* 226 */ LS_ACS_ExecuteAlways,
	/* 227 */ LS_PointPush_SetForce,
	/* 228 */ LS_Plat_RaiseAndStayTx0,
	/* 229 */ LS_Thing_SetGoal,
	/* 230 */ LS_Plat_UpByValueStayTx,
	/* 231 */ LS_Plat_ToggleCeiling,
	/* 232 */ LS_Light_StrobeDoom,
	/* 233 */ LS_Light_MinNeighbor,
	/* 234 */ LS_Light_MaxNeighbor,
	/* 235 */ LS_Floor_TransferTrigger,
	/* 236 */ LS_Floor_TransferNumeric,
	/* 237 */ LS_ChangeCamera,
	/* 238 */ LS_Floor_RaiseToLowestCeiling,
	/* 239 */ LS_Floor_RaiseByValueTxTy,
	/* 240 */ LS_Floor_RaiseByTexture,
	/* 241 */ LS_Floor_LowerToLowestTxTy,
	/* 242 */ LS_Floor_LowerToHighest,
	/* 243 */ LS_Exit_Normal,
	/* 244 */ LS_Exit_Secret,
	/* 245 */ LS_Elevator_RaiseToNearest,
	/* 246 */ LS_Elevator_MoveToFloor,
	/* 247 */ LS_Elevator_LowerToNearest,
	/* 248 */ LS_HealThing,
	/* 249 */ LS_Door_CloseWaitOpen,
	/* 250 */ LS_Floor_Donut,
	/* 251 */ LS_FloorAndCeiling_LowerRaise,
	/* 252 */ LS_Ceiling_RaiseToNearest,
	/* 253 */ LS_Ceiling_LowerToLowest,
	/* 254 */ LS_Ceiling_LowerToFloor,
	/* 255 */ LS_Ceiling_CrushRaiseAndStaySilA,

	/* 256 */ LS_Floor_LowerToHighestEE,
	/* 257 */ LS_Floor_RaiseToLowest,
	/* 258 */ LS_Floor_LowerToLowestCeiling,
	/* 259 */ LS_Floor_RaiseToCeiling,
	/* 260 */ LS_Floor_ToCeilingInstant,
	/* 261 */ LS_Floor_LowerByTexture,
	/* 262 */ LS_Ceiling_RaiseToHighest,
	/* 263 */ LS_Ceiling_ToHighestInstant,
	/* 264 */ LS_Ceiling_LowerToNearest,
	/* 265 */ LS_Ceiling_RaiseToLowest,
	/* 266 */ LS_Ceiling_RaiseToHighestFloor,
	/* 267 */ LS_Ceiling_ToFloorInstant,
	/* 268 */ LS_Ceiling_RaiseByTexture,
	/* 269 */ LS_Ceiling_LowerByTexture,
	/* 270 */ LS_Stairs_BuildDownDoom,
	/* 271 */ LS_Stairs_BuildUpDoomSync,
	/* 272 */ LS_Stairs_BuildDownDoomSync,
	/* 273 */ LS_Stairs_BuildUpDoomCrush,
	/* 274 */ LS_Door_AnimatedClose,
	/* 275 */ LS_Floor_Stop,
	/* 276 */ LS_Ceiling_Stop,
	/* 277 */ LS_Sector_SetFloorGlow,
	/* 278 */ LS_Sector_SetCeilingGlow,
	/* 279 */ LS_Floor_MoveToValueAndCrush,
	/* 280 */ LS_Ceiling_MoveToValueAndCrush,
	/* 281 */ LS_Line_SetAutomapFlags,
	/* 282 */ LS_Line_SetAutomapStyle,
	/* 283 */ LS_Polyobj_StopSound,
	/* 284 */ LS_Generic_CrusherDist
};

#define DEFINE_SPECIAL(name, num, min, max, mmax) {#name, num, min, max, mmax},
static FLineSpecial LineSpecialNames[] = {
#include "actionspecials.h"
};

static int lscmp (const void * a, const void * b)
{
	return stricmp( ((FLineSpecial*)a)->name, ((FLineSpecial*)b)->name);
}

static struct LineSpecialTable
{
	TArray<FLineSpecial *> LineSpecialsInfo;

	LineSpecialTable()
	{
		unsigned int max = 0;
		for (size_t i = 0; i < countof(LineSpecialNames); ++i)
		{
			if (LineSpecialNames[i].number > (int)max)
				max = LineSpecialNames[i].number;
		}
		LineSpecialsInfo.Resize(max + 1);
		for (unsigned i = 0; i <= max; i++)
		{
			LineSpecialsInfo[i] = NULL;
		}

		qsort(LineSpecialNames, countof(LineSpecialNames), sizeof(FLineSpecial), lscmp);
		for (size_t i = 0; i < countof(LineSpecialNames); ++i)
		{
			assert(LineSpecialsInfo[LineSpecialNames[i].number] == NULL);
			LineSpecialsInfo[LineSpecialNames[i].number] = &LineSpecialNames[i];
		}
	}
} LineSpec;

//==========================================================================
//
//
//
//==========================================================================

int P_GetMaxLineSpecial()
{
	return LineSpec.LineSpecialsInfo.Size() - 1;
}

//==========================================================================
//
//
//
//==========================================================================

FLineSpecial *P_GetLineSpecialInfo(int special)
{
	if ((unsigned) special < LineSpec.LineSpecialsInfo.Size())
	{
		return LineSpec.LineSpecialsInfo[special];
	}
	return NULL;
}

//==========================================================================
//
// P_FindLineSpecial
//
// Finds a line special and also returns the min and max argument count.
//
//==========================================================================

int P_FindLineSpecial (const char *string, int *min_args, int *max_args)
{
	int min = 0, max = countof(LineSpecialNames) - 1;

	while (min <= max)
	{
		int mid = (min + max) / 2;
		int lexval = stricmp (string, LineSpecialNames[mid].name);
		if (lexval == 0)
		{
			if (min_args != NULL) *min_args = LineSpecialNames[mid].min_args;
			if (max_args != NULL) *max_args = LineSpecialNames[mid].max_args;
			return LineSpecialNames[mid].number;
		}
		else if (lexval > 0)
		{
			min = mid + 1;
		}
		else
		{
			max = mid - 1;
		}
	}
	// Alias for ZScript. Check here to have universal support everywhere.
	if (!stricmp(string, "TeleportSpecial"))
	{
		if (min_args != NULL) *min_args = 1;
		if (max_args != NULL) *max_args = 3;
		return Teleport;
	}
	return 0;
}


//==========================================================================
//
// P_ExecuteSpecial
//
//==========================================================================

int P_ExecuteSpecial(FLevelLocals *Level, int			num,
					 struct line_t	*line,
					 class AActor	*activator,
					 bool			backSide,
					 int			arg1,
					 int			arg2,
					 int			arg3,
					 int			arg4,
					 int			arg5)
{
	if (num >= 0 && num < (int)countof(LineSpecials))
	{
		return LineSpecials[num](Level, line, activator, backSide, arg1, arg2, arg3, arg4, arg5);
	}
	return 0;
}

//==========================================================================
//
// Execute a line special / script
//
//==========================================================================
DEFINE_ACTION_FUNCTION(FLevelLocals, ExecuteSpecial)
{
	PARAM_SELF_STRUCT_PROLOGUE(FLevelLocals);
	PARAM_INT(special);
	PARAM_OBJECT(activator, AActor);
	PARAM_POINTER(linedef, line_t);
	PARAM_BOOL(lineside);
	PARAM_INT(arg1);
	PARAM_INT(arg2);
	PARAM_INT(arg3);
	PARAM_INT(arg4);
	PARAM_INT(arg5);

	ACTION_RETURN_INT(P_ExecuteSpecial(self, special, linedef, activator, lineside, arg1, arg2, arg3, arg4, arg5));
}
