ZSCRIPT.zc

version "4.1.3"

const MAXITERATIONS = 32676;

#include "zscript/PbWheel/parse.zsc"
#include "zscript/PbWheel/ev_core_special.zsc"
#include "zscript/PbWheel/ev_drawer_special.zsc"


Class PB_SpecialWheel_Mode
{
	string specialName;
	string specialAlias;
	TextureID specialIcon;
	Vector2 iconScale;
	int specialPriority;
	bool hidden;
	bool mergeDir;
}

class Demonpickup: CustomInventory
{
	Default
	{
		Height 26;
		-COUNTITEM
		+INVENTORY.ALWAYSPICKUP
		Inventory.PickupMessage "Lesser demon energy";
		Inventory.PickupSound "demonsoulpickup";
		renderstyle 'translucent';
		Scale 0.28;
		alpha 0.65;
	}
	States
	{
	Spawn:
		MDHP ABCDEFGH 3 bright A_Fadeout(0.001);
		Loop;
	
    Pickup:
       TNT1 A 0 A_GiveInventory("Demonpower",10);
       TNT1 A 0 A_GiveInventory("Armorshard", 1) ;
      //  TNT1 A 0 A_GiveInventory("Healthplus", 1) - too easy!
        Stop;
	}
}
class Demonpickup2: Demonpickup
{
	Default
	{
		renderstyle 'translucent';
		alpha 0.70;
		Scale 0.45;
		Inventory.PickupMessage "Greater demon energy";
	}
	States
	{
	Spawn:
		MDHP ABCDEFGH 2 bright A_Fadeout(0.001);
		Loop;

    Pickup:
        TNT1 A 0 A_GiveInventory("LargeDemonpower",30);
        TNT1 A 0 A_GiveInventory("Armorshard", 2);
        TNT1 A 0 A_GiveInventory("Healthplus", 2);
        Stop;
	}
}
#include "zscript/DeathFader.zc"
#include "zscript/PlayerPawn.zc"
#include "zscript/ZMoveMenu.ZMV"
#include "zscript/PBHitbox.zc"
#include "zscript/TiltPlus/TiltPlusPlus.zc"
#include "zscript/TiltPlus/TiltPlusPlusMenu.zc"
#include "zscript/Monsters/PBMonster.zc"
#include "zscript/Monsters/ZombieMen/ZombieMan.zc"
#include "zscript/PBPDA.zc"
#include "zscript/Monsters/ZombieMen/ZombieManDeath.zc"
#include "zscript/Gore/NashGore/NashGoreCommon.zc"
#include "zscript/Gore/NashGore/NashGoreStatics.zc"
#include "zscript/Gore/NashGore/NashGoreHandler.zc"
#include "zscript/Gore/NashGore/NashGoreBlood.zc"
#include "zscript/Gore/NashGore/NashGoreBloodPlane.zc"
#include "zscript/Gore/NashGore/NashGoreGibs.zc"
#include "zscript/Gore/NashGore/NashGoreCrushedGibs.zc"
#include "zscript/Gore/NashGore/NashGoreSquishyGibs.zc"
#include "zscript/Gore/NashGore/NashGoreIceChunk.zc"
#include "zscript/Gore/NashGore/NashGoreLiquidBlood.zc"
#include "zscript/Gore/NashGore/NashGoreWallBlood.zc"
#include "zscript/Gore/NashGore/NashGoreActor.zc"
#include "zscript/Gore/NashGore/NashGoreMenu.zc"
#include "zscript/Gore/PBBlood.zc"
#include "zscript/Gore/PBGore.zc"
#include "zscript/Gore/PBGoreEffects.zc"
#include "zscript/Decorations/PBDeadGeneric.zc"

//Monsters
#include "zscript/Monsters/PBMonster.zc"
#include "zscript/Monsters/ZombieMen/ZombieMan.zc"
#include "zscript/Monsters/ZombieMen/ZombieManDeath.zc"
#include "zscript/Monsters/ZombieMen/ZombieManHelmet.zc"
#include "zscript/Monsters/ZombieMen/ZombieManPistol.zc"
#include "zscript/Monsters/ZombieMen/ZombieManHelmetPistol.zc"
#include "zscript/Monsters/ZombieMen/ZombieManCarbine.zc"
#include "zscript/Monsters/ZombieMen/ZombieScientist.zc"
#include "zscript/Monsters/ZombieMen/ZombieScientistChainsaw.zc"
#include "zscript/Monsters/Sergeants/ZombieSergeant.zc"
#include "zscript/Monsters/Sergeants/ZombieSergeantHelmet.zc"
#include "zscript/Monsters/Sergeants/ZombieSergeantShield.zc"

//Effects
#include "zscript/Effects/Casings.txt"
// global constants
const STAT_NashGore_Gore = Thinker.STAT_USER + 1;
const STAT_PB_BULLETS = Thinker.STAT_USER_MAX - 1;

const C_TID	= 1000;	//Default camera tid
const  MAX_R	= 56+32;	//Maximum radius (or distance from the player)
const  ADJUST_R = 8;	//Amount to adjust the camera by
const  VIEW_HEIGHT = 61.0;	//The approximate hight of the player's view

class DoNotDoubleJump : Inventory {}
class BossBrainBase : Actor
{
	void RemoveCubes()
	{
		ThinkerIterator ti = ThinkerIterator.Create("Actor");
		Actor a;
		while (a = Actor(ti.Next()))
		{
			if (a is "SpawnShot" || a is "BossEye") a.Destroy();
			if (a.bISMONSTER && a.bCOUNTKILL) a.A_Die("Massacre");
		}
	}
}
class SpawnerBase : Actor
{
	void SpawnActor(class<Actor> spawnactor, bool HandleSpawnFlags = true)
	{
			Actor a = self;
			Actor r = a.Spawn(spawnactor,a.pos);
			r.spawnangle = a.spawnangle;
			r.angle = a.angle;
			r.pitch = a.pitch;
			r.roll = a.roll;
			r.spawnpoint = a.spawnpoint;
			r.special = a.special;
			r.args[0] = a.args[0];
			r.args[1] = a.args[1];
			r.args[2] = a.args[2];
			r.args[3] = a.args[3];
			r.args[4] = a.args[4];
			r.special1 = a.special1;
			r.special2 = a.special2;
			r.spawnflags = a.spawnflags&~MTF_SECRET;
			if (HandleSpawnFlags) r.HandleSpawnFlags();
			r.spawnflags = a.spawnflags;
			r.bCOUNTSECRET = a.spawnflags&MTF_SECRET;
			r.ChangeTid(a.tid);
			r.Vel = a.vel;
	}
}
extend class Demonpickup
{
	void SpawnActor(class<Actor> spawnactor, bool HandleSpawnFlags = true)
	{
			Actor a = self;
			Actor r = a.Spawn(spawnactor,a.pos);
			r.spawnangle = a.spawnangle;
			r.angle = a.angle;
			r.pitch = a.pitch;
			r.roll = a.roll;
			r.spawnpoint = a.spawnpoint;
			r.special = a.special;
			r.args[0] = a.args[0];
			r.args[1] = a.args[1];
			r.args[2] = a.args[2];
			r.args[3] = a.args[3];
			r.args[4] = a.args[4];
			r.special1 = a.special1;
			r.special2 = a.special2;
			r.spawnflags = a.spawnflags&~MTF_SECRET;
			if (HandleSpawnFlags) r.HandleSpawnFlags();
			r.spawnflags = a.spawnflags;
			r.bCOUNTSECRET = a.spawnflags&MTF_SECRET;
			r.ChangeTid(a.tid);
			r.Vel = a.vel;
	}
}
enum EPBWeaponFlags
{
	PBWEAP_KEEPYOFFSET = 1<<0, //Weapon must not move up/down when looking up/down.
	PBWEAP_ISPISTOLSILENCERSTATE = 1<<3, // Weapon is equipped with a silencer.
	PBWEAP_UNLOADED = 1<<4 // Weapon has been unloaded.
}
class InvisiblePuff : BulletPuff
{
	Default
	{
		-ALLOWPARTICLES
	}
}
class InvisiblePuffAlways : InvisiblePuff
{
	Default
	{
		+ALWAYSPUFF
		+THRUACTORS
		+ALLOWTHRUFLAGS
	}
}
class CameraRunner : Inventory
{
	static bool CheckForCamera(class<Actor> classname,int tidnum)
	{
		ActorIterator at = ActorIterator.Create(tidnum);
		Actor a = at.Next();
		if (a != NULL && a.GetClassName() == classname) return true;
		return false;
	}
	static Actor CheckForCameraActor(class<Actor> classname,int tidnum)
	{
		ActorIterator at = ActorIterator.Create(tidnum);
		Actor a = at.Next();
		if (a != NULL && a.GetClassName() == classname) return a;
		return null;
	}
	static void SetActorAngle(int tidnum, double angle)
	{
		ActorIterator at = ActorIterator.Create(tidnum);
		Actor a = at.Next();
		if (a != NULL) a.angle = angle;
	}
	static void SetActorPitch(int tidnum, double pitch)
	{
		ActorIterator at = ActorIterator.Create(tidnum);
		Actor a = at.Next();
		if (a != NULL) a.pitch = pitch;
	}
	static void SetActorRoll(int tidnum, double roll)
	{
		ActorIterator at = ActorIterator.Create(tidnum);
		Actor a = at.Next();
		if (a != NULL) a.roll = roll;
	}
	static bool, Actor ExtSpawn(class<Actor> classname,Vector3 pos,int tid,double angle)
	{
		Actor a = Spawn(classname,pos,ALLOW_REPLACE);
		if (a != NULL)
		{
			a.ChangeTid(tid);
			a.angle = angle;
			return true, a;
		}
		return false, null;
	}
	static bool SetActorPosition(int tidnum, Vector3 pos)
	{
		Actor a = CheckForCameraActor("ChaseCam2",tidnum);
		if (a != NULL)
		{
			a.SetOrigin(pos,true);
			if (a.pos == pos) return true;
		}
		return false;
	}
	void TerminateCamera()
	{
		owner.SetCamera(null);
		Actor a = CheckForCameraActor("ChaseCam2",C_TID + PlayerPawn(owner).PlayerNumber());
		if (a != NULL) a.Destroy();
	}
	static void WarpCamera(int tid, int plrnum = 1)
	{
		ActorIterator ai = ActorIterator.Create(tid);
		Actor a = ai.Next();
		if (a != NULL)
		{
			actor cameraactor;
			if ((cameraactor = ActorIterator.Create(6400 + plrnum,"WarpCamera").Next()) != NULL)
			{
				Players[plrnum].mo.SetCamera(cameraactor);
				cameraactor.Warp(a,flags: WARPF_INTERPOLATE | WARPF_COPYPITCH);
				cameraactor.SetOrigin(Players[plrnum].mo.vel + cameraactor.pos,true);
			}
		}
		else
		{
			players[consoleplayer].mo.SetCamera(null);
		}
	}
	Vector3, double, double, actor ReturnCamPos(Actor a)
	{
		Actor linepuff = a.LineAttack(a.angle - 180,128 + (a.radius*2),-a.pitch,0,'None',"InvisiblePuffAlways",LAF_NOINTERACT|LAF_NORANDOMPUFFZ,null,-(a.height/2) + a.player.viewheight);
		if (linepuff)
		{
			let vec3 = linepuff.pos + a.vel;
			let anglevalue = linepuff.angle;
			let pitchvalue = linepuff.pitch;
			linepuff.bINVISIBLE = true;
			//linepuff.Destroy();
			return vec3, anglevalue, pitchvalue,linepuff;
		}
		return a.pos, a.angle, a.pitch, null;
	}
	//ACS Prefab chasecam script ported to ZScript with changes by Cacodemon345.
	void RunCameraNew()
	{
		if (!owner.player || !owner) return; //Don't start camera if the owner isn't a player or is null.
		Double anglevalue;
		Double pitchvalue;
		Double actualpitch = owner.pitch;
		actor linepuff;
		Vector3 campos;
		int plrnum = PlayerPawn(owner).PlayerNumber();
		[campos,anglevalue, pitchvalue,linepuff] = ReturnCamPos(owner);
		if (!CheckForCamera("ChaseCam2",C_TID + plrnum))
		{
			Actor cameraactor;
			bool cameraspawned;
			[cameraspawned, cameraactor] = self.ExtSpawn ("ChaseCam2", campos, C_TID+plrnum, angle);
			if (CheckForCamera ("ChaseCam2", C_TID + plrnum))
			owner.SetCamera(cameraactor);
			else
			{
				Console.MidPrint ("INDEXFONT_DOOM","Camera script failed to initialize.");
				return;
			}
		}
		else
		{
			Actor cameraactor = CheckForCameraActor("ChaseCam2",C_TID + plrnum);
			cameraactor.SetOrigin(campos,true);
			//cameraactor.Warp(owner,0,0,0,0,WARPF_INTERPOLATE);
			self.SetActorAngle (C_TID + plrnum, anglevalue);
			self.SetActorPitch (C_TID + plrnum, actualpitch);
			self.SetActorRoll  (C_TID + plrnum, owner.roll);
		}
	}
	override void DoEffect()
	{
		let p = PlayerPawn(owner);
		if (p)
		{
			self.RunCameraNew();
		}
	}
	override void OnDestroy()
	{
		let p = PlayerPawn(owner);
		if (p)
		{
			self.TerminateCamera();
		}
		Super.OnDestroy();
	}
}
class TankBaseNotReal : Actor
{
	Actor warpto;
	int spritestate;
	Default
	{
		+THRUACTORS
		YScale 1.8;
		XScale 1.9;
		+NOTIMEFREEZE
		+NOBLOOD
		+NOBLOODDECALS
		+CLIENTSIDEONLY
		+FLOORCLIP
		+NOGRAVITY
		+FLOAT
		+NOBLOCKMAP
		+THRUSPECIES
		+MTHRUSPECIES
		Species "TankProj";
		Mass 99999;
		Radius 0;
		Height 0;
		Gravity 0;
	}
	States
	{
		Spawn:
			TNT1 A 0;
			TNK1 B 1
			{
				switch(spritestate)
				{
					default:
						break;
					case 1:
						self.SetStateLabel("Spawn1");
						break;
					case 2:
						self.SetStateLabel("Spawn2");
						break;
					case 3:
						self.SetStateLabel("Spawn3");
						break;
				}
			}
			TNT1 A 0 A_SPawnItemEx("TankWeakSpotBase", -65, 0, 2);
			Loop;
		Spawn1:
			TNT1 A 0;
			TNT1 A 0 A_Stop;
			TNT1 A 0 A_SPawnItemEx("TankWeakSpotBase", -65, 0, 2);
			TNK1 B 1;
			Goto Spawn;
		Spawn2:
			TNT1 A 0 A_SPawnItemEx("TankWeakSpotBase", -75, 0, 2);
			TNK1 D 1;
			Goto Spawn;
		Spawn3:
			TNT1 A 0 A_SPawnItemEx("TankWeakSpotBase", -75, 0, 2);
			TNK1 E 1;
			Goto Spawn;
	}
}


class LaserDeactivated : Inventory {}
class XDeathGibBase : Actor
{
	void A_PBGibMissile(class<Actor> missiletype, double spawnheight = 32, double spawnofs_xy = 0, double angle = 0, int flags = 0, double pitch = 0, int ptr = AAPTR_TARGET)
	{
		let a = A_SpawnProjectile(missiletype, spawnheight, spawnofs_xy, angle, flags | CMF_BADPITCH | CMF_SAVEPITCH, pitch, ptr);
		if (a)
		{
			a.VelFromAngle(vel.xy.Length() / 2, self.angle + frandom(-20, 20));
			a.vel.z += vel.z + 5;
		}
	}
	override void PostBeginPlay()
	{
		Super.PostBeginPlay();
		if (target)
		{
			vel = target.vel;
			A_FaceMovementDirection();
		}
	}
}
class PB_WeaponBase : DoomWeapon 
{
	Actor laseractor;
	Actor InvActor;
	Vector3 invactorpos;
	Statelabel UnloadedState;
	property UnloadedState: UnloadedState;
	string UnloaderToken;
	property UnloaderToken: UnloaderToken;
	int integer;
	string MidWeaponPickupMessage;
	property MidPickupMessage: MidWeaponPickupMessage;
	string lastGrenadeType;
	property lastGrenadeType: lastGrenadeType;
	Default
	{
		PB_WeaponBase.UnloaderToken "HasUnloaded";
	}
	override void AttachToOwner(Actor Other)
	{
		Super.AttachToOwner(other);
		let toucher = other;
		bool IsAlreadyPicked = false;
		if (toucher.FindInventory("PB_PDAWeaponContainer",true))
		{
			PB_PDAWeaponContainer pdaweapContainer = PB_PDAWeaponContainer(toucher.FindInventory("PB_PDAWeaponContainer",true));
			pdaweapContainer.CollectedWeapons.Push(self.GetClassName());
			EventHandler.SendNetworkEvent("Foundweapon:"..self.GetClassName());
		}
	}
	
	action string A_GetCurrentGrenadeType()
	{
		return invoker.lastGrenadeType;
	}
	
	action void A_SetCurrentGrenadeType(string type)
	{
		invoker.lastGrenadeType = type;
	}
	
	action void A_DecideSpawnLaserPuff()
	{
			if (CountInv("LaserSightActivated")==1 && CountInv("KeepLaserDeactivated") != 1)
			{
				invoker.A_SpawnLaserPuff();
			}
			else 
			{
				invoker.A_DestroyLaserPuff();
			}
	}
	action void A_DestroyLaserPuff()
	{
		if (invoker.laseractor) invoker.laseractor.Destroy();
	}
	action Actor A_SpawnLaserPuff()
	{
		int integer;
		[invoker.InvActor, invoker.integer] = LineAttack(angle,4096,pitch,0,'None',"InvisiblePuff",LAF_NORANDOMPUFFZ|LAF_NOINTERACT);
		if (invoker.InvActor)
		{
			invoker.invactorpos = invoker.InvActor.pos;
			invoker.InvActor.Destroy();
		}
		if (!invoker.laseractor) invoker.laseractor = Spawn("LaserDotPerma",invoker.invactorpos);
		else invoker.laseractor.SetOrigin(invoker.invactorpos, true);
		
		return invoker.laseractor;
	}
	action int CheckUnloaded(string token)
	{
		if (CountInv(token) == 1) return PBWEAP_UNLOADED;
		return 0;
	}
	action state A_DoPBWeaponAction(int weapflags = WRF_ALLOWRELOAD, int pbFlags = 0, string unloadtoken = "HasUnloaded")
	{
		static const string PBWeapEmptyToken[] = 
		{
			"PBPistolWasEmpty","RifleWasEmpty","UACSMGWasEmpty"
		};
		static const string PBWeapUnloadedToken[] =
		{
			"HasUnloaded","PulseCannonHasUnloaded", "HasUnloadedRG"
		};
		static const string PBWeapUnloadableClasses [] =
		{
			"PB_Weapon","PulseCannon"
		};
		static const statelabel PBWeapStatelabels[] =
		{
			"Steady", "LedgeClimb", "QuickPunch",
			"DoKick", "Taunt", "Salute", "Salute",
			"UseEquipment", "SwitchEquipment", "DualWieldBaby",
			"NoDualWield", "WeaponSpecial", "GrabbedBarrel", "GrabbedBurningBarrel"
		};
		if (!(pbFlags & PBWEAP_UNLOADED)) pbFlags |= CheckUnloaded(invoker.UnloaderToken);
		if (CountInv("GoFatality")>=1)
		{
			return ResolveState("Steady");
		}
		if (CountInv("Grabbing_A_Ledge")>=1) 
		{
			return ResolveState("LedgeClimb");
		}
		if (CountInv("DoPunch")>=1) 
		{
			return ResolveState("QuickPunch");
		}
		if (CountInv("Kicking")>=1) 
		{
			return ResolveState("DoKick");
		}
		else if (CountInv("Taunting")>=1) 
		{
			return ResolveState("Taunt");
		}
		if (CountInv("Salute1")>=1 || CountInv("Salute2")>=1) 
		{
			return ResolveState("Salute");
		}
		if (CountInv("UseEquipment")>=1) 
		{
			return ResolveState("UseEquipment");
		}
		if (CountInv("ToggleEquipment")>=1) 
		{
			return ResolveState("SwitchEquipment");
		}
		if (CountInv("GoWeaponSpecialAbility")>=1)
		{
			if (ResolveState("DualWieldBaby")) return ResolveState("DualWieldBaby");
			else if (ResolveState("NoDualWield")) return ResolveState("NoDualWield");
			else return ResolveState("WeaponSpecial");
		}
		if (CountInv("GrabbedBarrel")>=1 || CountInv("GrabbedBurningBarrel")>=1) 
		{
			return ResolveState("GrabBarrel");
		}
		if (CountInv("Unloading")>=1 && ResolveState("Unload") && !(pbFlags & PBWEAP_UNLOADED) && CountInv(invoker.UnloaderToken) != 1)
		{
			return ResolveState("Unload");
		}
		if (CountInv(invoker.UnloaderToken) >= 1 && !(pbFlags & PBWEAP_UNLOADED) && !InStateSequence(invoker.owner.player.GetPSprite(PSP_WEAPON).Curstate,invoker.ResolveState("GunEmpty")))
		{
			return ResolveState("GunEmpty");
		}
		if (ResolveState("LoadChamber"))
		{
			for (int i = 0; i < PBWeapEmptyToken.Size(); ++i)
			{
				if (CountInv(PBWeapEmptyToken[i]) >= 1)
				{
					return ResolveState("LoadChamber");
				}
			}
		}
		if (ResolveState("ReadyToFireSilencer") 
		&& CountInv("SilencerEquipped") >= 1
		&& !(pbFlags & PBWEAP_ISPISTOLSILENCERSTATE))
		{
			return ResolveState("ReadyToFireSilencer");
		}
		A_WeaponReady(weapflags);
		//A_WeaponOffset(-CallACS("Script_GetGunOffsetX"), CallACS("Script_GetGunOffsetY")-1,WOF_INTERPOLATE | (!!(pbFlags & PBWEAP_KEEPYOFFSET) ? WOF_KEEPY : 0));
		return null;
	}
  
	action void A_SetWeaponSprite(String str)
        {
                    let psp = player.GetPSprite(PSP_WEAPON);
                    psp.sprite = GetSpriteIndex(str);
        }
		
	action void A_SetFlashWeaponSprite(String str)
        {
                    let psp = player.GetPSprite(PSP_FLASH);
                    psp.sprite = GetSpriteIndex(str);
        }
}

// Optional Motion Blur by Pixel Eater
class MBlurHandler : StaticEventHandler
{
	int			pitch, yaw ;
	double		xtravel, ytravel ;
	
	override void PlayerEntered( PlayerEvent e )
	{
		PlayerInfo plr = players[ consoleplayer ];
		if( plr )
		{	
			xtravel = 0 ;
			ytravel = 0 ;
		}
	}
	
	override void WorldTick()
	{
		PlayerInfo	plr = players[ consoleplayer ];
		if( plr && plr.health > 0 && Cvar.GetCVar( "mblur", plr ).GetBool() && !plr.mo.FindInventory("PlayerWheelOpen"))
		{
			yaw		= plr.mo.GetPlayerInput( ModInput_Yaw );
			pitch	= -plr.mo.GetPlayerInput( ModInput_Pitch );
		}
	}
	
	override void NetworkProcess( ConsoleEvent e )
	{
		PlayerInfo	plr = players[ consoleplayer ];
		if( plr && plr.mo && e.Name == "liveupdate" && !plr.mo.FindInventory("PlayerWheelOpen"))
		{
			double pitchdimin	= 1. - abs( plr.mo.pitch * 1. / 90 );
			double decay		= 1. - Cvar.GetCVar( "mblur_recovery", plr ).GetFloat() * .01 ;
			double amount		= Cvar.GetCVar( "mblur_strength", plr ).GetFloat() * 10. / 32767 * sqrt( pitchdimin );
			if(plr.mo.FindInventory("PlayerWheelOpen")){
				xtravel				= 0 * decay + yaw * amount * .625 ;
				ytravel				= 0 * decay + pitch * amount ;
			}
			else
			{
				xtravel				= xtravel * decay + yaw * amount * .625 ;
				ytravel				= ytravel * decay + pitch * amount ;
			}
			
			if( Cvar.GetCVar( "mblur_autostop", plr ).GetBool() )
			{
				double threshold = Cvar.GetCVar( "mblur_threshold", plr ).GetFloat() * 30 ;
				double recovery2 = 1 - Cvar.GetCVar( "mblur_recovery2", plr ).GetFloat() * .01 ;
				if( abs( yaw )		<= threshold ) xtravel *= recovery2 ;
				if( abs( pitch )	<= threshold ) ytravel *= recovery2 ;
			}
		}
	}
	
	override void UiTick()
	{
		PlayerInfo	plr = players[ consoleplayer ];
		if( plr )
		{
			let player = players[ consoleplayer ].mo;
			
			if(  plr.health > 0 && Cvar.GetCVar( "mblur", plr ).GetBool() && !plr.mo.FindInventory("PlayerWheelOpen"))//&& yaw && pitch )
			{
				EventHandler.SendNetworkEvent( "liveupdate" );
				int copies			= 1 + Cvar.GetCVar( "mblur_samples", plr ).GetInt() ;
				double increment	= 1. / copies ;
				vector2 travel		= ( xtravel, ytravel ) / screen.getheight() ;
				
				Shader.SetUniform2f( plr, "MBlur", "steps", travel * increment );
				Shader.SetUniform1f( plr, "MBlur", "samples", copies );
				Shader.SetUniform1f( plr, "MBlur", "increment", increment );
				Shader.SetUniform1f( plr, "MBlur", "blendmode", Cvar.GetCVar( "mblur_blendmode", plr ).GetInt() );
					
				Shader.SetEnabled( plr, "MBlur", true );
				
			}
			else
			{
				Shader.SetEnabled( plr, "MBlur", false );
			}
		}
	}
}