raze/source/games/duke/src/actors.cpp

//-------------------------------------------------------------------------
/*
Copyright (C) 1996, 2003 - 3D Realms Entertainment
Copyright (C) 2000, 2003 - Matt Saettler (EDuke Enhancements)
Copyright (C) 2017-2019 - Nuke.YKT
Copyright (C) 2020 - Christoph Oelckers

This file is part of Enhanced Duke Nukem 3D version 1.5 - Atomic Edition

Duke Nukem 3D is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

Original Source: 1996 - Todd Replogle
Prepared for public release: 03/21/2003 - Charlie Wiederhold, 3D Realms

EDuke enhancements integrated: 04/13/2003 - Matt Saettler

Note: EDuke source was in transition.  Changes are in-progress in the
source as it is released.

This file is a combination of code from the following sources:
- EDuke 2 by Matt Saettler
- JFDuke by Jonathon Fowler (jf@jonof.id.au),
- DukeGDX and RedneckGDX by Alexander Makarov-[M210] (m210-2007@mail.ru)
- Redneck Rampage reconstructed source by Nuke.YKT

*/
//-------------------------------------------------------------------------

#include "ns.h"
#include "global.h"
#include "names.h"
#include "stats.h"
#include "constants.h"
#include "dukeactor.h"

BEGIN_DUKE_NS

int adjustfall(DDukeActor* s, int c);


//---------------------------------------------------------------------------
//
// this was once a macro
//
//---------------------------------------------------------------------------

void RANDOMSCRAP(DDukeActor* origin)
{
	int r1 = krand(), r2 = krand(), r3 = krand(), r4 = krand(), r5 = krand(), r6 = krand(), r7 = krand();
	int v = isRR() ? 16 : 48;
	EGS(origin->s->sector(),
		origin->s->x + (r7 & 255) - 128, origin->s->y + (r6 & 255) - 128, origin->s->z - (8 << 8) - (r5 & 8191), 
		TILE_SCRAP6 + (r4 & 15), -8, v, v, r3 & 2047, (r2 & 63) + 64, -512 - (r1 & 2047), origin, 5); 
}

//---------------------------------------------------------------------------
//
// wrapper to ensure that if a sound actor is killed, the sound is stopped as well.
//
//---------------------------------------------------------------------------

void deletesprite(DDukeActor *const actor)
{
	if (actor->s->picnum == MUSICANDSFX && actor->temp_data[0] == 1)
		S_StopSound(actor->s->lotag, actor);
	else
		S_RelinkActorSound(actor, nullptr);
	::deletesprite(actor->GetSpriteIndex());
}

//---------------------------------------------------------------------------
//
// 
//
//---------------------------------------------------------------------------

void addammo(int weapon, struct player_struct* player, int amount)
{
	player->ammo_amount[weapon] += amount;

	if (player->ammo_amount[weapon] > gs.max_ammo_amount[weapon])
		player->ammo_amount[weapon] = gs.max_ammo_amount[weapon];
}

//---------------------------------------------------------------------------
//
// 
//
//---------------------------------------------------------------------------

void checkavailinven(struct player_struct* player)
{

	if (player->firstaid_amount > 0)
		player->inven_icon = ICON_FIRSTAID;
	else if (player->steroids_amount > 0)
		player->inven_icon = ICON_STEROIDS;
	else if (player->holoduke_amount > 0)
		player->inven_icon = ICON_HOLODUKE;
	else if (player->jetpack_amount > 0)
		player->inven_icon = ICON_JETPACK;
	else if (player->heat_amount > 0)
		player->inven_icon = ICON_HEATS;
	else if (player->scuba_amount > 0)
		player->inven_icon = ICON_SCUBA;
	else if (player->boot_amount > 0)
		player->inven_icon = ICON_BOOTS;
	else player->inven_icon = ICON_NONE;
}

//---------------------------------------------------------------------------
//
// 
//
//---------------------------------------------------------------------------

void checkavailweapon(struct player_struct* player)
{
	int i, snum;
	int weap;

	if (player->wantweaponfire >= 0)
	{
		weap = player->wantweaponfire;
		player->wantweaponfire = -1;

		if (weap == player->curr_weapon) return;
		else if (player->gotweapon[weap] && player->ammo_amount[weap] > 0)
		{
			fi.addweapon(player, weap);
			return;
		}
	}

	weap = player->curr_weapon;
	if (player->gotweapon[weap] && player->ammo_amount[weap] > 0)
		return;

	snum = player->GetPlayerNum();

	int max = MAX_WEAPON;
	for (i = 0; i <= max; i++)
	{
		weap = ud.wchoice[snum][i];
		if ((g_gameType & GAMEFLAG_SHAREWARE) && weap > 6) continue;

		if (weap == 0) weap = max;
		else weap--;

		if (weap == MIN_WEAPON || (player->gotweapon[weap] && player->ammo_amount[weap] > 0))
			break;
	}

	if (i == MAX_WEAPON) weap = MIN_WEAPON;

	// Found the weapon

	player->last_weapon = player->curr_weapon;
	player->random_club_frame = 0;
	player->curr_weapon = weap;
	if (isWW2GI())
	{
		SetGameVarID(g_iWeaponVarID, player->curr_weapon, player->GetActor(), snum); // snum is player index!
		if (player->curr_weapon >= 0)
		{
			SetGameVarID(g_iWorksLikeVarID, aplWeaponWorksLike[player->curr_weapon][snum], player->GetActor(), snum);
		}
		else
		{
			SetGameVarID(g_iWorksLikeVarID, -1, player->GetActor(), snum);
		}
		OnEvent(EVENT_CHANGEWEAPON, snum, player->GetActor(), -1);
	}

	player->okickback_pic = player->kickback_pic = 0;
	if (player->holster_weapon == 1)
	{
		player->holster_weapon = 0;
		player->weapon_pos = 10;
	}
	else player->weapon_pos = -1;
}

//---------------------------------------------------------------------------
//
// 
//
//---------------------------------------------------------------------------

void clearcamera(player_struct* ps)
{
	ps->newOwner = nullptr;
	ps->pos.x = ps->oposx;
	ps->pos.y = ps->oposy;
	ps->pos.z = ps->oposz;
	ps->angle.restore();
	updatesector(ps->pos.x, ps->pos.y, &ps->cursectnum);

	DukeStatIterator it(STAT_ACTOR);
	while (auto k = it.Next())
	{
		if (k->s->picnum == TILE_CAMERA1)
			k->s->yvel = 0;
	}
}

//---------------------------------------------------------------------------
//
// 
//
//---------------------------------------------------------------------------

int ssp(DDukeActor* const actor, unsigned int cliptype) //The set sprite function
{
	Collision c;

	return movesprite_ex(actor,
		MulScale(actor->s->xvel, bcos(actor->s->ang), 14),
		MulScale(actor->s->xvel, bsin(actor->s->ang), 14), actor->s->zvel,
		cliptype, c) == kHitNone;
}

//---------------------------------------------------------------------------
//
// 
//
//---------------------------------------------------------------------------

void insertspriteq(DDukeActor* const actor)
{
	if (spriteqamount > 0)
	{
		if (spriteq[spriteqloc] != nullptr)
		{
			// Why is this not deleted here?
			// Also todo: Make list size a CVAR.
			spriteq[spriteqloc]->s->xrepeat = 0;
			// deletesprite(spriteq[spriteqloc]);
		}
		spriteq[spriteqloc] = actor;
		spriteqloc = (spriteqloc + 1) % spriteqamount;
	}
	else actor->s->xrepeat = actor->s->yrepeat = 0;
}

//---------------------------------------------------------------------------
//
// consolidation of several nearly identical functions
//
//---------------------------------------------------------------------------

void lotsofstuff(DDukeActor* actor, int n, int spawntype)
{
	auto s = actor->s;
	for (int i = n; i > 0; i--)
	{
		int r1 = krand(), r2 = krand();	// using the RANDCORRECT version from RR.
		auto j = EGS(s->sector(), s->x, s->y, s->z - (r2 % (47 << 8)), spawntype, -32, 8, 8, r1 & 2047, 0, 0, actor, 5);
		if (j) j->s->cstat = krand() & 12;
	}
}

//---------------------------------------------------------------------------
//
// movesector - why is this in actors.cpp?
//
//---------------------------------------------------------------------------

void ms(DDukeActor* const actor)
{
	//T1,T2 and T3 are used for all the sector moving stuff!!!

	int tx, ty;
	auto s = actor->s;

	s->x += MulScale(s->xvel, bcos(s->ang), 14);
	s->y += MulScale(s->xvel, bsin(s->ang), 14);

	int j = actor->temp_data[1];
	int k = actor->temp_data[2];

	for(auto& wal : wallsofsector(actor->sector()))
	{
		rotatepoint(
			0, 0,
			msx[j], msy[j],
			k & 2047, &tx, &ty);

		dragpoint(&wal, s->x + tx, s->y + ty);
		j++;
	}
}

//---------------------------------------------------------------------------
//
// 
//
//---------------------------------------------------------------------------

void movecyclers(void)
{
	for (int q = numcyclers - 1; q >= 0; q--)
	{
		Cycler* c = &cyclers[q];
		auto sect = c->sector;

		int t = c->shade2;
		int j = t + bsin(c->lotag, -10);
		int cshade = c->shade1;

		if (j < cshade) j = cshade;
		else if (j > t)  j = t;

		c->lotag += sect->extra;
		if (c->state)
		{
			for (auto& wal : wallsofsector(sect))
			{
				if (wal.hitag != 1)
				{
					wal.shade = j;

					if ((wal.cstat & CSTAT_WALL_BOTTOM_SWAP) && wal.twoSided())
						wal.nextWall()->shade = j;

				}
			}
			sect->floorshade = sect->ceilingshade = j;
		}
	}
}

//---------------------------------------------------------------------------
//
// 
//
//---------------------------------------------------------------------------

void movedummyplayers(void)
{
	int p;

	DukeStatIterator iti(STAT_DUMMYPLAYER);
	while (auto act = iti.Next())
	{
		if (!act->GetOwner()) continue;
		p = act->GetOwner()->PlayerIndex();
		auto spri = act->s;

		if ((!isRR() && ps[p].on_crane != nullptr) || !ps[p].insector() || ps[p].cursector()->lotag != 1 || ps->GetActor()->s->extra <= 0)
		{
			ps[p].dummyplayersprite = nullptr;
			deletesprite(act);
			continue;
		}
		else
		{
			if (ps[p].on_ground && ps[p].on_warping_sector == 1 && ps[p].cursector()->lotag == 1)
			{
				spri->cstat = CSTAT_SPRITE_BLOCK_ALL;
				spri->z = spri->sector()->ceilingz + (27 << 8);
				spri->ang = ps[p].angle.ang.asbuild();
				if (act->temp_data[0] == 8)
					act->temp_data[0] = 0;
				else act->temp_data[0]++;
			}
			else
			{
				if (spri->sector()->lotag != 2) spri->z = spri->sector()->floorz;
				spri->cstat = 32768;
			}
		}

		spri->x += (ps[p].pos.x - ps[p].oposx);
		spri->y += (ps[p].pos.y - ps[p].oposy);
		setsprite(act, spri->pos);
	}
}

//---------------------------------------------------------------------------
//
// 
//
//---------------------------------------------------------------------------

void moveplayers(void)
{
	int otherx;

	DukeStatIterator iti(STAT_PLAYER);
	while (auto act = iti.Next())
	{
		int pn = act->PlayerIndex();
		auto p = &ps[pn];
		auto spri = act->s;

		if (act->GetOwner())
		{
			if (p->newOwner != nullptr) //Looking thru the camera
			{
				spri->x = p->oposx;
				spri->y = p->oposy;
				spri->z = p->oposz + gs.playerheight;
				spri->backupz();
				spri->ang = p->angle.oang.asbuild();
				setsprite(act, spri->pos);
			}
			else
			{
				if (ud.multimode > 1)
					otherp = findotherplayer(pn, &otherx);
				else
				{
					otherp = pn;
					otherx = 0;
				}

				execute(act, pn, otherx);

				if (ud.multimode > 1)
				{
					auto psp = ps[otherp].GetActor();
					if (psp->s->extra > 0)
					{
						if (spri->yrepeat > 32 && psp->s->yrepeat < 32)
						{
							if (otherx < 1400 && p->knee_incs == 0)
							{
								p->knee_incs = 1;
								p->weapon_pos = -1;
								p->actorsqu = ps[otherp].GetActor();
							}
						}
					}
				}
				if (ud.god)
				{
					spri->extra = gs.max_player_health;
					spri->cstat = 257;
					if (!isWW2GI() && !isRR())
						p->jetpack_amount = 1599;
				}

				if (p->actorsqu != nullptr)
				{
					p->angle.addadjustment(getincanglebam(p->angle.ang, bvectangbam(p->actorsqu->s->x - p->pos.x, p->actorsqu->s->y - p->pos.y)) >> 2);
				}

				if (spri->extra > 0)
				{
					// currently alive...

					act->SetHitOwner(act);

					if (ud.god == 0)
						if (fi.ceilingspace(spri->sector()) || fi.floorspace(spri->sector()))
							quickkill(p);
				}
				else
				{
					p->pos.x = spri->x;
					p->pos.y = spri->y;
					p->pos.z = spri->z - (20 << 8);

					p->newOwner = nullptr;

					if (p->wackedbyactor != nullptr && p->wackedbyactor->s->statnum < MAXSTATUS)
					{
						p->angle.addadjustment(getincanglebam(p->angle.ang, bvectangbam(p->wackedbyactor->s->x - p->pos.x, p->wackedbyactor->s->y - p->pos.y)) >> 1);
					}
				}
				spri->ang = p->angle.ang.asbuild();
			}
		}
		else
		{
			if (p->holoduke_on == nullptr)
			{
				deletesprite(act);
				continue;
			}

			spri->cstat = 0;

			if (spri->xrepeat < 42)
			{
				spri->xrepeat += 4;
				spri->cstat |= 2;
			}
			else spri->xrepeat = 42;
			if (spri->yrepeat < 36)
				spri->yrepeat += 4;
			else
			{
				spri->yrepeat = 36;
				if (spri->sector()->lotag != ST_2_UNDERWATER)
					makeitfall(act);
				if (spri->zvel == 0 && spri->sector()->lotag == ST_1_ABOVE_WATER)
					spri->z += (32 << 8);
			}

			if (spri->extra < 8)
			{
				spri->xvel = 128;
				spri->ang = p->angle.ang.asbuild();
				spri->extra++;
				ssp(act, CLIPMASK0);
			}
			else
			{
				spri->ang = 2047 - (p->angle.ang.asbuild());
				setsprite(act, spri->pos);
			}
		}

		if (spri->insector())
		{
			if (spri->sector()->ceilingstat & 1)
				spri->shade += (spri->sector()->ceilingshade - spri->shade) >> 1;
			else
				spri->shade += (spri->sector()->floorshade - spri->shade) >> 1;
		}
	}
}

//---------------------------------------------------------------------------
//
// 
//
//---------------------------------------------------------------------------

void movefx(void)
{
	int p;
	int x, ht;

	DukeStatIterator iti(STAT_FX);
	while (auto act = iti.Next())
	{
		auto spri = act->s;
		switch (spri->picnum)
		{
		case RESPAWN:
			if (spri->extra == 66)
			{
				auto j = spawn(act, spri->hitag);
				if (isRRRA() && j)
				{
					respawn_rrra(act, j);
				}
				else
				{
					deletesprite(act);
				}
			}
			else if (spri->extra > (66 - 13))
				spri->extra++;
			break;

		case MUSICANDSFX:

			ht = spri->hitag;

			if (act->temp_data[1] != (int)SoundEnabled())
			{
				act->temp_data[1] = SoundEnabled();
				act->temp_data[0] = 0;
			}

			if (spri->lotag >= 1000 && spri->lotag < 2000)
			{
				x = ldist(ps[screenpeek].GetActor(), act);
				if (x < ht && act->temp_data[0] == 0)
				{
					FX_SetReverb(spri->lotag - 1100);
					act->temp_data[0] = 1;
				}
				if (x >= ht && act->temp_data[0] == 1)
				{
					FX_SetReverb(0);
					FX_SetReverbDelay(0);
					act->temp_data[0] = 0;
				}
			}
			else if (spri->lotag < 999 && (unsigned)spri->sector()->lotag < ST_9_SLIDING_ST_DOOR && snd_ambience && spri->sector()->floorz != spri->sector()->ceilingz)
			{
				int flags = S_GetUserFlags(spri->lotag);
				if (flags & SF_MSFX)
				{
					int x = dist(ps[screenpeek].GetActor(), act);

					if (x < ht && act->temp_data[0] == 0)
					{
						// Start playing an ambience sound.
						S_PlayActorSound(spri->lotag, act, CHAN_AUTO, CHANF_LOOP);
						act->temp_data[0] = 1;  // AMBIENT_SFX_PLAYING
					}
					else if (x >= ht && act->temp_data[0] == 1)
					{
						// Stop playing ambience sound because we're out of its range.
						S_StopSound(spri->lotag, act);
					}
				}

				if ((flags & (SF_GLOBAL | SF_DTAG)) == SF_GLOBAL)
				{
					if (act->temp_data[4] > 0) act->temp_data[4]--;
					else for (p = connecthead; p >= 0; p = connectpoint2[p])
						if (p == myconnectindex && ps[p].cursector() == spri->sector())
						{
							S_PlaySound(spri->lotag + (unsigned)global_random % (spri->hitag + 1));
							act->temp_data[4] = 26 * 40 + (global_random % (26 * 40));
						}
				}
			}
			break;
		}
	}
}

//---------------------------------------------------------------------------
//
// split out of movestandables
//
//---------------------------------------------------------------------------

void movecrane(DDukeActor *actor, int crane)
{
	int* t = &actor->temp_data[0];
	auto spri = actor->s;
	auto sectp = spri->sector();
	int x;
	auto& cpt = cranes[t[4]];

	//t[0] = state
	//t[1] = checking sector number

	if (spri->xvel) getglobalz(actor);

	if (t[0] == 0) //Waiting to check the sector
	{
		DukeSectIterator it(actor->temp_sect);
		while (auto a2 = it.Next())
		{
			switch (a2->s->statnum)
			{
			case STAT_ACTOR:
			case STAT_ZOMBIEACTOR:
			case STAT_STANDABLE:
			case STAT_PLAYER:
				spri->ang = getangle(cpt.polex - spri->x, cpt.poley - spri->y);
				setsprite(a2, cpt.polex, cpt.poley, a2->s->z);
				t[0]++;
				return;
			}
		}
	}

	else if (t[0] == 1)
	{
		if (spri->xvel < 184)
		{
			spri->picnum = crane + 1;
			spri->xvel += 8;
		}
		//IFMOVING;	// JBF 20040825: see my rant above about this
		ssp(actor, CLIPMASK0);
		if (spri->sector() == actor->temp_sect)
			t[0]++;
	}
	else if (t[0] == 2 || t[0] == 7)
	{
		spri->z += (1024 + 512);

		if (t[0] == 2)
		{
			if ((sectp->floorz - spri->z) < (64 << 8))
				if (spri->picnum > crane) spri->picnum--;

			if ((sectp->floorz - spri->z) < (4096 + 1024))
				t[0]++;
		}
		if (t[0] == 7)
		{
			if ((sectp->floorz - spri->z) < (64 << 8))
			{
				if (spri->picnum > crane) spri->picnum--;
				else
				{
					if (actor->IsActiveCrane())
					{
						int p = findplayer(actor, &x);
						S_PlayActorSound(isRR() ? 390 : DUKE_GRUNT, ps[p].GetActor());
						if (ps[p].on_crane == actor)
							ps[p].on_crane = nullptr;
					}
					t[0]++;
					actor->SetActiveCrane(false);
				}
			}
		}
	}
	else if (t[0] == 3)
	{
		spri->picnum++;
		if (spri->picnum == (crane + 2))
		{
			int p = checkcursectnums(actor->temp_sect);
			if (p >= 0 && ps[p].on_ground)
			{
				actor->SetActiveCrane(true);
				ps[p].on_crane = actor;
				S_PlayActorSound(isRR() ? 390 : DUKE_GRUNT, ps[p].GetActor());
				ps[p].angle.settarget(spri->ang + 1024);
			}
			else
			{
				DukeSectIterator it(actor->temp_sect);
				while (auto a2 = it.Next())
				{
					switch (a2->s->statnum)
					{
					case 1:
					case 6:
						actor->SetOwner(a2);
						break;
					}
				}
			}

			t[0]++;//Grabbed the sprite
			t[2] = 0;
			return;
		}
	}
	else if (t[0] == 4) //Delay before going up
	{
		t[2]++;
		if (t[2] > 10)
			t[0]++;
	}
	else if (t[0] == 5 || t[0] == 8)
	{
		if (t[0] == 8 && spri->picnum < (crane + 2))
			if ((sectp->floorz - spri->z) > 8192)
				spri->picnum++;

		if (spri->z < cpt.z)
		{
			t[0]++;
			spri->xvel = 0;
		}
		else
			spri->z -= (1024 + 512);
	}
	else if (t[0] == 6)
	{
		if (spri->xvel < 192)
			spri->xvel += 8;
		spri->ang = getangle(cpt.x - spri->x, cpt.y - spri->y);
		ssp(actor, CLIPMASK0);
		if (((spri->x - cpt.x) * (spri->x - cpt.x) + (spri->y - cpt.y) * (spri->y - cpt.y)) < (128 * 128))
			t[0]++;
	}

	else if (t[0] == 9)
		t[0] = 0;

	setsprite(cpt.poleactor, spri->x, spri->y, spri->z - (34 << 8));

	auto Owner = actor->GetOwner();
	if (Owner != nullptr || actor->IsActiveCrane())
	{
		int p = findplayer(actor, &x);

		int j = fi.ifhitbyweapon(actor);
		if (j >= 0)
		{
			if (actor->IsActiveCrane())
				if (ps[p].on_crane == actor)
					ps[p].on_crane = nullptr;
			actor->SetActiveCrane(false);
			spri->picnum = crane;
			return;
		}

		if (Owner != nullptr)
		{
			setsprite(Owner, spri->pos);

			Owner->s->opos = spri->pos;

			spri->zvel = 0;
		}
		else if (actor->IsActiveCrane())
		{
			auto ang = ps[p].angle.ang.asbuild();
			ps[p].oposx = ps[p].pos.x;
			ps[p].oposy = ps[p].pos.y;
			ps[p].oposz = ps[p].pos.z;
			ps[p].pos.x = spri->x - bcos(ang, -6);
			ps[p].pos.y = spri->y - bsin(ang, -6);
			ps[p].pos.z = spri->z + (2 << 8);
			setsprite(ps[p].GetActor(), ps[p].pos.x, ps[p].pos.y, ps[p].pos.z);
			ps[p].setCursector(ps[p].GetActor()->s->sector());
		}
	}
}

//---------------------------------------------------------------------------
//
// 
//
//---------------------------------------------------------------------------

void movefountain(DDukeActor *actor, int fountain)
{
	int* t = &actor->temp_data[0];
	int x;
	if (t[0] > 0)
	{
		if (t[0] < 20)
		{
			t[0]++;

			actor->s->picnum++;

			if (actor->s->picnum == fountain + 3)
				actor->s->picnum = fountain + 1;
		}
		else
		{
			findplayer(actor, &x);

			if (x > 512)
			{
				t[0] = 0;
				actor->s->picnum = fountain;
			}
			else t[0] = 1;
		}
	}
}
//---------------------------------------------------------------------------
//
// 
//
//---------------------------------------------------------------------------

void moveflammable(DDukeActor* actor, int tire, int box, int pool)
{
	auto spri = actor->s;
	int j;
	if (actor->temp_data[0] == 1)
	{
		actor->temp_data[1]++;
		if ((actor->temp_data[1] & 3) > 0) return;

		if (!isRR() && spri->picnum == tire && actor->temp_data[1] == 32)
		{
			spri->cstat = 0;
			auto spawned = spawn(actor, pool);
			if (spawned) spawned->s->shade = 127;
		}
		else
		{
			if (spri->shade < 64) spri->shade++;
			else
			{
				deletesprite(actor);
				return;
			}
		}

		j = spri->xrepeat - (krand() & 7);
		if (j < 10)
		{
			deletesprite(actor);
			return;
		}

		spri->xrepeat = j;

		j = spri->yrepeat - (krand() & 7);
		if (j < 4)
		{
			deletesprite(actor);
			return;
		}
		spri->yrepeat = j;
	}
	if (box >= 0 && spri->picnum == box)
	{
		makeitfall(actor);
		actor->ceilingz = spri->sector()->ceilingz;
	}
}


//---------------------------------------------------------------------------
//
// 
//
//---------------------------------------------------------------------------

void detonate(DDukeActor *actor, int explosion)
{
	auto spri = actor->s;
	int* t = &actor->temp_data[0];
	earthquaketime = 16;

	DukeStatIterator itj(STAT_EFFECTOR);
	while (auto effector = itj.Next())
	{
		auto sj = effector->s;
		if (actor->s->hitag == sj->hitag)
		{
			if (sj->lotag == SE_13_EXPLOSIVE)
			{
				if (effector->temp_data[2] == 0)
					effector->temp_data[2] = 1;
			}
			else if (sj->lotag == SE_8_UP_OPEN_DOOR_LIGHTS)
				effector->temp_data[4] = 1;
			else if (sj->lotag == SE_18_INCREMENTAL_SECTOR_RISE_FALL)
			{
				if (effector->temp_data[0] == 0)
					effector->temp_data[0] = 1;
			}
			else if (sj->lotag == SE_21_DROP_FLOOR)
				effector->temp_data[0] = 1;
		}
	}

	spri->z -= (32 << 8);

	if ((t[3] == 1 && spri->xrepeat) || spri->lotag == -99)
	{
		int x = spri->extra;
		spawn(actor, explosion);
		fi.hitradius(actor, gs.seenineblastradius, x >> 2, x - (x >> 1), x - (x >> 2), x);
		S_PlayActorSound(PIPEBOMB_EXPLODE, actor);
	}

	if (spri->xrepeat)
		for (int x = 0; x < 8; x++) RANDOMSCRAP(actor);

	deletesprite(actor);

}

//---------------------------------------------------------------------------
//
// 
//
//---------------------------------------------------------------------------

void movemasterswitch(DDukeActor *actor, int spectype1, int spectype2)
{
	auto spri = actor->s;
	if (spri->yvel == 1)
	{
		spri->hitag--;
		if (spri->hitag <= 0)
		{
			operatesectors(spri->sector(), actor);

			DukeSectIterator it(actor->sector());
			while (auto effector = it.Next())
			{
				auto sj = effector->s;
				if (sj->statnum == STAT_EFFECTOR)
				{
					switch (sj->lotag)
					{
					case SE_2_EARTHQUAKE:
					case SE_21_DROP_FLOOR:
					case SE_31_FLOOR_RISE_FALL:
					case SE_32_CEILING_RISE_FALL:
					case SE_36_PROJ_SHOOTER:
						effector->temp_data[0] = 1;
						break;
					case SE_3_RANDOM_LIGHTS_AFTER_SHOT_OUT:
						effector->temp_data[4] = 1;
						break;
					}
				}
				else if (sj->statnum == STAT_STANDABLE)
				{
					if (sj->picnum == spectype1 || sj->picnum == spectype2) // SEENINE and OOZFILTER
					{
						sj->shade = -31;
					}
				}
			}
			// we cannot delete this because it may be used as a sound source.
			// This originally depended on undefined behavior as the deleted sprite was still used for the sound
			// with no checking if it got reused in the mean time.
			spri->picnum = 0;	// give it a picnum without any behavior attached, just in case
			spri->cstat |= CSTAT_SPRITE_INVISIBLE;
			spri->cstat2 |= CSTAT2_SPRITE_NOFIND;
			changeactorstat(actor, STAT_REMOVED);
		}
	}
}

//---------------------------------------------------------------------------
//
// 
//
//---------------------------------------------------------------------------

void movetrash(DDukeActor *actor)
{
	auto s = actor->s;
	if (s->xvel == 0) s->xvel = 1;
	if (ssp(actor, CLIPMASK0))
	{
		makeitfall(actor);
		if (krand() & 1) s->zvel -= 256;
		if (abs(s->xvel) < 48)
			s->xvel += (krand() & 3);
	}
	else deletesprite(actor);
}

//---------------------------------------------------------------------------
//
// 
//
//---------------------------------------------------------------------------

void movewaterdrip(DDukeActor *actor, int drip)
{
	auto s = actor->s;
	int* t = &actor->temp_data[0];

	if (t[1])
	{
		t[1]--;
		if (t[1] == 0)
			s->cstat &= 32767;
	}
	else
	{
		makeitfall(actor);
		ssp(actor, CLIPMASK0);
		if (s->xvel > 0) s->xvel -= 2;

		if (s->zvel == 0)
		{
			s->cstat |= 32768;

			if (s->pal != 2 && (isRR() || s->hitag == 0))
				S_PlayActorSound(SOMETHING_DRIPPING, actor);

			auto Owner = actor->GetOwner();
			if (!Owner || Owner->s->picnum != drip)
			{
				deletesprite(actor);
			}
			else
			{
				s->z = t[0];
				s->backupz();
				t[1] = 48 + (krand() & 31);
			}
		}
	}
}

//---------------------------------------------------------------------------
//
// 
//
//---------------------------------------------------------------------------

void movedoorshock(DDukeActor* actor)
{
	auto s = actor->s;
	auto sectp = s->sector();
	int j = abs(sectp->ceilingz - sectp->floorz) >> 9;
	s->yrepeat = j + 4;
	s->xrepeat = 16;
	s->z = sectp->floorz;
}

//---------------------------------------------------------------------------
//
// 
//
//---------------------------------------------------------------------------

void movetouchplate(DDukeActor* actor, int plate)
{
	auto s = actor->s;
	int* t = &actor->temp_data[0];
	auto sectp = s->sector();
	int x;
	int p;

	if (t[1] == 1 && s->hitag >= 0) //Move the sector floor
	{
		x = sectp->floorz;

		if (t[3] == 1)
		{
			if (x >= t[2])
			{
				sectp->floorz = x;
				t[1] = 0;
			}
			else
			{
				sectp->floorz += sectp->extra;
				p = checkcursectnums(s->sector());
				if (p >= 0) ps[p].pos.z += sectp->extra;
			}
		}
		else
		{
			if (x <= s->z)
			{
				sectp->floorz = s->z;
				t[1] = 0;
			}
			else
			{
				sectp->floorz -= sectp->extra;
				p = checkcursectnums(s->sector());
				if (p >= 0)
					ps[p].pos.z -= sectp->extra;
			}
		}
		return;
	}

	if (t[5] == 1) return;

	p = checkcursectnums(s->sector());
	if (p >= 0 && (ps[p].on_ground || s->ang == 512))
	{
		if (t[0] == 0 && !check_activator_motion(s->lotag))
		{
			t[0] = 1;
			t[1] = 1;
			t[3] = !t[3];
			operatemasterswitches(s->lotag);
			operateactivators(s->lotag, p);
			if (s->hitag > 0)
			{
				s->hitag--;
				if (s->hitag == 0) t[5] = 1;
			}
		}
	}
	else t[0] = 0;

	if (t[1] == 1)
	{
		DukeStatIterator it(STAT_STANDABLE);
		while (auto act2 = it.Next())
		{
			if (act2 != actor && act2->s->picnum == plate && act2->s->lotag == s->lotag)
			{
				act2->temp_data[1] = 1;
				act2->temp_data[3] = t[3];
			}
		}
	}
}

//---------------------------------------------------------------------------
//
// 
//
//---------------------------------------------------------------------------

void moveooz(DDukeActor* actor, int seenine, int seeninedead, int ooz, int explosion)
{
	auto s = actor->s;
	int* t = &actor->temp_data[0];
	int j;
	if (s->shade != -32 && s->shade != -33)
	{
		if (s->xrepeat)
			j = (fi.ifhitbyweapon(actor) >= 0);
		else
			j = 0;

		if (j || s->shade == -31)
		{
			if (j) s->lotag = 0;

			t[3] = 1;

			DukeStatIterator it(STAT_STANDABLE);
			while (auto act2 = it.Next())
			{
				auto ss = act2->s;
				if (s->hitag == ss->hitag && (ss->picnum == seenine || ss->picnum == ooz))
					ss->shade = -32;
			}
		}
	}
	else
	{
		if (s->shade == -32)
		{
			if (s->lotag > 0)
			{
				s->lotag -= 3;
				if (s->lotag <= 0) s->lotag = -99;
			}
			else
				s->shade = -33;
		}
		else
		{
			if (s->xrepeat > 0)
			{
				actor->temp_data[2]++;
				if (actor->temp_data[2] == 3)
				{
					if (s->picnum == ooz)
					{
						actor->temp_data[2] = 0;
						detonate(actor, explosion);
						return;
					}
					if (s->picnum != (seeninedead + 1))
					{
						actor->temp_data[2] = 0;

						if (s->picnum == seeninedead) s->picnum++;
						else if (s->picnum == seenine)
							s->picnum = seeninedead;
					}
					else
					{
						detonate(actor, explosion);
						return;
					}
				}
				return;
			}
			detonate(actor, explosion);
			return;
		}
	}
}

//---------------------------------------------------------------------------
//
// 
//
//---------------------------------------------------------------------------

void movecanwithsomething(DDukeActor* actor)
{
	makeitfall(actor);
	int j = fi.ifhitbyweapon(actor);
	if (j >= 0)
	{
		S_PlayActorSound(VENT_BUST, actor);
		for (j = 0; j < 10; j++)
			RANDOMSCRAP(actor);

		if (actor->s->lotag) spawn(actor, actor->s->lotag);
		deletesprite(actor);
	}
}

//---------------------------------------------------------------------------
//
// 
//
//---------------------------------------------------------------------------

void bounce(DDukeActor* actor)
{
	auto s = actor->s;
	int xvect = MulScale(s->xvel, bcos(s->ang), 10);
	int yvect = MulScale(s->xvel, bsin(s->ang), 10);
	int zvect = s->zvel;

	auto sectp = s->sector();

	auto delta = sectp->firstWall()->delta();
	int daang = getangle(delta.x, delta.y);

	int k, l;
	if (s->z < (actor->floorz + actor->ceilingz) >> 1)
		k = sectp->ceilingheinum;
	else
		k = sectp->floorheinum;

	int dax = MulScale(k, bsin(daang), 14);
	int day = MulScale(k, -bcos(daang), 14);
	int daz = 4096;

	k = xvect * dax + yvect * day + zvect * daz;
	l = dax * dax + day * day + daz * daz;
	if ((abs(k) >> 14) < l)
	{
		k = DivScale(k, l, 17);
		xvect -= MulScale(dax, k, 16);
		yvect -= MulScale(day, k, 16);
		zvect -= MulScale(daz, k, 16);
	}

	s->zvel = zvect;
	s->xvel = ksqrt(DMulScale(xvect, xvect, yvect, yvect, 8));
	s->ang = getangle(xvect, yvect);
}

//---------------------------------------------------------------------------
//
// taken out of moveweapon
//
//---------------------------------------------------------------------------

void movetongue(DDukeActor *actor, int tongue, int jaw)
{
	auto s = actor->s;
	actor->temp_data[0] = bsin(actor->temp_data[1], -9);
	actor->temp_data[1] += 32;
	if (actor->temp_data[1] > 2047)
	{
		deletesprite(actor);
		return;
	}

	auto Owner = actor->GetOwner();
	if (!Owner) return;

	if (Owner->s->statnum == MAXSTATUS)
		if (badguy(Owner) == 0)
		{
			deletesprite(actor);
			return;
		}

	s->ang = Owner->s->ang;
	s->x = Owner->s->x;
	s->y = Owner->s->y;
	if (Owner->s->picnum == TILE_APLAYER)
		s->z = Owner->s->z - (34 << 8);
	for (int k = 0; k < actor->temp_data[0]; k++)
	{
		auto q = EGS(s->sector(),
			s->x + MulScale(k, bcos(s->ang), 9),
			s->y + MulScale(k, bsin(s->ang), 9),
			s->z + ((k * Sgn(s->zvel)) * abs(s->zvel / 12)), tongue, -40 + (k << 1),
			8, 8, 0, 0, 0, actor, 5);
		if (q)
		{
			q->s->cstat = 128;
			q->s->pal = 8;
	}
	}
	int k = actor->temp_data[0];	// do not depend on the above loop counter.
	auto spawned = EGS(s->sector(),
		s->x + MulScale(k, bcos(s->ang), 9),
		s->y + MulScale(k, bsin(s->ang), 9),
		s->z + ((k * Sgn(s->zvel)) * abs(s->zvel / 12)), jaw, -40,
		32, 32, 0, 0, 0, actor, 5);
	if (spawned)
	{
		spawned->s->cstat = 128;
		if (actor->temp_data[1] > 512 && actor->temp_data[1] < (1024))
			spawned->s->picnum = jaw + 1;
	}
}

//---------------------------------------------------------------------------
//
// 
//
//---------------------------------------------------------------------------

void rpgexplode(DDukeActor *actor, int hit, const vec3_t &pos, int EXPLOSION2, int EXPLOSION2BOT, int newextra, int playsound)
{
	auto s = actor->s;
	auto explosion = spawn(actor, EXPLOSION2);
	if (!explosion) return;
	explosion->s->pos = pos;

	if (s->xrepeat < 10)
	{
		explosion->s->xrepeat = 6;
		explosion->s->yrepeat = 6;
	}
	else if (hit == kHitSector)
	{
		if (s->zvel > 0 && EXPLOSION2BOT >= 0)
			spawn(actor, EXPLOSION2BOT);
		else
		{
			explosion->s->cstat |= 8;
			explosion->s->z += (48 << 8);
		}
	}
	if (newextra > 0) s->extra = newextra;
	S_PlayActorSound(playsound, actor);

	if (s->xrepeat >= 10)
	{
		int x = s->extra;
		fi.hitradius(actor, gs.rpgblastradius, x >> 2, x >> 1, x - (x >> 2), x);
	}
	else
	{
		int x = s->extra + (global_random & 3);
		fi.hitradius(actor, (gs.rpgblastradius >> 1), x >> 2, x >> 1, x - (x >> 2), x);
	}
}

//---------------------------------------------------------------------------
//
// 
//
//---------------------------------------------------------------------------

bool respawnmarker(DDukeActor *actor, int yellow, int green)
{
	actor->temp_data[0]++;
	if (actor->temp_data[0] > gs.respawnitemtime)
	{
		deletesprite(actor);
		return false;
	}
	if (actor->temp_data[0] >= (gs.respawnitemtime >> 1) && actor->temp_data[0] < ((gs.respawnitemtime >> 1) + (gs.respawnitemtime >> 2)))
		actor->s->picnum = yellow;
	else if (actor->temp_data[0] > ((gs.respawnitemtime >> 1) + (gs.respawnitemtime >> 2)))
		actor->s->picnum = green;
	makeitfall(actor);
	return true;
}

//---------------------------------------------------------------------------
//
// 
//
//---------------------------------------------------------------------------

bool rat(DDukeActor* actor, bool makesound)
{
	auto s = actor->s;
	makeitfall(actor);
	if (ssp(actor, CLIPMASK0))
	{
		if (makesound && (krand() & 255) == 0) S_PlayActorSound(RATTY, actor);
		s->ang += (krand() & 31) - 15 + bsin(actor->temp_data[0] << 8, -11);
	}
	else
	{
		actor->temp_data[0]++;
		if (actor->temp_data[0] > 1)
		{
			deletesprite(actor);
			return false;
		}
		else s->ang = (krand() & 2047);
	}
	if (s->xvel < 128)
		s->xvel += 2;
	s->ang += (krand() & 3) - 6;
	return true;
}

//---------------------------------------------------------------------------
//
// 
//
//---------------------------------------------------------------------------

bool queball(DDukeActor *actor, int pocket, int queball, int stripeball)
{
	auto s = actor->s;
	if (s->xvel)
	{
		DukeStatIterator it(STAT_DEFAULT);
		while (auto aa = it.Next())
		{
			if (aa->s->picnum == pocket && ldist(aa, actor) < 52)
			{
				deletesprite(actor);
				return false;
			}
		}

		Collision coll;
		static_assert(sizeof(s->sectnum) != sizeof(int)); // this will error out when sectnum gets expanded.
		int sect = s->sectnum;
		int j = clipmove_ex(&s->pos, &sect,
			(MulScale(s->xvel, bcos(s->ang), 14) * TICSPERFRAME) << 11,
			(MulScale(s->xvel, bsin(s->ang), 14) * TICSPERFRAME) << 11,
			24L, (4 << 8), (4 << 8), CLIPMASK1, coll);
		s->sectnum = sect;

		if (j == kHitWall)
		{
			auto delta = coll.wall()->delta();
			int k = getangle(delta.x, delta.y);
			s->ang = ((k << 1) - s->ang) & 2047;
		}
		else if (j == kHitSprite)
		{
			fi.checkhitsprite(actor, coll.actor);
		}

		s->xvel--;
		if (s->xvel < 0) s->xvel = 0;
		if (s->picnum == stripeball)
		{
			s->cstat = 257;
			s->cstat |= 4 & s->xvel;
			s->cstat |= 8 & s->xvel;
		}
	}
	else
	{
		int x;
		int p = findplayer(actor, &x);

		if (x < 1596)
		{
			//						if(s->pal == 12)
			{
				int j = getincangle(ps[p].angle.ang.asbuild(), getangle(s->x - ps[p].pos.x, s->y - ps[p].pos.y));
				if (j > -64 && j < 64 && PlayerInput(p, SB_OPEN))
					if (ps[p].toggle_key_flag == 1)
					{
						DukeStatIterator it(STAT_ACTOR);
						DDukeActor *act2;
						while ((act2 = it.Next()))
						{
							auto sa = act2->s;
							if (sa->picnum == queball || sa->picnum == stripeball)
							{
								j = getincangle(ps[p].angle.ang.asbuild(), getangle(sa->x - ps[p].pos.x, sa->y - ps[p].pos.y));
								if (j > -64 && j < 64)
								{
									int l;
									findplayer(act2, &l);
									if (x > l) break;
								}
							}
						}
						if (act2 == nullptr)
						{
							if (s->pal == 12)
								s->xvel = 164;
							else s->xvel = 140;
							s->ang = ps[p].angle.ang.asbuild();
							ps[p].toggle_key_flag = 2;
						}
					}
			}
		}
		if (x < 512 && s->sector() == ps[p].cursector())
		{
			s->ang = getangle(s->x - ps[p].pos.x, s->y - ps[p].pos.y);
			s->xvel = 48;
		}
	}
	return true;
}

//---------------------------------------------------------------------------
//
// 
//
//---------------------------------------------------------------------------

void forcesphere(DDukeActor* actor, int forcesphere)
{
	auto s = actor->s;
	int* t = &actor->temp_data[0];
	auto sectp = s->sector();
	if (s->yvel == 0)
	{
		s->yvel = 1;

		for (int l = 512; l < (2048 - 512); l += 128)
			for (int j = 0; j < 2048; j += 128)
			{
				auto k = spawn(actor, forcesphere);
				if (k)
				{
					k->s->cstat = 257 + 128;
					k->s->clipdist = 64;
					k->s->ang = j;
					k->s->zvel = bsin(l, -5);
					k->s->xvel = bcos(l, -9);
					k->SetOwner(actor);
				}
			}
	}

	if (t[3] > 0)
	{
		if (s->zvel < 6144)
			s->zvel += 192;
		s->z += s->zvel;
		if (s->z > sectp->floorz)
			s->z = sectp->floorz;
		t[3]--;
		if (t[3] == 0)
		{
			deletesprite(actor);
			return;
		}
		else if (t[2] > 10)
		{
			DukeStatIterator it(STAT_MISC);
			while (auto aa = it.Next())
			{
				if (aa->GetOwner() == actor && aa->s->picnum == forcesphere)
					aa->temp_data[1] = 1 + (krand() & 63);
			}
			t[3] = 64;
		}
	}
}

//---------------------------------------------------------------------------
//
// 
//
//---------------------------------------------------------------------------

void recon(DDukeActor *actor, int explosion, int firelaser, int attacksnd, int painsnd, int roamsnd, int shift, int (*getspawn)(DDukeActor* i))
{
	auto s = actor->s;
	int* t = &actor->temp_data[0];
	auto sectp = s->sector();
	int a;

	getglobalz(actor);

	if (sectp->ceilingstat & 1)
		s->shade += (sectp->ceilingshade - s->shade) >> 1;
	else s->shade += (sectp->floorshade - s->shade) >> 1;

	if (s->z < sectp->ceilingz + (32 << 8))
		s->z = sectp->ceilingz + (32 << 8);

	if (ud.multimode < 2)
	{
		if (actor_tog == 1)
		{
			s->cstat = 32768;
			return;
		}
		else if (actor_tog == 2) s->cstat = 257;
	}
	if (fi.ifhitbyweapon(actor) >= 0)
	{
		if (s->extra < 0 && t[0] != -1)
		{
			t[0] = -1;
			s->extra = 0;
		}
		if (painsnd >= 0) S_PlayActorSound(painsnd, actor);
		RANDOMSCRAP(actor);
	}

	if (t[0] == -1)
	{
		s->z += 1024;
		t[2]++;
		if ((t[2] & 3) == 0) spawn(actor, explosion);
		getglobalz(actor);
		s->ang += 96;
		s->xvel = 128;
		int j = ssp(actor, CLIPMASK0);
		if (j != 1 || s->z > actor->floorz)
		{
			for (int l = 0; l < 16; l++)
				RANDOMSCRAP(actor);
			S_PlayActorSound(LASERTRIP_EXPLODE, actor);
			int sp = getspawn(actor);
			if (sp >= 0) spawn(actor, sp);
			ps[myconnectindex].actors_killed++;
			deletesprite(actor);
		}
		return;
	}
	else
	{
		if (s->z > actor->floorz - (48 << 8))
			s->z = actor->floorz - (48 << 8);
	}

	int x;
	int p = findplayer(actor, &x);
	auto Owner = actor->GetOwner();

	// 3 = findplayerz, 4 = shoot

	if (t[0] >= 4)
	{
		t[2]++;
		if ((t[2] & 15) == 0)
		{
			a = s->ang;
			s->ang = actor->tempang;
			if (attacksnd >= 0) S_PlayActorSound(attacksnd, actor);
			fi.shoot(actor, firelaser);
			s->ang = a;
		}
		if (t[2] > (26 * 3) || !cansee(s->x, s->y, s->z - (16 << 8), s->sector(), ps[p].pos.x, ps[p].pos.y, ps[p].pos.z, ps[p].cursector()))
		{
			t[0] = 0;
			t[2] = 0;
		}
		else actor->tempang +=
			getincangle(actor->tempang, getangle(ps[p].pos.x - s->x, ps[p].pos.y - s->y)) / 3;
	}
	else if (t[0] == 2 || t[0] == 3)
	{
		t[3] = 0;
		if (s->xvel > 0) s->xvel -= 16;
		else s->xvel = 0;

		if (t[0] == 2)
		{
			int l = ps[p].pos.z - s->z;
			if (abs(l) < (48 << 8)) t[0] = 3;
			else s->z += Sgn(ps[p].pos.z - s->z) << shift; // The shift here differs between Duke and RR.
		}
		else
		{
			t[2]++;
			if (t[2] > (26 * 3) || !cansee(s->x, s->y, s->z - (16 << 8), s->sector(), ps[p].pos.x, ps[p].pos.y, ps[p].pos.z, ps[p].cursector()))
			{
				t[0] = 1;
				t[2] = 0;
			}
			else if ((t[2] & 15) == 0 && attacksnd >= 0)
			{
				S_PlayActorSound(attacksnd, actor);
				fi.shoot(actor, firelaser);
			}
		}
		s->ang += getincangle(s->ang, getangle(ps[p].pos.x - s->x, ps[p].pos.y - s->y)) >> 2;
	}

	if (t[0] != 2 && t[0] != 3 && Owner)
	{
		int l = ldist(Owner, actor);
		if (l <= 1524)
		{
			a = s->ang;
			s->xvel >>= 1;
		}
		else a = getangle(Owner->s->x - s->x, Owner->s->y - s->y);

		if (t[0] == 1 || t[0] == 4) // Found a locator and going with it
		{
			l = dist(Owner, actor);

			if (l <= 1524) { if (t[0] == 1) t[0] = 0; else t[0] = 5; }
			else
			{
				// Control speed here
				if (l > 1524) { if (s->xvel < 256) s->xvel += 32; }
				else
				{
					if (s->xvel > 0) s->xvel -= 16;
					else s->xvel = 0;
				}
			}

			if (t[0] < 2) t[2]++;

			if (x < 6144 && t[0] < 2 && t[2] > (26 * 4))
			{
				t[0] = 2 + (krand() & 2);
				t[2] = 0;
				actor->tempang = s->ang;
			}
		}

		if (t[0] == 0 || t[0] == 5)
		{
			if (t[0] == 0)
				t[0] = 1;
			else t[0] = 4;
			auto NewOwner = LocateTheLocator(s->hitag, nullptr);
			if (!NewOwner)
			{
				s->hitag = actor->temp_data[5];
				NewOwner = LocateTheLocator(s->hitag, nullptr);
				if (!NewOwner)
				{
					deletesprite(actor);
					return;
				}
			}
			else s->hitag++;
			actor->SetOwner(NewOwner);
		}

		t[3] = getincangle(s->ang, a);
		s->ang += t[3] >> 3;

		if (s->z < Owner->s->z)
			s->z += 1024;
		else s->z -= 1024;
	}

	if (roamsnd >= 0 && S_CheckActorSoundPlaying(actor, roamsnd) < 1)
		S_PlayActorSound(roamsnd, actor);

	ssp(actor, CLIPMASK0);
}

//---------------------------------------------------------------------------
//
// 
//
//---------------------------------------------------------------------------

void ooz(DDukeActor *actor)
{
	getglobalz(actor);

	int j = (actor->floorz - actor->ceilingz) >> 9;
	if (j > 255) j = 255;

	int x = 25 - (j >> 1);
	if (x < 8) x = 8;
	else if (x > 48) x = 48;

	actor->s->yrepeat = j;
	actor->s->xrepeat = x;
	actor->s->z = actor->floorz;
}

//---------------------------------------------------------------------------
//
// 
//
//---------------------------------------------------------------------------

void reactor(DDukeActor* const actor, int REACTOR, int REACTOR2, int REACTORBURNT, int REACTOR2BURNT, int REACTORSPARK, int REACTOR2SPARK)
{
	spritetype* const s = actor->s;
	int* t = &actor->temp_data[0];
	auto sectp = s->sector();

	if (t[4] == 1)
	{
		DukeSectIterator it(actor->sector());
		while (auto act2 = it.Next())
		{
			auto sprj = act2->s;
			if (sprj->picnum == SECTOREFFECTOR)
			{
				if (sprj->lotag == 1)
				{
					sprj->lotag = -1;
					sprj->hitag = -1;
				}
			}
			else if (sprj->picnum == REACTOR)
			{
				sprj->picnum = REACTORBURNT;
			}
			else if (sprj->picnum == REACTOR2)
			{
				sprj->picnum = REACTOR2BURNT;
			}
			else if (sprj->picnum == REACTORSPARK || sprj->picnum == REACTOR2SPARK)
			{
				sprj->cstat = 32768;
			}
		}		
		return;
	}

	if (t[1] >= 20)
	{
		t[4] = 1;
		return;
	}

	int x;
	int p = findplayer(actor, &x);

	t[2]++;
	if (t[2] == 4) t[2] = 0;

	if (x < 4096)
	{
		if ((krand() & 255) < 16)
		{
			if (!S_CheckSoundPlaying(DUKE_LONGTERM_PAIN))
				S_PlayActorSound(DUKE_LONGTERM_PAIN, ps[p].GetActor());

			S_PlayActorSound(SHORT_CIRCUIT, actor);

			ps[p].GetActor()->s->extra--;
			SetPlayerPal(&ps[p], PalEntry(32, 32, 0, 0));
		}
		t[0] += 128;
		if (t[3] == 0)
			t[3] = 1;
	}
	else t[3] = 0;

	if (t[1])
	{
		t[1]++;

		t[4] = s->z;
		s->z = sectp->floorz - (krand() % (sectp->floorz - sectp->ceilingz));

		switch (t[1])
		{
		case 3:
		{
			//Turn on all of those flashing sectoreffector.
			fi.hitradius(actor, 4096,
				gs.impact_damage << 2,
				gs.impact_damage << 2,
				gs.impact_damage << 2,
				gs.impact_damage << 2);
			DukeStatIterator it(STAT_STANDABLE);
			while (auto act2 = it.Next())
			{
				auto sj = act2->s;
				if (sj->picnum == MASTERSWITCH)
					if (sj->hitag == s->hitag)
						if (sj->yvel == 0)
							sj->yvel = 1;
			}
			break;
		}
		case 4:
		case 7:
		case 10:
		case 15:
		{
			DukeSectIterator it(actor->sector());
			while (auto a2 = it.Next())
			{
				if (a2 != actor)
				{
					deletesprite(a2);
					break;
				}
			}
			break;
		}
		}
		for (x = 0; x < 16; x++)
			RANDOMSCRAP(actor);

		s->z = t[4];
		t[4] = 0;

	}
	else
	{
		int j = fi.ifhitbyweapon(actor);
		if (j >= 0)
		{
			for (x = 0; x < 32; x++)
				RANDOMSCRAP(actor);
			if (s->extra < 0)
				t[1] = 1;
		}
	}
}

//---------------------------------------------------------------------------
//
// 
//
//---------------------------------------------------------------------------

void camera(DDukeActor *actor)
{
	spritetype* s = actor->s;
	int* t = &actor->temp_data[0];
	if (t[0] == 0)
	{
		if (gs.camerashitable)
		{
			int j = fi.ifhitbyweapon(actor);
			if (j >= 0)
			{
				t[0] = 1; // static
				s->cstat = 32768;
				for (int x = 0; x < 5; x++)
					RANDOMSCRAP(actor);
				return;
			}
		}
		
		if (s->hitag > 0)
		{
			// alias our temp_data array indexes.
			auto& increment = t[1];
			auto& minimum = t[2];
			auto& maximum = t[3];
			auto& setupflag = t[4];

			// set up camera if already not.
			if (setupflag != 1)
			{
				increment = 8;
				minimum = s->ang - s->hitag - increment;
				maximum = s->ang + s->hitag - increment;
				setupflag = 1;
			}

			// update angle accordingly.
			if (s->ang == minimum || s->ang == maximum)
			{
				increment = -increment;
				s->ang += increment;
			}
			else if (s->ang + increment < minimum)
			{
				s->ang = minimum;
			}
			else if (s->ang + increment > maximum)
			{
				s->ang = maximum;
			}
			else
			{
				s->ang += increment;
			}
		}
	}
}

//---------------------------------------------------------------------------
//
// taken out of moveexplosion
//
//---------------------------------------------------------------------------

void forcesphereexplode(DDukeActor *actor)
{
	int* t = &actor->temp_data[0];
	int l = actor->s->xrepeat;
	if (t[1] > 0)
	{
		t[1]--;
		if (t[1] == 0)
		{
			deletesprite(actor);
			return;
		}
	}
	auto Owner = actor->GetOwner();
	if (!Owner) return;
	if (Owner->temp_data[1] == 0)
	{
		if (t[0] < 64)
		{
			t[0]++;
			l += 3;
		}
	}
	else
		if (t[0] > 64)
		{
			t[0]--;
			l -= 3;
		}

	actor->s->x = Owner->s->x;
	actor->s->y = Owner->s->y;
	actor->s->z = Owner->s->z;
	actor->s->ang += Owner->temp_data[0];

	if (l > 64) l = 64;
	else if (l < 1) l = 1;

	actor->s->xrepeat = l;
	actor->s->yrepeat = l;
	actor->s->shade = (l >> 1) - 48;

	for (int j = t[0]; j > 0; j--)
		ssp(actor, CLIPMASK0);
}

//---------------------------------------------------------------------------
//
// 
//
//---------------------------------------------------------------------------

void watersplash2(DDukeActor* actor)
{
	auto sectp = actor->sector();
	int* t = &actor->temp_data[0];
	t[0]++;
	if (t[0] == 1)
	{
		if (sectp->lotag != 1 && sectp->lotag != 2)
		{
			deletesprite(actor);
			return;
		}
		if (!S_CheckSoundPlaying(ITEM_SPLASH))
			S_PlayActorSound(ITEM_SPLASH, actor);
	}
	if (t[0] == 3)
	{
		t[0] = 0;
		t[1]++;
	}
	if (t[1] == 5)
		deletesprite(actor);
}

//---------------------------------------------------------------------------
//
// 
//
//---------------------------------------------------------------------------

void frameeffect1(DDukeActor *actor)
{
	int* t = &actor->temp_data[0];
	auto Owner = actor->GetOwner();
	if (Owner)
	{
		t[0]++;

		if (t[0] > 7)
		{
			deletesprite(actor);
			return;
		}
		else if (t[0] > 4) actor->s->cstat |= 512 + 2;
		else if (t[0] > 2) actor->s->cstat |= 2;
		actor->s->xoffset = Owner->s->xoffset;
		actor->s->yoffset = Owner->s->yoffset;
	}
}

//---------------------------------------------------------------------------
//
// 
//
//---------------------------------------------------------------------------

bool money(DDukeActor* actor, int BLOODPOOL)
{
	auto s = actor->s;
	auto sectp = s->sector();

	s->xvel = (krand() & 7) + bsin(actor->temp_data[0], -9);
	actor->temp_data[0] += (krand() & 63);
	if ((actor->temp_data[0] & 2047) > 512 && (actor->temp_data[0] & 2047) < 1596)
	{
		if (sectp->lotag == 2)
		{
			if (s->zvel < 64)
				s->zvel += (gs.gravity >> 5) + (krand() & 7);
		}
		else
			if (s->zvel < 144)
				s->zvel += (gs.gravity >> 5) + (krand() & 7);
	}

	ssp(actor, CLIPMASK0);

	if ((krand() & 3) == 0)
		setsprite(actor, s->pos);

	if (s->sectnum == -1)
	{
		deletesprite(actor);
		return false;
	}
	int l = getflorzofslopeptr(s->sector(), s->x, s->y);

	if (s->z > l)
	{
		s->z = l;

		insertspriteq(actor);
		s->picnum++;

		DukeStatIterator it(STAT_MISC);
		while (auto aa = it.Next())
		{
			if (aa->s->picnum == BLOODPOOL)
				if (ldist(actor, aa) < 348)
				{
					s->pal = 2;
					break;
				}
		}
	}
	return true;
}

//---------------------------------------------------------------------------
//
// 
//
//---------------------------------------------------------------------------

bool jibs(DDukeActor *actor, int JIBS6, bool timeout, bool callsetsprite, bool floorcheck, bool zcheck1, bool zcheck2)
{
	spritetype* s = actor->s;
	auto sectp = s->sector();
	int* t = &actor->temp_data[0];

	if (s->xvel > 0) s->xvel--;
	else s->xvel = 0;

	if (timeout)
	{
		if (t[5] < 30 * 10)
			t[5]++;
		else
		{
			deletesprite(actor);
			return false;
		}
	}

	if (s->zvel > 1024 && s->zvel < 1280)
	{
		setsprite(actor, s->pos);
		sectp = s->sector();
	}

	if (callsetsprite) setsprite(actor, s->pos);

	// this was after the slope calls, but we should avoid calling that for invalid sectors.
	if (!s->insector())
	{
		deletesprite(actor);
		return false;
	}

	int l = getflorzofslopeptr(sectp, s->x, s->y);
	int x = getceilzofslopeptr(sectp, s->x, s->y);
	if (x == l)
	{
		deletesprite(actor);
		return false;
	}

	if (s->z < l - (2 << 8))
	{
		if (t[1] < 2) t[1]++;
		else if (sectp->lotag != 2)
		{
			t[1] = 0;
			if (zcheck1)
			{
				if (t[0] > 6) t[0] = 0;
				else t[0]++;
			}
			else
			{
				if (t[0] > 2)
					t[0] = 0;
				else t[0]++;
			}
		}

		if (s->zvel < 6144)
		{
			if (sectp->lotag == 2)
			{
				if (s->zvel < 1024)
					s->zvel += 48;
				else s->zvel = 1024;
			}
			else s->zvel += gs.gravity - 50;
		}

		s->x += MulScale(s->xvel, bcos(s->ang), 14);
		s->y += MulScale(s->xvel, bsin(s->ang), 14);
		s->z += s->zvel;

		if (floorcheck && s->z >= s->sector()->floorz)
		{
			deletesprite(actor);
			return false;
		}
	}
	else
	{
		if (zcheck2)
		{
			deletesprite(actor);
			return false;
		}
		if (t[2] == 0)
		{
			if (s->sectnum == -1)
			{
				deletesprite(actor);
				return false;
			}
			if ((s->sector()->floorstat & 2))
			{
				deletesprite(actor);
				return false;
			}
			t[2]++;
		}
		l = getflorzofslopeptr(s->sector(), s->x, s->y);

		s->z = l - (2 << 8);
		s->xvel = 0;

		if (s->picnum == JIBS6)
		{
			t[1]++;
			if ((t[1] & 3) == 0 && t[0] < 7)
				t[0]++;
			if (t[1] > 20)
			{
				deletesprite(actor);
				return false;
			}
		}
		else { s->picnum = JIBS6; t[0] = 0; t[1] = 0; }
	}
	return true;
}

//---------------------------------------------------------------------------
//
// 
//
//---------------------------------------------------------------------------

bool bloodpool(DDukeActor* actor, bool puke, int TIRE)
{
	spritetype* s = actor->s;
	auto sectp = s->sector();
	int* t = &actor->temp_data[0];

	if (t[0] == 0)
	{
		t[0] = 1;
		if (sectp->floorstat & 2)
		{
			deletesprite(actor);
			return false;
		}
		else insertspriteq(actor);
	}

	makeitfall(actor);

	int x;
	int p = findplayer(actor, &x);

	s->z = actor->floorz - (FOURSLEIGHT);

	if (t[2] < 32)
	{
		t[2]++;
		if (actor->picnum == TIRE)
		{
			if (s->xrepeat < 64 && s->yrepeat < 64)
			{
				s->xrepeat += krand() & 3;
				s->yrepeat += krand() & 3;
			}
		}
		else
		{
			if (s->xrepeat < 32 && s->yrepeat < 32)
			{
				s->xrepeat += krand() & 3;
				s->yrepeat += krand() & 3;
			}
		}
	}

	if (x < 844 && s->xrepeat > 6 && s->yrepeat > 6)
	{
		if (s->pal == 0 && (krand() & 255) < 16 && !puke)
		{
			if (ps[p].boot_amount > 0)
				ps[p].boot_amount--;
			else
			{
				if (!S_CheckSoundPlaying(DUKE_LONGTERM_PAIN))
					S_PlayActorSound(DUKE_LONGTERM_PAIN, ps[p].GetActor());
				ps[p].GetActor()->s->extra--;
				SetPlayerPal(&ps[p], PalEntry(32, 16, 0, 0));
			}
		}

		if (t[1] == 1) return false;
		t[1] = 1;

		if (actor->picnum == TIRE)
			ps[p].footprintcount = 10;
		else ps[p].footprintcount = 3;

		ps[p].footprintpal = s->pal;
		ps[p].footprintshade = s->shade;

		if (t[2] == 32)
		{
			s->xrepeat -= 6;
			s->yrepeat -= 6;
		}
	}
	else t[1] = 0;
	return true;
}

//---------------------------------------------------------------------------
//
// 
//
//---------------------------------------------------------------------------

void shell(DDukeActor* actor, bool morecheck)
{
	spritetype* s = actor->s;
	auto sectp = s->sector();
	int* t = &actor->temp_data[0];

	ssp(actor, CLIPMASK0);

	if (!s->insector() || morecheck)
	{
		deletesprite(actor);
		return;
	}

	if (sectp->lotag == 2)
	{
		t[1]++;
		if (t[1] > 8)
		{
			t[1] = 0;
			t[0]++;
			t[0] &= 3;
		}
		if (s->zvel < 128) s->zvel += (gs.gravity / 13); // 8
		else s->zvel -= 64;
		if (s->xvel > 0)
			s->xvel -= 4;
		else s->xvel = 0;
	}
	else
	{
		t[1]++;
		if (t[1] > 3)
		{
			t[1] = 0;
			t[0]++;
			t[0] &= 3;
		}
		if (s->zvel < 512) s->zvel += (gs.gravity / 3); // 52;
		if (s->xvel > 0)
			s->xvel--;
		else
		{
			deletesprite(actor);
		}
	}
}

//---------------------------------------------------------------------------
//
// 
//
//---------------------------------------------------------------------------

void glasspieces(DDukeActor* actor)
{
	spritetype* s = actor->s;
	auto sectp = s->sector();
	int* t = &actor->temp_data[0];

	makeitfall(actor);

	if (s->zvel > 4096) s->zvel = 4096;
	if (!s->insector())
	{
		deletesprite(actor);
		return;
	}

	if (s->z == actor->floorz - (FOURSLEIGHT) && t[0] < 3)
	{
		s->zvel = -((3 - t[0]) << 8) - (krand() & 511);
		if (sectp->lotag == 2)
			s->zvel >>= 1;
		s->xrepeat >>= 1;
		s->yrepeat >>= 1;
		if (rnd(96))
			setsprite(actor, s->pos);
		t[0]++;//Number of bounces
	}
	else if (t[0] == 3)
	{
		deletesprite(actor);
		return;
	}

	if (s->xvel > 0)
	{
		s->xvel -= 2;
		s->cstat = ((s->xvel & 3) << 2);
	}
	else s->xvel = 0;

	ssp(actor, CLIPMASK0);
}

//---------------------------------------------------------------------------
//
// 
//
//---------------------------------------------------------------------------

void scrap(DDukeActor* actor, int SCRAP1, int SCRAP6)
{
	spritetype* s = actor->s;
	auto sectp = s->sector();
	int* t = &actor->temp_data[0];

	if (s->xvel > 0)
		s->xvel--;
	else s->xvel = 0;

	if (s->zvel > 1024 && s->zvel < 1280)
	{
		setsprite(actor, s->pos);
		sectp = s->sector();
	}

	if (s->z < sectp->floorz - (2 << 8))
	{
		if (t[1] < 1) t[1]++;
		else
		{
			t[1] = 0;

			if (s->picnum < SCRAP6 + 8)
			{
				if (t[0] > 6)
					t[0] = 0;
				else t[0]++;
			}
			else
			{
				if (t[0] > 2)
					t[0] = 0;
				else t[0]++;
			}
		}
		if (s->zvel < 4096) s->zvel += gs.gravity - 50;
		s->x += MulScale(s->xvel, bcos(s->ang), 14);
		s->y += MulScale(s->xvel, bsin(s->ang), 14);
		s->z += s->zvel;
	}
	else
	{
		if (s->picnum == SCRAP1 && s->yvel > 0)
		{
			auto spawned = spawn(actor, s->yvel);
			if (spawned)
			{
				setsprite(spawned, s->pos);
				getglobalz(spawned);
				spawned->s->hitag = spawned->s->lotag = 0;
			}
		}
		deletesprite(actor);
	}
}

//---------------------------------------------------------------------------
//
// 
//
//---------------------------------------------------------------------------

void gutsdir(DDukeActor* actor, int gtype, int n, int p)
{
	int sx, sy;

	if (badguy(actor) && actor->s->xrepeat < 16)
		sx = sy = 8;
	else sx = sy = 32;

	int gutz = actor->s->z - (8 << 8);
	int floorz = getflorzofslope(actor->s->sectnum, actor->s->x, actor->s->y);

	if (gutz > (floorz - (8 << 8)))
		gutz = floorz - (8 << 8);

	gutz += gs.actorinfo[actor->s->picnum].gutsoffset;

	for (int j = 0; j < n; j++)
	{
		int a = krand() & 2047;
		int r1 = krand();
		int r2 = krand();
		// TRANSITIONAL: owned by a player???
		EGS(actor->s->sector(), actor->s->x, actor->s->y, gutz, gtype, -32, sx, sy, a, 256 + (r2 & 127), -512 - (r1 & 2047), ps[p].GetActor(), 5);
	}
}

//---------------------------------------------------------------------------
//
// taken out of moveeffectors
//
//---------------------------------------------------------------------------

void handle_se00(DDukeActor* actor, int LASERLINE)
{
	auto s = actor->s;
	int* t = &actor->temp_data[0];
	sectortype *sect = actor->sector();

	int zchange = 0;

	auto Owner = actor->GetOwner();

	if (!Owner || Owner->s->lotag == -1)
	{
		deletesprite(actor);
		return;
	}

	int q = sect->extra >> 3;
	int l = 0;

	if (sect->lotag == 30)
	{
		q >>= 2;

		if (s->extra == 1)
		{
			if (actor->tempang < 256)
			{
				actor->tempang += 4;
				if (actor->tempang >= 256)
					callsound(s->sector(), actor);
				if (s->clipdist) l = 1;
				else l = -1;
			}
			else actor->tempang = 256;

			if (sect->floorz > s->z) //z's are touching
			{
				sect->floorz -= 512;
				zchange = -512;
				if (sect->floorz < s->z)
					sect->floorz = s->z;
			}

			else if (sect->floorz < s->z) //z's are touching
			{
				sect->floorz += 512;
				zchange = 512;
				if (sect->floorz > s->z)
					sect->floorz = s->z;
			}
		}
		else if (s->extra == 3)
		{
			if (actor->tempang > 0)
			{
				actor->tempang -= 4;
				if (actor->tempang <= 0)
					callsound(s->sector(), actor);
				if (s->clipdist) l = -1;
				else l = 1;
			}
			else actor->tempang = 0;

			if (sect->floorz > actor->temp_data[3]) //z's are touching
			{
				sect->floorz -= 512;
				zchange = -512;
				if (sect->floorz < actor->temp_data[3])
					sect->floorz = actor->temp_data[3];
			}

			else if (sect->floorz < actor->temp_data[3]) //z's are touching
			{
				sect->floorz += 512;
				zchange = 512;
				if (sect->floorz > actor->temp_data[3])
					sect->floorz = actor->temp_data[3];
			}
		}

		s->ang += (l * q);
		t[2] += (l * q);
	}
	else
	{
		if (Owner->temp_data[0] == 0) return;
		if (Owner->temp_data[0] == 2)
		{
			deletesprite(actor);
			return;
		}

		if (Owner->s->ang > 1024)
			l = -1;
		else l = 1;
		if (t[3] == 0)
			t[3] = ldist(actor, Owner);
		s->xvel = t[3];
		s->x = Owner->s->x;
		s->y = Owner->s->y;
		s->ang += (l * q);
		t[2] += (l * q);
	}

	if (l && (sect->floorstat & 64))
	{
		int p;
		for (p = connecthead; p >= 0; p = connectpoint2[p])
		{
			if (ps[p].cursector() == s->sector() && ps[p].on_ground == 1)
			{
				ps[p].angle.addadjustment(l * q);

				ps[p].pos.z += zchange;

				int m, x;
				rotatepoint(Owner->s->x, Owner->s->y,	ps[p].pos.x, ps[p].pos.y, (q * l), &m, &x);

				ps[p].bobposx += m - ps[p].pos.x;
				ps[p].bobposy += x - ps[p].pos.y;

				ps[p].pos.x = m;
				ps[p].pos.y = x;

				auto psp = ps[p].GetActor();
				if (psp->s->extra <= 0)
				{
					psp->s->x = m;
					psp->s->y = x;
				}
			}
		}
		DukeSectIterator itp(actor->sector());
		while (auto ap = itp.Next())
		{
			auto sprp = ap->s;
			if (sprp->statnum != 3 && sprp->statnum != 4)
				if (LASERLINE < 0 || sprp->picnum != LASERLINE)
				{
					if (sprp->picnum == TILE_APLAYER && ap->GetOwner())
					{
						continue;
					}

					sprp->ang += (l * q);
					sprp->ang &= 2047;

					sprp->z += zchange;
					rotatepoint(Owner->s->x, Owner->s->y, ap->s->x, ap->s->y, (q* l), &ap->s->x, &ap->s->y);
				}
		}

	}
	ms(actor);
}

//---------------------------------------------------------------------------
//
// 
//
//---------------------------------------------------------------------------

void handle_se01(DDukeActor *actor)
{
	int* t = &actor->temp_data[0];
	int sh = actor->s->hitag;
	if (actor->GetOwner() == nullptr) //Init
	{
		actor->SetOwner(actor);

		DukeStatIterator it(STAT_EFFECTOR);
		while (auto ac = it.Next())
		{
			if (ac->s->lotag == 19 && ac->s->hitag == sh)
			{
				t[0] = 0;
				break;
			}
		}
	}
}

//---------------------------------------------------------------------------
//
// 
//
//---------------------------------------------------------------------------

void handle_se14(DDukeActor* actor, bool checkstat, int RPG, int JIBS6)
{
	auto const s = actor->s;
	int* t = &actor->temp_data[0];
	auto sc = actor->sector();
	int st = s->lotag;

	if (actor->GetOwner() == nullptr)
	{
		auto NewOwner = LocateTheLocator(t[3], actor->temp_sect);

		if (NewOwner == nullptr)
		{
			I_Error("Could not find any locators for SE# 6 and 14 with a hitag of %d.", t[3]);
		}
		actor->SetOwner(NewOwner);
	}

	auto Owner = actor->GetOwner();
	int j = ldist(Owner, actor);

	if (j < 1024)
	{
		if (st == 6)
			if (Owner->s->hitag & 1)
				t[4] = sc->extra; //Slow it down
		t[3]++;
		auto NewOwner = LocateTheLocator(t[3], actor->temp_sect);
		if (NewOwner == nullptr)
		{
			t[3] = 0;
			NewOwner = LocateTheLocator(0, actor->temp_sect);
		}
		if (NewOwner) actor->SetOwner(NewOwner);
	}

	Owner = actor->GetOwner();
	if (s->xvel)
	{
		int x = getangle(Owner->s->x - s->x, Owner->s->y - s->y);
		int q = getincangle(s->ang, x) >> 3;

		t[2] += q;
		s->ang += q;

		bool statstate = (!checkstat || ((sc->floorstat & 1) == 0 && (sc->ceilingstat & 1) == 0));
		if (s->xvel == sc->extra)
		{
			if (statstate)
			{
				if (!S_CheckSoundPlaying(actor->lastvx))
					S_PlayActorSound(actor->lastvx, actor);
			}
			if ((!checkstat || !statstate) && (ud.monsters_off == 0 && sc->floorpal == 0 && (sc->floorstat & 1) && rnd(8)))
			{
				int p = findplayer(actor, &x);
				if (x < 20480)
				{
					j = s->ang;
					s->ang = getangle(s->x - ps[p].pos.x, s->y - ps[p].pos.y);
					fi.shoot(actor, RPG);
					s->ang = j;
				}
			}
		}

		if (s->xvel <= 64 && statstate)
			S_StopSound(actor->lastvx, actor);

		if ((sc->floorz - sc->ceilingz) < (108 << 8))
		{
			if (ud.clipping == 0 && s->xvel >= 192)
				for (int p = connecthead; p >= 0; p = connectpoint2[p])
				{
					auto psp = ps[p].GetActor();
					if (psp->s->extra > 0)
					{
						auto k = ps[p].cursector();
						updatesector(ps[p].pos.x, ps[p].pos.y, &k);
						if ((k == nullptr && ud.clipping == 0) || (k == s->sector() && ps[p].cursector() != s->sector()))
						{
							ps[p].pos.x = s->x;
							ps[p].pos.y = s->y;
							ps[p].setCursector(s->sector());

							setsprite(ps[p].GetActor(), s->pos);
							quickkill(&ps[p]);
						}
					}
				}
		}

		int m = MulScale(s->xvel, bcos(s->ang), 14);
		x = MulScale(s->xvel, bsin(s->ang), 14);

		for (int p = connecthead; p >= 0; p = connectpoint2[p])
		{
			auto psp = ps[p].GetActor();
			if (ps[p].insector() && ps[p].cursector()->lotag != 2)
			{
				if (po[p].os == s->sector())
				{
					po[p].ox += m;
					po[p].oy += x;
				}

				if (s->sectnum == psp->s->sectnum)
				{
					rotatepoint(s->x, s->y, ps[p].pos.x, ps[p].pos.y, q, &ps[p].pos.x, &ps[p].pos.y);

					ps[p].pos.x += m;
					ps[p].pos.y += x;

					ps[p].bobposx += m;
					ps[p].bobposy += x;

					ps[p].angle.addadjustment(q);

					if (numplayers > 1)
					{
						ps[p].oposx = ps[p].pos.x;
						ps[p].oposy = ps[p].pos.y;
					}
					if (psp->s->extra <= 0)
					{
						psp->s->x = ps[p].pos.x;
						psp->s->y = ps[p].pos.y;
					}
				}
			}
		}
		DukeSectIterator it(actor->sector());
		while (auto a2 = it.Next())
		{
			auto sj = a2->s;
			if (sj->statnum != 10 && sj->sector()->lotag != 2 && sj->picnum != SECTOREFFECTOR && sj->picnum != LOCATORS)
			{
				rotatepoint(s->x, s->y, sj->x, sj->y, q, &sj->x, &sj->y);

				sj->x += m;
				sj->y += x;

				sj->ang += q;

				if (numplayers > 1)
				{
					sj->backupvec2();
				}
			}
		}

		ms(actor);
		setsprite(actor, s->pos);

		if ((sc->floorz - sc->ceilingz) < (108 << 8))
		{
			if (ud.clipping == 0 && s->xvel >= 192)
				for (int p = connecthead; p >= 0; p = connectpoint2[p])
				{
					if (ps[p].GetActor()->s->extra > 0)
					{
						auto k = ps[p].cursector();
						updatesector(ps[p].pos.x, ps[p].pos.y, &k);
						if ((k == nullptr && ud.clipping == 0) || (k == s->sector() && ps[p].cursector() != s->sector()))
						{
							ps[p].oposx = ps[p].pos.x = s->x;
							ps[p].oposy = ps[p].pos.y = s->y;
							ps[p].setCursector(s->sector());

							setsprite(ps[p].GetActor(), s->pos);
							quickkill(&ps[p]);
						}
					}
				}

			auto Owner = actor->GetOwner();
			if (Owner)
			{
				DukeSectIterator itr(Owner->sector());
				while (auto a2 = itr.Next())
				{
					if (a2->s->statnum == 1 && badguy(a2) && a2->s->picnum != SECTOREFFECTOR && a2->s->picnum != LOCATORS)
					{
						int k = a2->s->sectnum;
						updatesector(a2->s->x, a2->s->y, &k);
						if (a2->s->extra >= 0 && k == s->sectnum)
						{
							gutsdir(a2, JIBS6, 72, myconnectindex);
							S_PlayActorSound(SQUISHED, actor);
							deletesprite(a2);
						}
					}
				}
			}
		}
	}
}

//---------------------------------------------------------------------------
//
// 
//
//---------------------------------------------------------------------------

void handle_se30(DDukeActor *actor, int JIBS6)
{
	auto s = actor->s;
	int* t = &actor->temp_data[0];
	auto sc = actor->sector();

	auto Owner = actor->GetOwner();
	if (Owner == nullptr)
	{
		t[3] = !t[3];
		Owner = LocateTheLocator(t[3], actor->temp_sect);
		actor->SetOwner(Owner);
	}
	else
	{
		if (t[4] == 1) // Starting to go
		{
			if (ldist(Owner, actor) < (2048 - 128))
				t[4] = 2;
			else
			{
				if (s->xvel == 0)
					operateactivators(s->hitag + (!t[3]), -1);
				if (s->xvel < 256)
					s->xvel += 16;
			}
		}
		if (t[4] == 2)
		{
			int l = FindDistance2D(Owner->s->x - s->x, Owner->s->y - s->y);

			if (l <= 128)
				s->xvel = 0;

			if (s->xvel > 0)
				s->xvel -= 16;
			else
			{
				s->xvel = 0;
				operateactivators(s->hitag + (short)t[3], -1);
				actor->SetOwner(nullptr);
				s->ang += 1024;
				t[4] = 0;
				fi.operateforcefields(actor, s->hitag);
			}
		}
	}

	if (s->xvel)
	{
		int l = MulScale(s->xvel, bcos(s->ang), 14);
		int x = MulScale(s->xvel, bsin(s->ang), 14);

		if ((sc->floorz - sc->ceilingz) < (108 << 8))
			if (ud.clipping == 0)
				for (int p = connecthead; p >= 0; p = connectpoint2[p])
					{
					auto psp = ps[p].GetActor();
					if (psp->s->extra > 0)
					{
						auto k = ps[p].cursector();
						updatesector(ps[p].pos.x, ps[p].pos.y, &k);
						if ((k == nullptr && ud.clipping == 0) || (k == s->sector() && ps[p].cursector() != s->sector()))
						{
							ps[p].pos.x = s->x;
							ps[p].pos.y = s->y;
							ps[p].setCursector(s->sector());

							setsprite(ps[p].GetActor(), s->pos);
							quickkill(&ps[p]);
						}
					}
				}
		for (int p = connecthead; p >= 0; p = connectpoint2[p])
		{
			auto psp = ps[p].GetActor();
			if (psp->s->sectnum == s->sectnum)
			{
				ps[p].pos.x += l;
				ps[p].pos.y += x;

				if (numplayers > 1)
				{
					ps[p].oposx = ps[p].pos.x;
					ps[p].oposy = ps[p].pos.y;
				}

				ps[p].bobposx += l;
				ps[p].bobposy += x;
			}

			if (po[p].os == s->sector())
			{
				po[p].ox += l;
				po[p].oy += x;
			}
		}

		DukeSectIterator its(s->sectnum);
		while (auto a2 = its.Next())
		{
			auto spa2 = a2->s;
			if (spa2->picnum != SECTOREFFECTOR && spa2->picnum != LOCATORS)
			{
				spa2->x += l;
				spa2->y += x;

				if (numplayers > 1)
				{
					spa2->backupvec2();
				}
			}
		}

		ms(actor);
		setsprite(actor, s->pos);

		if ((sc->floorz - sc->ceilingz) < (108 << 8))
		{
			if (ud.clipping == 0)
				for (int p = connecthead; p >= 0; p = connectpoint2[p])
					if (ps[p].GetActor()->s->extra > 0)
					{
						auto k = ps[p].cursector();
						updatesector(ps[p].pos.x, ps[p].pos.y, &k);
						if ((k == nullptr && ud.clipping == 0) || (k == s->sector() && ps[p].cursector() != s->sector()))
						{
							ps[p].pos.x = s->x;
							ps[p].pos.y = s->y;

							ps[p].oposx = ps[p].pos.x;
							ps[p].oposy = ps[p].pos.y;

							ps[p].setCursector(s->sector());

							setsprite(ps[p].GetActor(), s->pos);
							quickkill(&ps[p]);
						}
					}

			if (Owner)
			{
				DukeSectIterator it(Owner->sector());
				while (auto a2 = it.Next())
				{
					if (a2->s->statnum == 1 && badguy(a2) && a2->s->picnum != SECTOREFFECTOR && a2->s->picnum != LOCATORS)
					{
						//					if(a2->s->sector != s->sector)
						{
							int k = a2->s->sectnum;
							updatesector(a2->s->x, a2->s->y, &k);
							if (a2->s->extra >= 0 && k == s->sectnum)
							{
								gutsdir(a2, JIBS6, 24, myconnectindex);
								S_PlayActorSound(SQUISHED, a2);
								deletesprite(a2);
						}
					}
				}
			}
		}
	}
	}
}

//---------------------------------------------------------------------------
//
// 
//
//---------------------------------------------------------------------------

void handle_se02(DDukeActor* actor)
{
	auto const s = actor->s;
	int* t = &actor->temp_data[0];
	auto sc = actor->sector();
	int sh = s->hitag;

	if (t[4] > 0 && t[0] == 0)
	{
		if (t[4] < sh)
			t[4]++;
		else t[0] = 1;
	}

	if (t[0] > 0)
	{
		t[0]++;

		s->xvel = 3;

		if (t[0] > 96)
		{
			t[0] = -1; //Stop the quake
			t[4] = -1;
			deletesprite(actor);
			return;
		}
		else
		{
			if ((t[0] & 31) == 8)
			{
				earthquaketime = 48;
				S_PlayActorSound(EARTHQUAKE, ps[screenpeek].GetActor());
			}

			if (abs(sc->floorheinum - t[5]) < 8)
				sc->floorheinum = t[5];
			else sc->floorheinum += (Sgn(t[5] - sc->floorheinum) << 4);
		}

		int m = MulScale(s->xvel, bcos(s->ang), 14);
		int x = MulScale(s->xvel, bsin(s->ang), 14);


		for (int p = connecthead; p >= 0; p = connectpoint2[p])
			if (ps[p].cursector() == s->sector() && ps[p].on_ground)
			{
				ps[p].pos.x += m;
				ps[p].pos.y += x;

				ps[p].bobposx += m;
				ps[p].bobposy += x;
			}

		DukeSectIterator it(actor->sector());
		while (auto a2 = it.Next())
		{
			auto sj = a2->s;
			if (sj->picnum != SECTOREFFECTOR)
			{
				sj->x += m;
				sj->y += x;
				setsprite(a2, sj->pos);
			}
		}
		ms(actor);
		setsprite(actor, s->pos);
	}
}

//---------------------------------------------------------------------------
//
// 
//
//---------------------------------------------------------------------------

void handle_se03(DDukeActor *actor)
{
	auto s = actor->s;
	int* t = &actor->temp_data[0];
	auto sc = actor->sector();
	int sh = s->hitag;

	if (t[4] == 0) return;
	int x;
		
	findplayer(actor, &x);

	int palvals = actor->palvals;

	//	if(t[5] > 0) { t[5]--; break; }

	if ((global_random / (sh + 1) & 31) < 4 && !t[2])
	{
		//	   t[5] = 4+(global_random&7);
		sc->ceilingpal = palvals >> 8;
		sc->floorpal = palvals & 0xff;
		t[0] = s->shade + (global_random & 15);
	}
	else
	{
		//	   t[5] = 4+(global_random&3);
		sc->ceilingpal = s->pal;
		sc->floorpal = s->pal;
		t[0] = t[3];
	}

	sc->ceilingshade = t[0];
	sc->floorshade = t[0];

	for(auto& wal : wallsofsector(sc))
	{
		if (wal.hitag != 1)
		{
			wal.shade = t[0];
			if ((wal.cstat & 2) && wal.twoSided())
			{
				wal.nextWall()->shade = wal.shade;
			}
		}
	}
}

//---------------------------------------------------------------------------
//
// 
//
//---------------------------------------------------------------------------

void handle_se04(DDukeActor *actor)
{
	auto s = actor->s;
	int* t = &actor->temp_data[0];
	auto sc = actor->sector();
	int sh = s->hitag;
	int j;

	int palvals = actor->palvals;

	if ((global_random / (sh + 1) & 31) < 4)
	{
		t[1] = s->shade + (global_random & 15);//Got really bright
		t[0] = s->shade + (global_random & 15);
		sc->ceilingpal = palvals >> 8;
		sc->floorpal = palvals & 0xff;
		j = 1;
	}
	else
	{
		t[1] = t[2];
		t[0] = t[3];

		sc->ceilingpal = s->pal;
		sc->floorpal = s->pal;

		j = 0;
	}

	sc->floorshade = t[1];
	sc->ceilingshade = t[1];

	for (auto& wal : wallsofsector(sc))
	{
		if (j) wal.pal = (palvals & 0xff);
		else wal.pal = s->pal;

		if (wal.hitag != 1)
		{
			wal.shade = t[0];
			if ((wal.cstat & 2) && wal.twoSided())
				wal.nextWall()->shade = wal.shade;
		}
	}

	DukeSectIterator it(actor->sector());
	while (auto a2 = it.Next())
	{
		auto sj = a2->s;
		if (sj->cstat & 16)
		{
			if (sc->ceilingstat & 1)
				sj->shade = sc->ceilingshade;
			else sj->shade = sc->floorshade;
		}
	}

	if (t[4])
		deletesprite(actor);

}

//---------------------------------------------------------------------------
//
// 
//
//---------------------------------------------------------------------------

void handle_se05(DDukeActor* actor, int FIRELASER)
{
	auto s = actor->s;
	int* t = &actor->temp_data[0];
	auto sc = actor->sector();
	int j, l, m;

	int x, p = findplayer(actor, &x);
	if (x < 8192)
	{
		j = s->ang;
		s->ang = getangle(s->x - ps[p].pos.x, s->y - ps[p].pos.y);
		fi.shoot(actor, FIRELASER);
		s->ang = j;
	}

	auto Owner = actor->GetOwner();
	if (Owner == nullptr) //Start search
	{
		t[4] = 0;
		l = 0x7fffffff;
		while (1) //Find the shortest dist
		{
			auto NewOwner = LocateTheLocator(t[4], nullptr);
			if (NewOwner == nullptr) break;

			m = ldist(ps[p].GetActor(), NewOwner);

			if (l > m)
			{
				Owner = NewOwner;
				l = m;
			}

			t[4]++;
		}

		actor->SetOwner(Owner);
		if (!Owner) return; // Undefined case - was not checked.
		s->zvel = Sgn(Owner->s->z - s->z) << 4;
	}

	if (ldist(Owner, actor) < 1024)
	{
		auto ta = s->ang;
		s->ang = getangle(ps[p].pos.x - s->x, ps[p].pos.y - s->y);
		s->ang = ta;
		actor->SetOwner(nullptr);
		return;

	}
	else s->xvel = 256;

	x = getangle(Owner->s->x - s->x, Owner->s->y - s->y);
	int q = getincangle(s->ang, x) >> 3;
	s->ang += q;

	if (rnd(32))
	{
		t[2] += q;
		sc->ceilingshade = 127;
	}
	else
	{
		t[2] +=
			getincangle(t[2] + 512, getangle(ps[p].pos.x - s->x, ps[p].pos.y - s->y)) >> 2;
		sc->ceilingshade = 0;
	}
	j = fi.ifhitbyweapon(actor);
	if (j >= 0)
	{
		t[3]++;
		if (t[3] == 5)
		{
			s->zvel += 1024;
			FTA(7, &ps[myconnectindex]);
		}
	}

	s->z += s->zvel;
	sc->ceilingz += s->zvel;
	actor->temp_sect->ceilingz += s->zvel;
	ms(actor);
	setsprite(actor, s->pos);
}

//---------------------------------------------------------------------------
//
// 
//
//---------------------------------------------------------------------------

void handle_se08(DDukeActor *actor, bool checkhitag1)
{
	// work only if its moving
	auto s = actor->s;
	int* t = &actor->temp_data[0];
	auto sc = actor->sector();
	int st = s->lotag;
	int sh = s->hitag;

	int x, j = -1;

	if (actor->temp_data[4])
	{
		actor->temp_data[4]++;
		if (actor->temp_data[4] > 8)
		{
			deletesprite(actor);
			return;
		}
		j = 1;
	}
	else j = getanimationgoal(anim_ceilingz, s->sector());

	if (j >= 0)
	{
		int sn;

		if ((sc->lotag & 0x8000) || actor->temp_data[4])
			x = -t[3];
		else
			x = t[3];

		if (st == 9) x = -x;

		DukeStatIterator it(STAT_EFFECTOR);
		while (auto ac = it.Next())
		{
			if (((ac->s->lotag) == st) && (ac->s->hitag) == sh)
			{
				sn = ac->s->sectnum;
				auto sect = ac->sector();
				int m = ac->s->shade;

				for (auto& wal : wallsofsector(sect))
				{
					if (wal.hitag != 1)
					{
						wal.shade += x;

						if (wal.shade < m)
							wal.shade = m;
						else if (wal.shade > ac->temp_data[2])
							wal.shade = ac->temp_data[2];

						if (wal.twoSided())
							if (wal.nextWall()->hitag != 1)
								wal.nextWall()->shade = wal.shade;
					}
				}

				sect->floorshade += x;
				sect->ceilingshade += x;

				if (sect->floorshade < m)
					sect->floorshade = m;
				else if (sect->floorshade > ac->temp_data[0])
					sect->floorshade = ac->temp_data[0];

				if (sect->ceilingshade < m)
					sect->ceilingshade = m;
				else if (sect->ceilingshade > ac->temp_data[1])
					sect->ceilingshade = ac->temp_data[1];

				if (checkhitag1 && sect->hitag == 1)
					sect->ceilingshade = ac->temp_data[1];

			}
		}
	}
}

//---------------------------------------------------------------------------
//
// 
//
//---------------------------------------------------------------------------

void handle_se10(DDukeActor* actor, const int* specialtags)
{
	auto s = actor->s;
	int* t = &actor->temp_data[0];
	auto sc = actor->sector();
	int sh = s->hitag;

	if ((sc->lotag & 0xff) == 27 || (sc->floorz > sc->ceilingz && (sc->lotag & 0xff) != 23) || sc->lotag == 32791 - 65536)
	{
		int j = 1;

		if ((sc->lotag & 0xff) != 27)
			for (int p = connecthead; p >= 0; p = connectpoint2[p])
				if (sc->lotag != 30 && sc->lotag != 31 && sc->lotag != 0)
					if (s->sectnum == ps[p].GetActor()->s->sectnum)
						j = 0;

		if (j == 1)
		{
			if (t[0] > sh)
			{
				if (specialtags) for (int i = 0; specialtags[i]; i++)
				{
					if (s->sector()->lotag == specialtags[i] && getanimationgoal(anim_ceilingz, s->sector()) >= 0)
					{
						return;
					}
				}
				fi.activatebysector(s->sector(), actor);
				t[0] = 0;
			}
			else t[0]++;
		}
	}
	else t[0] = 0;
}

//---------------------------------------------------------------------------
//
// 
//
//---------------------------------------------------------------------------

void handle_se11(DDukeActor *actor)
{
	auto s = actor->s;
	int* t = &actor->temp_data[0];
	auto sc = actor->sector();
	if (t[5] > 0)
	{
		t[5]--;
		return;
	}

	if (t[4])
	{
		for(auto& wal : wallsofsector(sc))
		{
			DukeStatIterator it(STAT_ACTOR);
			while (auto ac = it.Next())
			{
				auto sk = ac->s;
				if (sk->extra > 0 && badguy(ac) && clipinsidebox(sk->x, sk->y, wallnum(&wal), 256) == 1)
					return;
			}
		}

		int k = (s->yvel >> 3) * t[3];
		t[2] += k;
		t[4] += k;
		ms(actor);
		setsprite(actor, s->pos);

		for(auto& wal : wallsofsector(sc))
		{
			DukeStatIterator it(STAT_PLAYER);
			while (auto ac = it.Next())
			{
				auto sk = ac->s;
				if (ac->GetOwner() && clipinsidebox(sk->x, sk->y, wallnum(&wal), 144) == 1)
				{
					t[5] = 8; // Delay
					t[2] -= k;
					t[4] -= k;
					ms(actor);
					setsprite(actor, s->pos);
					return;
				}
			}
		}

		if (t[4] <= -511 || t[4] >= 512)
		{
			t[4] = 0;
			t[2] &= 0xffffff00;
			ms(actor);
			setsprite(actor, s->pos);
		}
	}
}

//---------------------------------------------------------------------------
//
// 
//
//---------------------------------------------------------------------------

void handle_se12(DDukeActor *actor, int planeonly)
{
	auto s = actor->s;
	int* t = &actor->temp_data[0];
	auto sc = actor->sector();
	if (t[0] == 3 || t[3] == 1) //Lights going off
	{
		sc->floorpal = 0;
		sc->ceilingpal = 0;

		for (auto& wal : wallsofsector(sc))
		{
			if (wal.hitag != 1)
			{
				wal.shade = t[1];
				wal.pal = 0;
			}
		}
		sc->floorshade = t[1];
		sc->ceilingshade = t[2];
		t[0] = 0;

		DukeSectIterator it(sc);
		while (auto a2 = it.Next())
		{
			if (a2->s->cstat & 16)
			{
				if (sc->ceilingstat & 1)
					a2->s->shade = sc->ceilingshade;
				else a2->s->shade = sc->floorshade;
			}
		}

		if (t[3] == 1)
		{
			deletesprite(actor);
			return;
		}
	}
	if (t[0] == 1) //Lights flickering on
	{
		// planeonly 1 is RRRA SE47, planeonly 2 is SE48
		int compshade = planeonly == 2 ? sc->ceilingshade : sc->floorshade;
		if (compshade > s->shade)
		{
			if (planeonly != 2) sc->floorpal = s->pal;
			if (planeonly != 1) sc->ceilingpal = s->pal;

			if (planeonly != 2) sc->floorshade -= 2;
			if (planeonly != 1) sc->ceilingshade -= 2;

			for (auto& wal : wallsofsector(sc))
			{
				if (wal.hitag != 1)
				{
					wal.pal = s->pal;
					wal.shade -= 2;
				}
			}
		}
		else t[0] = 2;

		DukeSectIterator it(actor->sector());
		while (auto a2 = it.Next())
		{
			if (a2->s->cstat & 16)
			{
				if (sc->ceilingstat & 1)
					a2->s->shade = sc->ceilingshade;
				else a2->s->shade = sc->floorshade;
			}
		}
	}
}

//---------------------------------------------------------------------------
//
// 
//
//---------------------------------------------------------------------------

void handle_se13(DDukeActor* actor)
{
	auto s = actor->s;
	int* t = &actor->temp_data[0];
	auto sc = actor->sector();
	if (t[2])
	{
		int j = (s->yvel << 5) | 1;

		if (s->ang == 512)
		{
			if (actor->spriteextra)
			{
				if (abs(t[0] - sc->ceilingz) >= j)
					sc->ceilingz += Sgn(t[0] - sc->ceilingz) * j;
				else sc->ceilingz = t[0];
			}
			else
			{
				if (abs(t[1] - sc->floorz) >= j)
					sc->floorz += Sgn(t[1] - sc->floorz) * j;
				else sc->floorz = t[1];
			}
		}
		else
		{
			if (abs(t[1] - sc->floorz) >= j)
				sc->floorz += Sgn(t[1] - sc->floorz) * j;
			else sc->floorz = t[1];
			if (abs(t[0] - sc->ceilingz) >= j)
				sc->ceilingz += Sgn(t[0] - sc->ceilingz) * j;
			sc->ceilingz = t[0];
		}

		if (t[3] == 1)
		{
			//Change the shades

			t[3]++;
			sc->ceilingstat ^= 1;

			if (s->ang == 512)
			{
				for (auto& wal : wallsofsector(sc))
					wal.shade = s->shade;

				sc->floorshade = s->shade;

				if (ps[0].one_parallax_sectnum != nullptr)
				{
					sc->ceilingpicnum = ps[0].one_parallax_sectnum->ceilingpicnum;
					sc->ceilingshade = ps[0].one_parallax_sectnum->ceilingshade;
				}
			}
		}
		t[2]++;
		if (t[2] > 256)
		{
			deletesprite(actor);
			return;
		}
	}


	if (t[2] == 4 && s->ang != 512)
		for (int x = 0; x < 7; x++) RANDOMSCRAP(actor);
}

//---------------------------------------------------------------------------
//
// 
//
//---------------------------------------------------------------------------

void handle_se15(DDukeActor* actor)
{
	auto s = actor->s;
	int* t = &actor->temp_data[0];
	if (t[4])
	{
		s->xvel = 16;

		if (t[4] == 1) //Opening
		{
			if (t[3] >= (s->yvel >> 3))
			{
				t[4] = 0; //Turn off the sliders
				callsound(s->sector(), actor);
				return;
			}
			t[3]++;
		}
		else if (t[4] == 2)
		{
			if (t[3] < 1)
			{
				t[4] = 0;
				callsound(s->sector(), actor);
				return;
			}
			t[3]--;
		}

		ms(actor);
		setsprite(actor, s->pos);
	}
}

//---------------------------------------------------------------------------
//
// 
//
//---------------------------------------------------------------------------

void handle_se16(DDukeActor* actor, int REACTOR, int REACTOR2)
{
	auto s = actor->s;
	int* t = &actor->temp_data[0];
	auto sc = actor->sector();

	t[2] += 32;
	if (sc->floorz < sc->ceilingz) s->shade = 0;

	else if (sc->ceilingz < t[3])
	{

		//The following code check to see if
		//there is any other sprites in the sector.
		//If there isn't, then kill this sectoreffector
		//itself.....

		DukeSectIterator it(actor->sector());
		DDukeActor* a2;
		while ((a2 = it.Next()))
		{
			if (a2->s->picnum == REACTOR || a2->s->picnum == REACTOR2)
				return;
		}
		if (a2 == nullptr)
		{
			deletesprite(actor);
			return;
		}
		else s->shade = 1;
	}

	if (s->shade) sc->ceilingz += 1024;
	else sc->ceilingz -= 512;

	ms(actor);
	setsprite(actor, s->pos);
}

//---------------------------------------------------------------------------
//
// 
//
//---------------------------------------------------------------------------

void handle_se17(DDukeActor* actor)
{
	auto s = actor->s;
	int* t = &actor->temp_data[0];
	auto sc = actor->sector();
	int sh = s->hitag;

	int q = t[0] * (s->yvel << 2);

	sc->ceilingz += q;
	sc->floorz += q;

	DukeSectIterator it(actor->sector());
	while (auto act1 = it.Next())
	{
		if (act1->s->statnum == STAT_PLAYER && act1->GetOwner())
		{
			int p = act1->s->yvel;
			if (numplayers < 2) ps[p].oposz = ps[p].pos.z;
			ps[p].pos.z += q;
			ps[p].truefz += q;
			ps[p].truecz += q;
			if (numplayers > 1)	ps[p].oposz = ps[p].pos.z;
		}
		if (act1->s->statnum != STAT_EFFECTOR)
		{
			act1->s->backupz();
			act1->s->z += q;
		}

		act1->floorz = sc->floorz;
		act1->ceilingz = sc->ceilingz;
	}

	if (t[0]) //If in motion
	{
		if (abs(sc->floorz - t[2]) <= s->yvel)
		{
			activatewarpelevators(actor, 0);
			return;
		}

		if (t[0] == -1)
		{
			if (sc->floorz > t[3])
				return;
		}
		else if (sc->ceilingz < t[4]) return;

		if (t[1] == 0) return;
		t[1] = 0;

		DDukeActor* act2;
		DukeStatIterator it(STAT_EFFECTOR);
		while ((act2 = it.Next()))
		{
			if (actor != act2 && (act2->s->lotag) == 17)
				if ((sc->hitag - t[0]) == (act2->sector()->hitag) && sh == (act2->s->hitag))
					break;
		}

		if (act2 == nullptr) return;
		auto spr2 = act2->s;

		DukeSectIterator its(actor->sector());
		while (auto act3 = its.Next())
		{
			auto spr3 = act3->s;
			if (spr3->statnum == STAT_PLAYER && act3->GetOwner())
			{
				int p = spr3->yvel;

				ps[p].pos.x += spr2->x - s->x;
				ps[p].pos.y += spr2->y - s->y;
				ps[p].pos.z = spr2->sector()->floorz - (sc->floorz - ps[p].pos.z);

				act3->floorz = spr2->sector()->floorz;
				act3->ceilingz = spr2->sector()->ceilingz;

				ps[p].bobposx = ps[p].oposx = ps[p].pos.x;
				ps[p].bobposy = ps[p].oposy = ps[p].pos.y;
				ps[p].oposz = ps[p].pos.z;

				ps[p].truefz = act3->floorz;
				ps[p].truecz = act3->ceilingz;
				ps[p].bobcounter = 0;

				changeactorsect(act3, spr2->sectnum);
				ps[p].setCursector(spr2->sector());
			}
			else if (spr3->statnum != STAT_EFFECTOR)
			{
				spr3->x += spr2->x - s->x;
				spr3->y += spr2->y - s->y;
				spr3->z = spr2->sector()->floorz - (sc->floorz - spr3->z);

				spr3->backupz();

				changeactorsect(act3, spr2->sectnum);
				setsprite(act3, spr3->pos);

				act3->floorz = spr2->sector()->floorz;
				act3->ceilingz = spr2->sector()->ceilingz;

			}
		}
	}
}

//---------------------------------------------------------------------------
//
// 
//
//---------------------------------------------------------------------------

void handle_se18(DDukeActor *actor, bool morecheck)
{
	int* t = &actor->temp_data[0];
	auto sc = actor->sector();

	if (t[0])
	{
		if (actor->s->pal)
		{
			if (actor->s->ang == 512)
			{
				sc->ceilingz -= sc->extra;
				if (sc->ceilingz <= t[1])
				{
					sc->ceilingz = t[1];
					deletesprite(actor);
					return;
				}
			}
			else
			{
				sc->floorz += sc->extra;
				if (morecheck)
				{
					DukeSectIterator it(actor->sector());
					while (auto a2 = it.Next())
					{
						if (a2->s->picnum == TILE_APLAYER && a2->GetOwner())
							if (ps[a2->PlayerIndex()].on_ground == 1) ps[a2->PlayerIndex()].pos.z += sc->extra;
						if (a2->s->zvel == 0 && a2->s->statnum != STAT_EFFECTOR && a2->s->statnum != STAT_PROJECTILE)
						{
							a2->s->z += sc->extra;
							a2->floorz = sc->floorz;
						}
					}
				}
				if (sc->floorz >= t[1])
				{
					sc->floorz = t[1];
					deletesprite(actor);
					return;
				}
			}
		}
		else
		{
			if (actor->s->ang == 512)
			{
				sc->ceilingz += sc->extra;
				if (sc->ceilingz >= actor->s->z)
				{
					sc->ceilingz = actor->s->z;
					deletesprite(actor);
					return;
				}
			}
			else
			{
				sc->floorz -= sc->extra;
				if (morecheck)
				{
					DukeSectIterator it(actor->sector());
					while (auto a2 = it.Next())
					{
						if (a2->s->picnum == TILE_APLAYER && a2->GetOwner())
							if (ps[a2->PlayerIndex()].on_ground == 1) ps[a2->PlayerIndex()].pos.z -= sc->extra;
						if (a2->s->zvel == 0 && a2->s->statnum != STAT_EFFECTOR && a2->s->statnum != STAT_PROJECTILE)
						{
							a2->s->z -= sc->extra;
							a2->floorz = sc->floorz;
						}
					}
				}
				if (sc->floorz <= actor->s->z)
				{
					sc->floorz = actor->s->z;
					deletesprite(actor);
					return;
				}
			}
		}

		t[2]++;
		if (t[2] >= actor->s->hitag)
		{
			t[2] = 0;
			t[0] = 0;
		}
	}
}

//---------------------------------------------------------------------------
//
// 
//
//---------------------------------------------------------------------------

void handle_se19(DDukeActor *actor, int BIGFORCE)
{
	int* t = &actor->temp_data[0];
	auto sc = actor->sector();
	int sh = actor->s->hitag;

	if (t[0])
	{
		if (t[0] == 1)
		{
			t[0]++;
			for (auto& wal : wallsofsector(sc))
			{
				if (wal.overpicnum == BIGFORCE)
				{
					wal.cstat &= (128 + 32 + 8 + 4 + 2);
					wal.overpicnum = 0;
					auto nextwal = wal.nextWall();
					if (nextwal != nullptr)
					{
						nextwal->overpicnum = 0;
						nextwal->cstat &= (128 + 32 + 8 + 4 + 2);
					}
				}
			}
		}

		if (sc->ceilingz < sc->floorz)
			sc->ceilingz += actor->s->yvel;
		else
		{
			sc->ceilingz = sc->floorz;

			DukeStatIterator it(STAT_EFFECTOR);
			while (auto a2 = it.Next())
			{
				auto a2Owner = a2->GetOwner();
				if (a2->s->lotag == 0 && a2->s->hitag == sh && a2Owner)
				{
					auto sectp = a2Owner->sector(); 
					a2->sector()->floorpal = a2->sector()->ceilingpal =	sectp->floorpal;
					a2->sector()->floorshade = a2->sector()->ceilingshade = sectp->floorshade;
					a2Owner->temp_data[0] = 2;
				}
			}
			deletesprite(actor);
			return;
		}
	}
	else //Not hit yet
	{
		auto hitter = fi.ifhitsectors(actor->s->sectnum);
		if (hitter)
		{
			FTA(8, &ps[myconnectindex]);

			DukeStatIterator it(STAT_EFFECTOR);
			while (auto ac = it.Next())
			{
				int x = ac->s->lotag & 0x7fff;
				switch (x)
				{
				case 0:
					if (ac->s->hitag == sh && ac->GetOwner())
					{
						auto sectp = ac->sector();
						sectp->floorshade = sectp->ceilingshade =	ac->GetOwner()->s->shade;
						sectp->floorpal = sectp->ceilingpal =	ac->GetOwner()->s->pal;
					}
					break;

				case 1:
				case 12:
					//case 18:
				case 19:

					if (sh == ac->s->hitag)
						if (ac->temp_data[0] == 0)
						{
							ac->temp_data[0] = 1; //Shut them all on
							ac->SetOwner(actor);
						}

					break;
				}
			}
		}
	}
}

//---------------------------------------------------------------------------
//
// 
//
//---------------------------------------------------------------------------

void handle_se20(DDukeActor* actor)
{
	auto s = actor->s;
	int* t = &actor->temp_data[0];
	auto sc = actor->sector();

	if (t[0] == 0) return;
	if (t[0] == 1) s->xvel = 8;
	else s->xvel = -8;

	if (s->xvel) //Moving
	{
		int x = MulScale(s->xvel, bcos(s->ang), 14);
		int l = MulScale(s->xvel, bsin(s->ang), 14);

		t[3] += s->xvel;

		s->x += x;
		s->y += l;

		if (t[3] <= 0 || (t[3] >> 6) >= (s->yvel >> 6))
		{
			s->x -= x;
			s->y -= l;
			t[0] = 0;
			callsound(s->sector(), actor);
			return;
		}

		DukeSectIterator it(actor->sector());
		while (auto a2 = it.Next())
		{
			if (a2->s->statnum != 3 && a2->s->zvel == 0)
			{
				a2->s->x += x;
				a2->s->y += l;
				setsprite(a2, a2->s->pos);
				if (a2->sector()->floorstat & 2)
					if (a2->s->statnum == 2)
						makeitfall(a2);
			}
		}

		auto& wal = actor->temp_walls;
		dragpoint(wal[0], wal[0]->x + x, wal[0]->y + l);
		dragpoint(wal[1], wal[1]->x + x, wal[1]->y + l);

		for (int p = connecthead; p >= 0; p = connectpoint2[p])
			if (ps[p].cursector() == s->sector() && ps[p].on_ground)
			{
				ps[p].pos.x += x;
				ps[p].pos.y += l;

				ps[p].oposx = ps[p].pos.x;
				ps[p].oposy = ps[p].pos.y;

				setsprite(ps[p].GetActor(), ps[p].pos.x, ps[p].pos.y, ps[p].pos.z + gs.playerheight);
			}

		sc->addfloorxpan(-x / 8.f);
		sc->addfloorypan(-l / 8.f);

		sc->addceilingxpan(-x / 8.f);
		sc->addceilingypan(-l / 8.f);
	}
}

//---------------------------------------------------------------------------
//
// 
//
//---------------------------------------------------------------------------

void handle_se21(DDukeActor* actor)
{
	auto s = actor->s;
	int* t = &actor->temp_data[0];
	auto sc = actor->sector();
	int* lp;

	if (t[0] == 0) return;

	if (s->ang == 1536)
		lp = &sc->ceilingz;
	else
		lp = &sc->floorz;

	if (t[0] == 1) //Decide if the s->sectnum should go up or down
	{
		s->zvel = Sgn(s->z - *lp) * (s->yvel << 4);
		t[0]++;
	}

	if (sc->extra == 0)
	{
		*lp += s->zvel;

		if (abs(*lp - s->z) < 1024)
		{
			*lp = s->z;
			deletesprite(actor);
		}
	}
	else sc->extra--;
}

//---------------------------------------------------------------------------
//
// 
//
//---------------------------------------------------------------------------

void handle_se22(DDukeActor* actor)
{
	int* t = &actor->temp_data[0];
	auto sc = actor->sector();
	if (t[1])
	{
		if (getanimationgoal(anim_ceilingz, actor->temp_sect) >= 0)
			sc->ceilingz += sc->extra * 9;
		else t[1] = 0;
	}
}

//---------------------------------------------------------------------------
//
// 
//
//---------------------------------------------------------------------------

void handle_se26(DDukeActor* actor)
{
	auto s = actor->s;
	int* t = &actor->temp_data[0];
	auto sc = actor->sector();
	int x, l;

	s->xvel = 32;
	l = MulScale(s->xvel, bcos(s->ang), 14);
	x = MulScale(s->xvel, bsin(s->ang), 14);

	s->shade++;
	if (s->shade > 7)
	{
		s->x = t[3];
		s->y = t[4];
		sc->floorz -= ((s->zvel * s->shade) - s->zvel);
		s->shade = 0;
	}
	else
		sc->floorz += s->zvel;

	DukeSectIterator it(actor->sector());
	while (auto a2 = it.Next())
	{
		if (a2->s->statnum != 3 && a2->s->statnum != 10)
		{
			a2->s->x += l;
			a2->s->y += x;
			a2->s->z += s->zvel;
			setsprite(a2, a2->s->pos);
		}
	}

	for (int p = connecthead; p >= 0; p = connectpoint2[p])
		if (ps[p].GetActor()->s->sectnum == s->sectnum && ps[p].on_ground)
		{
			ps[p].fric.x += l << 5;
			ps[p].fric.y += x << 5;
			ps[p].pos.z += s->zvel;
		}

	ms(actor);
	setsprite(actor, s->pos);
}

//---------------------------------------------------------------------------
//
// 
//
//---------------------------------------------------------------------------

void handle_se27(DDukeActor* actor)
{
	auto s = actor->s;
	int* t = &actor->temp_data[0];
	int sh = s->hitag;
	int x, p;

	if (ud.recstat == 0) return;

	actor->tempang = s->ang;

	p = findplayer(actor, &x);
	if (ps[p].GetActor()->s->extra > 0 && myconnectindex == screenpeek)
	{
		if (t[0] < 0)
		{
			ud.cameraactor = actor;
			t[0]++;
		}
		else if (ud.recstat == 2 && ps[p].newOwner == nullptr)
		{
			if (cansee(s->x, s->y, s->z, s->sector(), ps[p].pos.x, ps[p].pos.y, ps[p].pos.z, ps[p].cursector()))
			{
				if (x < sh)
				{
					ud.cameraactor = actor;
					t[0] = 999;
					s->ang += getincangle(s->ang, getangle(ps[p].pos.x - s->x, ps[p].pos.y - s->y)) >> 3;
					s->yvel = 100 + ((s->z - ps[p].pos.z) / 257);

				}
				else if (t[0] == 999)
				{
					if (ud.cameraactor == actor)
						t[0] = 0;
					else t[0] = -10;
					ud.cameraactor = actor;

				}
			}
			else
			{
				s->ang = getangle(ps[p].pos.x - s->x, ps[p].pos.y - s->y);

				if (t[0] == 999)
				{
					if (ud.cameraactor == actor)
						t[0] = 0;
					else t[0] = -20;
					ud.cameraactor = actor;
				}
			}
		}
	}
}

//---------------------------------------------------------------------------
//
// 
//
//---------------------------------------------------------------------------

void handle_se24(DDukeActor *actor, const int16_t *list1, const int16_t *list2, bool scroll, int TRIPBOMB, int LASERLINE, int CRANE, int shift)
{
	int* t = &actor->temp_data[0];

	auto testlist = [](const int16_t* list, int val) { for (int i = 0; list[i] > 0; i++) if (list[i] == val) return true; return false; };

	if (t[4]) return;

	int x = MulScale(actor->s->yvel, bcos(actor->s->ang), 18);
	int l = MulScale(actor->s->yvel, bsin(actor->s->ang), 18);

	DukeSectIterator it(actor->sector());
	while (auto a2 = it.Next())
	{
		auto s2 = a2->s;
		if (s2->zvel >= 0)
		{
			switch (s2->statnum)
			{
			case 5:
				if (testlist(list1, s2->picnum))
				{
					s2->xrepeat = s2->yrepeat = 0;
					continue;
				}
				if (s2->picnum == LASERLINE)
				{
					continue;
				}

				[[fallthrough]];
			case 6:
				if (s2->picnum == TRIPBOMB) break;
				[[fallthrough]];
			case 1:
			case 0:
				if (testlist(list2, s2->picnum) ||
					wallswitchcheck(a2))
					break;

				if (!(s2->picnum >= CRANE && s2->picnum <= (CRANE + 3)))
				{
					if (s2->z > (a2->floorz - (16 << 8)))
					{
						s2->x += x >> shift;
						s2->y += l >> shift;

						setsprite(a2, s2->pos);

						if (s2->sector()->floorstat & 2)
							if (s2->statnum == 2)
								makeitfall(a2);
					}
				}
				break;
			}
		}
	}

	for (auto p = connecthead; p >= 0; p = connectpoint2[p])
	{
		if (ps[p].cursector() == actor->s->sector() && ps[p].on_ground)
		{
			if (abs(ps[p].pos.z - ps[p].truefz) < gs.playerheight + (9 << 8))
			{
				ps[p].fric.x += x << 3;
				ps[p].fric.y += l << 3;
			}
		}
	}
	if (scroll) actor->sector()->addfloorxpan(actor->s->yvel / 128.f);
}

//---------------------------------------------------------------------------
//
// 
//
//---------------------------------------------------------------------------

void handle_se25(DDukeActor* actor, int t_index, int snd1, int snd2)
{
	int* t = &actor->temp_data[0];
	auto sec = actor->sector();

	if (sec->floorz <= sec->ceilingz)
		actor->s->shade = 0;
	else if (sec->ceilingz <= t[t_index])
		actor->s->shade = 1;

	if (actor->s->shade)
	{
		sec->ceilingz += actor->s->yvel << 4;
		if (sec->ceilingz > sec->floorz)
		{
			sec->ceilingz = sec->floorz;
			if (pistonsound && snd1 >= 0)
				S_PlayActorSound(snd1, actor);
		}
	}
	else
	{
		sec->ceilingz -= actor->s->yvel << 4;
		if (sec->ceilingz < t[t_index])
		{
			sec->ceilingz = t[t_index];
			if (pistonsound && snd2 >= 0)
				S_PlayActorSound(snd2, actor);
		}
	}
}

//---------------------------------------------------------------------------
//
// 
//
//---------------------------------------------------------------------------

void handle_se32(DDukeActor *actor)
{
	auto s = actor->s;
	int* t = &actor->temp_data[0];
	auto sc = actor->sector();

	if (t[0] == 1)
	{
		// Choose dir

		if (t[2] == 1) // Retract
		{
			if (s->ang != 1536)
			{
				if (abs(sc->ceilingz - s->z) < (s->yvel << 1))
				{
					sc->ceilingz = s->z;
					callsound(s->sector(), actor);
					t[2] = 0;
					t[0] = 0;
				}
				else sc->ceilingz += Sgn(s->z - sc->ceilingz) * s->yvel;
			}
			else
			{
				if (abs(sc->ceilingz - t[1]) < (s->yvel << 1))
				{
					sc->ceilingz = t[1];
					callsound(s->sector(), actor);
					t[2] = 0;
					t[0] = 0;
				}
				else sc->ceilingz += Sgn(t[1] - sc->ceilingz) * s->yvel;
			}
			return;
		}

		if ((s->ang & 2047) == 1536)
		{
			if (abs(sc->ceilingz - s->z) < (s->yvel << 1))
			{
				t[0] = 0;
				t[2] = !t[2];
				callsound(s->sector(), actor);
				sc->ceilingz = s->z;
			}
			else sc->ceilingz += Sgn(s->z - sc->ceilingz) * s->yvel;
		}
		else
		{
			if (abs(sc->ceilingz - t[1]) < (s->yvel << 1))
			{
				t[0] = 0;
				t[2] = !t[2];
				callsound(s->sector(), actor);
			}
			else sc->ceilingz -= Sgn(s->z - t[1]) * s->yvel;
		}
	}

}

//---------------------------------------------------------------------------
//
// 
//
//---------------------------------------------------------------------------

void handle_se35(DDukeActor *actor, int SMALLSMOKE, int EXPLOSION2)
{
	auto s = actor->s;
	int* t = &actor->temp_data[0];
	auto sc = actor->sector();

	if (sc->ceilingz > s->z)
		for (int j = 0; j < 8; j++)
		{
			s->ang += krand() & 511;
			auto spawned = spawn(actor, SMALLSMOKE);
			if (spawned)
			{
				spawned->s->xvel = 96 + (krand() & 127);
				ssp(spawned, CLIPMASK0);
				setsprite(spawned, spawned->s->pos);
				if (rnd(16))
					spawn(actor, EXPLOSION2);
			}
		}

	switch (t[0])
	{
	case 0:
		sc->ceilingz += s->yvel;
		if (sc->ceilingz > sc->floorz)
			sc->floorz = sc->ceilingz;
		if (sc->ceilingz > s->z + (32 << 8))
			t[0]++;
		break;
	case 1:
		sc->ceilingz -= (s->yvel << 2);
		if (sc->ceilingz < t[4])
		{
			sc->ceilingz = t[4];
			t[0] = 0;
		}
		break;
	}
}

//---------------------------------------------------------------------------
//
// 
//
//---------------------------------------------------------------------------

void handle_se128(DDukeActor *actor)
{
	int* t = &actor->temp_data[0];

	auto wal = actor->temp_walls[0]; 
	if (!wal) return; // E4L1 contains an uninitialized SE128 which would crash without this.

	//if (wal->cstat | 32) // this has always been bugged, the condition can never be false.
	{
		wal->cstat &= (255 - 32);
		wal->cstat |= 16;
		if (wal->twoSided())
		{
			wal->nextWall()->cstat &= (255 - 32);
			wal->nextWall()->cstat |= 16;
		}
	}
//	else return;

	wal->overpicnum++;
	auto nextwal = wal->nextWall();
	if (nextwal)
		nextwal->overpicnum++;

	if (t[0] < t[1]) t[0]++;
	else
	{
		wal->cstat &= (128 + 32 + 8 + 4 + 2);
		if (nextwal)
			nextwal->cstat &= (128 + 32 + 8 + 4 + 2);
		deletesprite(actor);
	}
}

//---------------------------------------------------------------------------
//
// 
//
//---------------------------------------------------------------------------

void handle_se130(DDukeActor *actor, int countmax, int EXPLOSION2)
{
	int* t = &actor->temp_data[0];
	auto sc = actor->sector();

	if (t[0] > countmax)
	{
		deletesprite(actor);
		return;
	}
	else t[0]++;

	int x = sc->floorz - sc->ceilingz;

	if (rnd(64))
	{
		auto k = spawn(actor, EXPLOSION2);
		if (k)
		{
			k->s->xrepeat = k->s->yrepeat = 2 + (krand() & 7);
			k->s->z = sc->floorz - (krand() % x);
			k->s->ang += 256 - (krand() % 511);
			k->s->xvel = krand() & 127;
			ssp(k, CLIPMASK0);
		}
	}
}

//---------------------------------------------------------------------------
//
// 
//
//---------------------------------------------------------------------------

void handle_se31(DDukeActor* actor, bool choosedir)
{
	auto s = actor->s;
	int* t = &actor->temp_data[0];
	auto sec = actor->sector();

	if (t[0] == 1)
	{
		// Choose dir

		if (choosedir && t[3] > 0)
		{
			t[3]--;
			return;
		}

		if (t[2] == 1) // Retract
		{
			if (s->ang != 1536)
			{
				if (abs(sec->floorz - s->z) < s->yvel)
				{
					sec->floorz = s->z;
					t[2] = 0;
					t[0] = 0;
					if (choosedir) t[3] = s->hitag;
					callsound(s->sector(), actor);
				}
				else
				{
					int l = Sgn(s->z - sec->floorz) * s->yvel;
					sec->floorz += l;

					DukeSectIterator it(actor->sector());
					while (auto a2 = it.Next())
					{
						if (a2->s->picnum == TILE_APLAYER && a2->GetOwner())
							if (ps[a2->PlayerIndex()].on_ground == 1)
								ps[a2->PlayerIndex()].pos.z += l;
						if (a2->s->zvel == 0 && a2->s->statnum != STAT_EFFECTOR && (!choosedir || a2->s->statnum != STAT_PROJECTILE))
						{
							a2->s->z += l;
							a2->floorz = sec->floorz;
						}
					}
				}
			}
			else
			{
				if (abs(sec->floorz - t[1]) < s->yvel)
				{
					sec->floorz = t[1];
					callsound(s->sector(), actor);
					t[2] = 0;
					t[0] = 0;
					if (choosedir) t[3] = s->hitag;
				}
				else
				{
					int l = Sgn(t[1] - sec->floorz) * s->yvel;
					sec->floorz += l;

					DukeSectIterator it(actor->sector());
					while (auto a2 = it.Next())
					{
						if (a2->s->picnum == TILE_APLAYER && a2->GetOwner())
							if (ps[a2->PlayerIndex()].on_ground == 1)
								ps[a2->PlayerIndex()].pos.z += l;
						if (a2->s->zvel == 0 && a2->s->statnum != STAT_EFFECTOR && (!choosedir || a2->s->statnum != STAT_PROJECTILE))
						{
							a2->s->z += l;
							a2->floorz = sec->floorz;
						}
					}
				}
			}
			return;
		}

		if ((s->ang & 2047) == 1536)
		{
			if (abs(s->z - sec->floorz) < s->yvel)
			{
				callsound(s->sector(), actor);
				t[0] = 0;
				t[2] = 1;
				if (choosedir) t[3] = s->hitag;
			}
			else
			{
				int l = Sgn(s->z - sec->floorz) * s->yvel;
				sec->floorz += l;

				DukeSectIterator it(actor->sector());
				while (auto a2 = it.Next())
				{
					if (a2->s->picnum == TILE_APLAYER && a2->GetOwner())
						if (ps[a2->PlayerIndex()].on_ground == 1)
							ps[a2->PlayerIndex()].pos.z += l;
					if (a2->s->zvel == 0 && a2->s->statnum != STAT_EFFECTOR && (!choosedir || a2->s->statnum != STAT_PROJECTILE))
					{
						a2->s->z += l;
						a2->floorz = sec->floorz;
					}
				}
			}
		}
		else
		{
			if (abs(sec->floorz - t[1]) < s->yvel)
			{
				t[0] = 0;
				callsound(s->sector(), actor);
				t[2] = 1;
				t[3] = s->hitag;
			}
			else
			{
				int l = Sgn(s->z - t[1]) * s->yvel;
				sec->floorz -= l;

				DukeSectIterator it(actor->sector());
				while (auto a2 = it.Next())
				{
					if (a2->s->picnum ==TILE_APLAYER && a2->GetOwner())
						if (ps[a2->PlayerIndex()].on_ground == 1)
							ps[a2->PlayerIndex()].pos.z -= l;
					if (a2->s->zvel == 0 && a2->s->statnum != STAT_EFFECTOR && (!choosedir || a2->s->statnum != STAT_PROJECTILE))
					{
						a2->s->z -= l;
						a2->floorz = sec->floorz;
					}
				}
			}
		}
	}
}

//---------------------------------------------------------------------------
//
// 
//
//---------------------------------------------------------------------------

void getglobalz(DDukeActor* actor)
{
	auto s = actor->s;
	int zr;
	Collision hz, lz;

	if( s->statnum == STAT_PLAYER || s->statnum == STAT_STANDABLE || s->statnum == STAT_ZOMBIEACTOR || s->statnum == STAT_ACTOR || s->statnum == STAT_PROJECTILE)
	{
		if(s->statnum == STAT_PROJECTILE)
			zr = 4;
		else zr = 127;

		auto cc = s->cstat2;
		s->cstat2 |= CSTAT2_SPRITE_NOFIND; // don't clip against self. getzrange cannot detect this because it only receives a coordinate.
		getzrange_ex(s->x, s->y, s->z - (FOURSLEIGHT), s->sectnum, &actor->ceilingz, hz, &actor->floorz, lz, zr, CLIPMASK0);
		s->cstat2 = cc;

		if( lz.type == kHitSprite && (lz.actor->s->cstat&48) == 0 )
		{
			if( badguy(lz.actor) && lz.actor->s->pal != 1)
			{
				if( s->statnum != STAT_PROJECTILE)
				{
					actor->aflags |= SFLAG_NOFLOORSHADOW; 
					//actor->dispicnum = -4; // No shadows on actors
					s->xvel = -256;
					ssp(actor, CLIPMASK0);
				}
			}
			else if(lz.actor->s->picnum == TILE_APLAYER && badguy(actor) )
			{
				actor->aflags |= SFLAG_NOFLOORSHADOW; 
				//actor->dispicnum = -4; // No shadows on actors
				s->xvel = -256;
				ssp(actor, CLIPMASK0);
			}
			else if(s->statnum == STAT_PROJECTILE && lz.actor->s->picnum == TILE_APLAYER && actor->GetOwner() == actor)
			{
				actor->ceilingz = s->sector()->ceilingz;
				actor->floorz	= s->sector()->floorz;
			}
		}
	}
	else
	{
		actor->ceilingz = s->sector()->ceilingz;
		actor->floorz	= s->sector()->floorz;
	}
}

//---------------------------------------------------------------------------
//
// 
//
//---------------------------------------------------------------------------

void makeitfall(DDukeActor* actor)
{
	auto s = actor->s;
	int c;

	if( fi.floorspace(s->sector()) )
		c = 0;
	else
	{
		if( fi.ceilingspace(s->sector()) || s->sector()->lotag == ST_2_UNDERWATER)
			c = gs.gravity/6;
		else c = gs.gravity;
	}
	
	if (isRRRA())
	{
		c = adjustfall(actor, c); // this accesses sprite indices and cannot be in shared code. Should be done better.
	}

	if ((s->statnum == STAT_ACTOR || s->statnum == STAT_PLAYER || s->statnum == STAT_ZOMBIEACTOR || s->statnum == STAT_STANDABLE))
	{
		Collision c;
		getzrange_ex(s->x, s->y, s->z - (FOURSLEIGHT), s->sectnum, &actor->ceilingz, c, &actor->floorz, c, 127, CLIPMASK0);
	}
	else
	{
		actor->ceilingz = s->sector()->ceilingz;
		actor->floorz	= s->sector()->floorz;
	}

	if( s->z < actor->floorz-(FOURSLEIGHT) )
	{
		if( s->sector()->lotag == 2 && s->zvel > 3122 )
			s->zvel = 3144;
		if(s->zvel < 6144)
			s->zvel += c;
		else s->zvel = 6144;
		s->z += s->zvel;
	}
	if( s->z >= actor->floorz-(FOURSLEIGHT) )
	{
		s->z = actor->floorz - FOURSLEIGHT;
		s->zvel = 0;
	}
}

//---------------------------------------------------------------------------
//
// 
//
//---------------------------------------------------------------------------

int dodge(DDukeActor* actor)
{
	auto s = actor->s;
	int bx, by, mx, my, bxvect, byvect, d;

	mx = s->x;
	my = s->y;

	DukeStatIterator it(STAT_PROJECTILE);
	while (auto ac = it.Next())
	{
		auto si = ac->s;
		if (ac->GetOwner() == ac || si->sectnum != s->sectnum)
			continue;

		bx = si->x - mx;
		by = si->y - my;
		bxvect = bcos(si->ang);
		byvect = bsin(si->ang);

		if (bcos(s->ang) * bx + bsin(s->ang) * by >= 0)
			if (bxvect * bx + byvect * by < 0)
			{
				d = bxvect * by - byvect * bx;
				if (abs(d) < 65536 * 64)
				{
					s->ang -= 512 + (krand() & 1024);
					return 1;
				}
			}
	}
	return 0;
}

//---------------------------------------------------------------------------
//
// 
//
//---------------------------------------------------------------------------

int furthestangle(DDukeActor *actor, int angs)
{
	auto s = actor->s;
	int j, furthest_angle = 0, angincs;
	int hx, hy, hz, d, greatestd;

	greatestd = -(1 << 30);
	angincs = 2048 / angs;

	if (s->picnum != TILE_APLAYER)
		if ((actor->temp_data[0] & 63) > 2) return(s->ang + 1024);

	for (j = s->ang; j < (2048 + s->ang); j += angincs)
	{
		hitscan(s->x, s->y, s->z - (8 << 8), s->sectnum, bcos(j), bsin(j), 0, nullptr, nullptr, nullptr, &hx, &hy, &hz, CLIPMASK1);

		d = abs(hx - s->x) + abs(hy - s->y);

		if (d > greatestd)
		{
			greatestd = d;
			furthest_angle = j;
		}
	}
	return (furthest_angle & 2047);
}

//---------------------------------------------------------------------------
//
// return value was changed to what its only caller really expects
//
//---------------------------------------------------------------------------

int furthestcanseepoint(DDukeActor *actor, DDukeActor* tosee, int* dax, int* day)
{
	auto s = actor->s;
	int j, angincs;
	int hx, hy, hz, d, da;//, d, cd, ca,tempx,tempy,cx,cy;
	DDukeActor* dd;
	sectortype* hitsect;

	if ((actor->temp_data[0] & 63)) return -1;

	if (ud.multimode < 2 && ud.player_skill < 3)
		angincs = 2048 / 2;
	else angincs = 2048 / (1 + (krand() & 1));

	auto ts = tosee->s;
	for (j = ts->ang; j < (2048 + ts->ang); j += (angincs - (krand() & 511)))
	{
		hitscan(ts->x, ts->y, ts->z - (16 << 8), ts->sectnum, bcos(j), bsin(j), 16384 - (krand() & 32767), 
			&hitsect, nullptr, &dd, &hx, &hy, &hz, CLIPMASK1);

		d = abs(hx - ts->x) + abs(hy - ts->y);
		da = abs(hx - s->x) + abs(hy - s->y);

		if (d < da && hitsect)
			if (cansee(hx, hy, hz, sectnum(hitsect), s->x, s->y, s->z - (16 << 8), s->sectnum))
			{
				*dax = hx;
				*day = hy;
				return 1;
			}
	}
	return 0;
}

//---------------------------------------------------------------------------
//
// 
//
//---------------------------------------------------------------------------

void alterang(int ang, DDukeActor* actor, int playernum)
{
	auto s = actor->s;
	int aang, angdif, goalang, j;
	int ticselapsed;
	int* t = actor->temp_data;

	auto moveptr = &ScriptCode[t[1]];

	ticselapsed = (t[0]) & 31;

	aang = s->ang;

	s->xvel += (*moveptr - s->xvel) / 5;
	if (s->zvel < 648) s->zvel += ((*(moveptr + 1) << 4) - s->zvel) / 5;

	if (isRRRA() && (ang & windang))
		s->ang = WindDir;
	else if (ang & seekplayer)
	{
		auto holoduke = !isRR()? ps[playernum].holoduke_on : nullptr;

		// NOTE: looks like 'Owner' is set to target sprite ID...

		if (holoduke && cansee(holoduke->s->x, holoduke->s->y, holoduke->s->z, holoduke->s->sectnum, s->x, s->y, s->z, s->sectnum))
			actor->SetOwner(holoduke);
		else actor->SetOwner(ps[playernum].GetActor());

		auto Owner = actor->GetOwner();
		if (Owner->s->picnum == TILE_APLAYER)
			goalang = getangle(actor->lastvx - s->x, actor->lastvy - s->y);
		else
			goalang = getangle(Owner->s->x - s->x, Owner->s->y - s->y);

		if (s->xvel && s->picnum != TILE_DRONE)
		{
			angdif = getincangle(aang, goalang);

			if (ticselapsed < 2)
			{
				if (abs(angdif) < 256)
				{
					j = 128 - (krand() & 256);
					s->ang += j;
					if (hits(actor) < 844)
						s->ang -= j;
				}
			}
			else if (ticselapsed > 18 && ticselapsed < 26) // choose
			{
				if (abs(angdif >> 2) < 128) s->ang = goalang;
				else s->ang += angdif >> 2;
			}
		}
		else s->ang = goalang;
	}

	if (ticselapsed < 1)
	{
		j = 2;
		if (ang & furthestdir)
		{
			goalang = furthestangle(actor, j);
			s->ang = goalang;
			actor->SetOwner(ps[playernum].GetActor());
		}

		if (ang & fleeenemy)
		{
			goalang = furthestangle(actor, j);
			s->ang = goalang; // += angdif; //  = getincangle(aang,goalang)>>1;
		}
	}
}

//---------------------------------------------------------------------------
//
// the indirections here are to keep this core function free of game references
//
//---------------------------------------------------------------------------

void fall_common(DDukeActor *actor, int playernum, int JIBS6, int DRONE, int BLOODPOOL, int SHOTSPARK1, int squished, int thud, int(*fallspecial)(DDukeActor*, int))
{
	auto s = actor->s;
	s->xoffset = 0;
	s->yoffset = 0;
	//			  if(!gotz)
	{
		int c;

		int sphit = fallspecial? fallspecial(actor, playernum) : 0;
		if (fi.floorspace(s->sector()))
			c = 0;
		else
		{
			if (fi.ceilingspace(s->sector()) || s->sector()->lotag == 2)
				c = gs.gravity / 6;
			else c = gs.gravity;
		}

		if (actor->cgg <= 0 || (s->sector()->floorstat & 2))
		{
			getglobalz(actor);
			actor->cgg = 6;
		}
		else actor->cgg--;

		if (s->z < (actor->floorz - FOURSLEIGHT))
		{
			s->zvel += c;
			s->z += s->zvel;

			if (s->zvel > 6144) s->zvel = 6144;
		}
		else
		{
			s->z = actor->floorz - FOURSLEIGHT;

			if (badguy(actor) || (s->picnum == TILE_APLAYER && actor->GetOwner()))
			{

				if (s->zvel > 3084 && s->extra <= 1)
				{
					if (s->pal != 1 && s->picnum != DRONE)
					{
						if (s->picnum == TILE_APLAYER && s->extra > 0)
							goto SKIPJIBS;
						if (sphit)
						{
							fi.guts(actor, JIBS6, 5, playernum);
							S_PlayActorSound(squished, actor);
						}
						else
						{
							fi.guts(actor, JIBS6, 15, playernum);
							S_PlayActorSound(squished, actor);
							spawn(actor, BLOODPOOL);
						}
					}

				SKIPJIBS:

					actor->picnum = SHOTSPARK1;
					actor->extra = 1;
					s->zvel = 0;
				}
				else if (s->zvel > 2048 && s->sector()->lotag != 1)
				{

					int j = s->sectnum;
					pushmove(&s->pos, &j, 128, (4 << 8), (4 << 8), CLIPMASK0);
					if (j != s->sectnum && validSectorIndex(j))
						changeactorsect(actor, j);

					S_PlayActorSound(thud, actor);
				}
			}
			if (s->sector()->lotag == 1)
				s->z += gs.actorinfo[s->picnum].falladjustz;
			else s->zvel = 0;
		}
	}
}

//---------------------------------------------------------------------------
//
// 
//
//---------------------------------------------------------------------------

DDukeActor *LocateTheLocator(int n, sectortype* sect)
{
	DukeStatIterator it(STAT_LOCATOR);
	while (auto ac = it.Next())
	{
		if ((sect == nullptr || sect == ac->s->sector()) && n == ac->s->lotag)
			return ac;
	}
	return nullptr;
}

//---------------------------------------------------------------------------
//
// 
//
//---------------------------------------------------------------------------

void recordoldspritepos()
{
	for (int statNum = 0; statNum < MAXSTATUS; statNum++)
	{
		DukeStatIterator it(statNum);
		while (auto ac = it.Next())
		{
			ac->s->backuploc();
		}
	}
}



END_DUKE_NS