Class FlakAmmo : Ammo
{
	Default
	{
		Tag "$T_FLAKAMMO";
		Inventory.PickupMessage "";
		Inventory.Amount 10;
		Inventory.MaxAmount 50;
		Ammo.BackpackAmount 5;
		Ammo.BackpackMaxAmount 100;
		Ammo.DropAmount 5;
	}
	override String PickupMessage()
	{
		if ( PickupMsg.Length() > 0 ) return Super.PickupMessage();
		return String.Format("%s%d%s",StringTable.Localize("$I_FLAKAMMOL"),Amount,StringTable.Localize("$I_FLAKAMMOR"));
	}
	States
	{
	Spawn:
		FAMO A -1;
		Stop;
	}
}

Class FlakAmmo2 : FlakAmmo
{
	Default
	{
		Tag "$T_FLAKAMMO2";
		Inventory.PickupMessage "$I_FLAKAMMO2";
		Inventory.Amount 1;
		Ammo.DropAmount 1;
		+INVENTORY.IGNORESKILL;
	}
	States
	{
	Spawn:
		FSLG A -1;
		Stop;
	}
}

Class ChunkLight : DynamicLight
{
	Default
	{
		DynamicLight.Type "Point";
		Args 255,224,128,8;
	}
	override void Tick()
	{
		Super.Tick();
		if ( !target )
		{
			Destroy();
			return;
		}
		SetOrigin(target.pos,true);
		if ( isFrozen() ) return;
		args[LIGHT_RED] = int(255*(10-target.frame)*0.1);
		args[LIGHT_GREEN] = int(224*(10-target.frame)*0.1);
		args[LIGHT_BLUE] = int(128*(10-target.frame)*0.1);
	}
}

Class ChunkTrail : Actor
{
	Default
	{
		RenderStyle "Add";
		Radius 0.1;
		Height 0;
		+NOBLOCKMAP;
		+NOGRAVITY;
		+DONTSPLASH;
		+FORCEXYBILLBOARD;
		+NOTELEPORT;
		Scale 0.2;
	}
	override void PostBeginPlay()
	{
		Super.PostBeginPlay();
		let l = Spawn("ChunkLight",pos);
		l.target = self;
	}
	override void Tick()
	{
		Super.Tick();
		if ( isFrozen() ) return;
		if ( InStateSequence(CurState,FindState("Death")) ) return;
		if ( !target )
		{
			int dist = FindState("Spawn").DistanceTo(CurState);
			SetState(FindState("Death")+dist);
			return;
		}
		SetOrigin(target.Vec3Offset(0,0,speed),true);
	}
	States
	{
	Spawn:
		FGLO ABCDEFGHIJK 3 Bright;
		Stop;
	Death:
		FGLO ABCDEFGHIJK 1 Bright;
		Stop;
	}
}

Class FlakAccumulator : Thinker
{
	Actor victim, inflictor, source;
	Array<Int> amounts;
	int total;
	Name type;

	override void Tick()
	{
		Super.Tick();
		// so many damn safeguards in this
		if ( !victim )
		{
			Destroy();
			return;
		}
		int gibhealth = victim.GetGibHealth();
		// おまえはもう死んでいる
		if ( victim.health-total <= gibhealth )
		{
			// safeguard for inflictors that have somehow ceased to exist, which apparently STILL CAN HAPPEN
			if ( inflictor ) inflictor.bEXTREMEDEATH = true;
			else type = 'Extreme';
		}
		// make sure accumulation isn't reentrant
		if ( inflictor && (inflictor is 'FlakChunk') ) inflictor.bAMBUSH = true;
		// 何？
		for ( int i=0; i<amounts.Size(); i++ )
		{
			if ( !victim ) break;
			victim.DamageMobj(inflictor,source,amounts[i],type,DMG_THRUSTLESS);
		}
		// clean up
		if ( inflictor )
		{
			if ( inflictor is 'FlakChunk' ) inflictor.bAMBUSH = false;
			inflictor.bEXTREMEDEATH = false;
		}
		Destroy();
	}

	static void Accumulate( Actor victim, int amount, Actor inflictor, Actor source, Name type )
	{
		if ( !victim ) return;
		let ti = ThinkerIterator.Create("FlakAccumulator",STAT_USER);
		FlakAccumulator a, match = null;
		while ( a = FlakAccumulator(ti.Next()) )
		{
			if ( a.victim != victim ) continue;
			match = a;
			break;
		}
		if ( !match )
		{
			match = new("FlakAccumulator");
			match.ChangeStatNum(STAT_USER);
			match.victim = victim;
			match.amounts.Clear();
		}
		match.amounts.Push(amount);
		match.total += amount;
		match.inflictor = inflictor;
		match.source = source;
		match.type = type;
	}

	static clearscope int GetAmount( Actor victim )
	{
		let ti = ThinkerIterator.Create("FlakAccumulator",STAT_USER);
		FlakAccumulator a, match = null;
		while ( a = FlakAccumulator(ti.Next()) )
		{
			if ( a.victim != victim ) continue;
			return a.total;
		}
		return 0;
	}
}

Class FlakChunk : Actor
{
	Mixin UTMissileFix;

	ChunkTrail trail;
	double rollvel, pitchvel, yawvel;
	double lifetime, lifespeed;
	int lifetics;
	Vector3 oldvel;
	Actor lasthit;
	Default
	{
		Obituary "$O_FLAKCANNON";
		Radius 2;
		Height 2;
		Speed 32;
		DamageFunction 16;
		DamageType 'Shredded';
		BounceType "Hexen";
		BounceFactor 1.0;
		WallBounceFactor 1.0;
		PROJECTILE;
		+USEBOUNCESTATE;
		+CANBOUNCEWATER;
		+SKYEXPLODE;
		+INTERPOLATEANGLES;
		+HITTRACER;
		+DONTBOUNCEONSHOOTABLES;
		Scale 0.3;
	}
	override void PostBeginPlay()
	{
		Super.PostBeginPlay();
		lifetime = 0;
		lifespeed = FRandom[Flak](0.004,0.008);
		trail = ChunkTrail(Spawn("ChunkTrail",pos));
		trail.target = self;
		trail.speed = 1.2;
		rollvel = FRandom[Flak](50,100)*RandomPick[Flak](-1,1);
		pitchvel = FRandom[Flak](50,100)*RandomPick[Flak](-1,1);
		yawvel = FRandom[Flak](50,100)*RandomPick[Flak](-1,1);
		scale *= Frandom[Flak](0.8,1.2);
		SetState(ResolveState("Spawn")+Random[Flak](0,3));
	}
	override void Tick()
	{
		oldvel = vel;
		Super.Tick();
		if ( isFrozen() ) return;
		if ( waterlevel > 0 )
		{
			rollvel *= 0.98;
			pitchvel *= 0.98;
			yawvel *= 0.98;
			if ( trail ) trail.Destroy();
		}
		lifetics++;
		if ( lifetics > 3 )
		{
			lifetics = 0;
			if ( frame < 11 ) frame++;
		}
		lifetime += lifespeed;
		if ( (waterlevel <= 0) && (frame < 10) && !(lifetics%2) )
		{
			let s = Spawn("UTSmoke",pos);
			s.vel = (FRandom[Flak](-0.1,0.1),FRandom[Flak](-0.1,0.1),FRandom[Flak](-0.1,0.1));
			s.alpha = scale.x/0.5;
			s.SetShade("AAAAAA");
		}
		else if ( waterlevel > 0 )
		{
			let s = Spawn("UTBubble",pos);
			s.vel = (FRandom[Flak](-0.1,0.1),FRandom[Flak](-0.1,0.1),FRandom[Flak](-0.1,0.1));
			s.scale *= scale.x*0.5;
		}
		if ( trail ) trail.alpha = max(0,11-frame)/11.;
		if ( InStateSequence(CurState,FindState("Death")) ) return;
		roll += rollvel;
		pitch += pitchvel;
		angle += pitchvel;
	}
	void A_HandleBounce()
	{
		// chunks in vanilla have a special variation on the standard reflect formula that causes them to bounce differently when hitting a surface head-on
		// (0.5 to 0.8 reduction perpendicular to the surface normal, to be specific)
		Vector3 HitNormal = -vel.unit();
		F3DFloor ff;
		if ( BlockingFloor )
		{
			// find closest 3d floor for its normal
			for ( int i=0; i<CurSector.Get3DFloorCount(); i++ )
			{
				if ( !(CurSector.Get3DFloor(i).top.ZAtPoint(pos.xy) ~== floorz) ) continue;
				ff = CurSector.Get3DFloor(i);
				break;
			}
			if ( ff ) HitNormal = -ff.top.Normal;
			else HitNormal = BlockingFloor.floorplane.Normal;
		}
		else if ( BlockingCeiling )
		{
			// find closest 3d floor for its normal
			for ( int i=0; i<CurSector.Get3DFloorCount(); i++ )
			{
				if ( !(CurSector.Get3DFloor(i).bottom.ZAtPoint(pos.xy) ~== ceilingz) ) continue;
				ff = CurSector.Get3DFloor(i);
				break;
			}
			if ( ff ) HitNormal = -ff.bottom.Normal;
			else HitNormal = BlockingCeiling.ceilingplane.Normal;
		}
		else if ( BlockingLine )
		{
			HitNormal = (-BlockingLine.delta.y,BlockingLine.delta.x,0).unit();
			if ( !BlockingLine.sidedef[1] || (CurSector == BlockingLine.frontsector) )
				HitNormal *= -1;
		}
		else if ( BlockingMobj )
		{
			Vector3 diff = level.Vec3Diff(pos,BlockingMobj.pos);
			if ( (pos.x+radius) <= (BlockingMobj.pos.x-BlockingMobj.radius) )
				HitNormal = (-1,0,0);
			else if ( (pos.x-radius) >= (BlockingMobj.pos.x+BlockingMobj.radius) )
				HitNormal = (1,0,0);
			else if ( (pos.y+radius) <= (BlockingMobj.pos.y-BlockingMobj.radius) )
				HitNormal = (0,-1,0);
			else if ( (pos.y-radius) >= (BlockingMobj.pos.y+BlockingMobj.radius) )
				HitNormal = (0,1,0);
			else if ( pos.z >= (BlockingMobj.pos.z+BlockingMobj.height) )
				HitNormal = (0,0,1);
			else if ( (pos.z+height) <= BlockingMobj.pos.z )
				HitNormal = (0,0,-1);
		}
		// undo the bounce, we need to hook in our own
		vel = oldvel;
		// re-do the bounce with our formula
		vel = 0.8*((vel dot HitNormal)*HitNormal*(-1.8+FRandom[Flak](0.0,0.8))+vel);
		bHITOWNER = true;
		int numpt = Random[Flak](2,3);
		if ( (frame < 10) && Random[Flak](0,1) )
		{
			for ( int i=0; i<numpt; i++ )
			{
				Vector3 pvel = (FRandom[Flak](-1,1),FRandom[Flak](-1,1),FRandom[Flak](-1,1)).unit()*FRandom[Flak](2,4);
				let s = Spawn("UTSpark",pos);
				s.vel = pvel;
			}
		}
		else A_SprayDecal("WallCrack",-8);
		A_Gravity();
		gravity = 0.35;
		rollvel = FRandom[Flak](50,100)*RandomPick[Flak](-1,1)*(vel.length()/speed);
		pitchvel = FRandom[Flak](50,100)*RandomPick[Flak](-1,1)*(vel.length()/speed);
		yawvel = FRandom[Flak](50,100)*RandomPick[Flak](-1,1)*(vel.length()/speed);
		A_StartSound("flak/bounce",volume:0.3);
		A_AlertMonsters();
		if ( vel.length() < 5 ) ExplodeMissile();
	}
	override int DoSpecialDamage( Actor target, int damage, Name damagetype )
	{
		if ( bAMBUSH || (vel.length() <= 5) ) return damage;
		if ( !target.bNOBLOOD )
		{
			target.SpawnBlood(pos,AngleTo(target),damage);
			A_StartSound("flak/meat",volume:0.3);
			A_AlertMonsters();
		}
		return -1;
	}
	override int SpecialMissileHit( Actor victim )
	{
		if ( bAMBUSH || (vel.length() <= 5) || ((victim == target) && !bHITOWNER) || (victim == lasthit) )
			return 1;
		// with this we can guarantee that the chunk won't just keep on dealing damage
		// this is something I wish Unreal's boulders did
		lasthit = victim;
		// gather damage
		FlakAccumulator.Accumulate(victim,GetMissileDamage(0,0),self,target,damagetype);
		int amt = FlakAccumulator.GetAmount(victim);
		// pass through if it's already dead
		if ( victim.health-amt <= 0 )
		{
			// bleed if not gibbed (reduces effect spam)
			if ( !victim.bNOBLOOD && (victim.health-amt > victim.GetGibHealth()) )
			{
				victim.SpawnBlood(pos,AngleTo(victim),damage);
				A_StartSound("flak/meat",volume:0.3);
				A_AlertMonsters();
			}
			return 1;
		}
		return -1;
	}
	States
	{
	Spawn:
		FCH1 A 0;
		Goto Idle;
		FCH2 A 0;
		Goto Idle;
		FCH3 A 0;
		Goto Idle;
		FCH4 A 0;
		Goto Idle;
	Idle:
		#### # -1;
		Stop;
	Bounce:
		#### # 0 A_HandleBounce();
		Goto Idle;
	Death:
		#### # 0
		{
			bMOVEWITHSECTOR = true;
			A_SetTics(Random[Flak](30,50));
		}
		#### # 1
		{
			A_SetScale(scale.x-0.002);
			if ( scale.x <= 0.0 ) Destroy();
		}
		Wait;
	Crash:
		TNT1 A 0
		{
			let l = Spawn("BulletImpact",pos);
			Vector3 dir;
			if ( tracer ) dir = level.Vec3Diff(pos,tracer.Vec3Offset(0,0,tracer.height/2)).unit();
			else dir = vel.unit();
			l.angle = atan2(dir.y,dir.x);
			l.pitch = asin(-dir.z);
			A_StartSound("flak/hit",volume:0.3);
			A_AlertMonsters();
		}
	XDeath:
		TNT1 A 2;	// must exist for at least two tics so the accumulator gets the right inflictor
		Stop;
	Dummy:
		FCH1 ABCDEFGHIJKL -1;
		FCH2 ABCDEFGHIJKL -1;
		FCH3 ABCDEFGHIJKL -1;
		FCH4 ABCDEFGHIJKL -1;
		Stop;
	}
}

Class SlugSmoke : Actor
{
	double lifetime, lifespeed;
	Default
	{
		Radius 0.1;
		Height 0;
		+NOBLOCKMAP;
		+NOGRAVITY;
		+DONTSPLASH;
		+NOTELEPORT;
	}
	override void PostBeginPlay()
	{
		Super.PostBeginPlay();
		lifetime = 0;
		lifespeed = FRandom[Flak](0.004,0.008);
	}
	override void Tick()
	{
		Super.Tick();
		if ( isFrozen() ) return;
		lifetime += lifespeed;
		let s = Spawn("UTSmoke",pos);
		s.vel = (FRandom[Flak](-0.5,0.5),FRandom[Flak](-0.5,0.5),FRandom[Flak](-0.5,0.5));
		s.vel.z += 2.;
		s.alpha = scale.x;
		s.SetShade("AAAAAA");
		scale.x = max(0,1-lifetime);
		if ( scale.x <= 0 ) Destroy();
	}
	States
	{
	Spawn:
		TNT1 A -1;
		Stop;
	}
}

Class SlugLight : PaletteLight
{
	Default
	{
		Args 0,0,0,80;
		ReactionTime 20;
	}
}

Class FlakSlug : Actor
{
	Mixin UTMissileFix;

	Default
	{
		Obituary "$O_FLAKCANNON";
		DamageType 'FlakDeath';
		Radius 2;
		Height 2;
		Gravity 0.35;
		Speed 20;
		PROJECTILE;
		-NOGRAVITY;
		+SKYEXPLODE;
		+EXPLODEONWATER;
		+HITTRACER;
		+FORCERADIUSDMG;
		+NODAMAGETHRUST;
	}
	override void PostBeginPlay()
	{
		Super.PostBeginPlay();
		vel.z += 3;
	}
	action void A_FlakExplode()
	{
		bForceXYBillboard = true;
		A_SetRenderStyle(1.0,STYLE_Add);
		A_SprayDecal("RocketBlast",50);
		A_NoGravity();
		A_SetScale(1.2);
		UTMainHandler.DoBlast(self,120,75000);
		A_Explode(70,120);
		A_QuakeEx(4,4,4,8,0,170,"",QF_RELATIVE|QF_SCALEDOWN,falloff:120,rollIntensity:0.2);
		A_StartSound("flak/explode",CHAN_VOICE);
		A_AlertMonsters();
		if ( !Tracer ) Spawn("SlugSmoke",pos);
		Spawn("SlugLight",pos);
		Vector3 x, y, z;
		double a, s;
		[x, y, z] = dt_CoordUtil.GetAxes(pitch,angle,roll);
		Actor p;
		Vector3 spawnofs;
		if ( BlockingMobj ) spawnofs = level.Vec3Diff(pos,BlockingMobj.Vec3Offset(0,0,BlockingMobj.height/2)).unit()*8;
		else if ( BlockingFloor ) spawnofs = BlockingFloor.floorplane.Normal*8;
		else if ( BlockingCeiling ) spawnofs = BlockingCeiling.ceilingplane.Normal*8;
		else if ( BlockingLine )
		{
			spawnofs = (-BlockingLine.delta.y,BlockingLine.delta.x,0).unit()*8;
			if ( !BlockingLine.sidedef[1] || (CurSector == BlockingLine.frontsector) )
				spawnofs *= -1;
		}
		for ( int i=0; i<5; i++ )
		{
			p = Spawn("FlakChunk",Vec3Offset(spawnofs.x,spawnofs.y,spawnofs.z));
			p.bHITOWNER = true;
			a = FRandom[Flak](0,360);
			s = FRandom[Flak](0,0.1);
			Vector3 dir = dt_Utility.ConeSpread(x,y,z,a,s);
			p.angle = atan2(dir.y,dir.x);
			p.pitch = -asin(dir.z);
			p.vel = dt_Utility.Vec3FromAngle(p.angle,p.pitch)*(p.speed+FRandom[Flak](-3,3));
			p.target = target;
		}
		int numpt = Random[Flak](8,12);
		for ( int i=0; i<numpt; i++ )
		{
			Vector3 pvel = (FRandom[Flak](-1,1),FRandom[Flak](-1,1),FRandom[Flak](-1,1)).unit()*FRandom[Flak](2,8);
			let s = Spawn("UTSpark",pos);
			s.vel = pvel;
		}
		numpt = Random[Flak](15,30);
		for ( int i=0; i<numpt; i++ )
		{
			Vector3 pvel = (FRandom[Flak](-1,1),FRandom[Flak](-1,1),FRandom[Flak](-1,1)).unit()*FRandom[Flak](6,16);
			let s = Spawn("UTChip",pos);
			s.vel = pvel;
			s.scale *= FRandom[Flak](0.9,1.8);
		}
	}
	States
	{
	Spawn:
		FSLG A 1
		{
			for ( int i=0; i<6; i++ )
			{
				let s = Spawn("UTSmoke",pos);
				s.vel = (FRandom[Flak](-0.5,0.5),FRandom[Flak](-0.5,0.5),FRandom[Flak](-0.5,0.5));
				s.alpha = 0.5;
				s.SetShade("AAAAAA");
			}
		}
		Wait;
	Death:
		FLEX A 0 A_FlakExplode();
		FLEX ABCDEFGHIJKLMNOPQR 1 BRIGHT;
		Stop;
	}
}

Class FlakLight : DynamicLight
{
	int cnt;
	Default
	{
		DynamicLight.Type "Point";
		args 255,224,128,150;
	}
	override void Tick()
	{
		Super.Tick();
		if ( !target )
		{
			Destroy();
			return;
		}
		if ( target.player ) SetOrigin(target.Vec2OffsetZ(0,0,target.player.viewz),true);
		else SetOrigin(target.pos,true);
		if ( cnt++ > 2 ) Destroy();
	}
}

Class FlakMag : UTCasing
{
	Default
	{
		BounceSound "flak/sbounce";
	}
	override void PostBeginPlay()
	{
		Super.PostBeginPlay();
		if ( special1 )
		{
			anglevel *= .1;
			pitchvel *= .1;
		}
	}
	States
	{
	Death:
		PCAS A -1
		{
			pitch = RandomPick[Junk](-90,90);
			angle = FRandom[Junk](0,360);
		}
		Stop;
	}
}

Class FlakCannon : UTWeapon
{
	transient ui Canvas AmmoLed;
	ui TextureID LedFont;

	override void RenderOverlay( RenderEvent e )
	{
		Vector2 fnt[] =
		{
			(0,1), (21,1), (42,1), (63,1), (84,1),
			(105,1), (126,1), (147,1), (168,1), (189,1)
		};
		if ( !AmmoLed ) AmmoLed = TexMan.GetCanvas("FlakALed");
		if ( !LedFont ) LedFont = TexMan.CheckForTexture("models/LEDFont2.png",TexMan.Type_Any);
		AmmoLed.Clear(0,0,128,64,"Black");
		int dg3 = (Ammo1.Amount/100)%10;
		int dg2 = (Ammo1.Amount/10)%10;
		int dg1 = Ammo1.Amount%10;
		AmmoLed.DrawTexture(LedFont,false,34,14,DTA_SrcX,fnt[dg3].x,DTA_SrcY,fnt[dg3].y,DTA_SrcWidth,20,DTA_SrcHeight,35,DTA_DestWidth,20,DTA_DestHeight,35,DTA_Color,0xFFFF0000);
		AmmoLed.DrawTexture(LedFont,false,54,14,DTA_SrcX,fnt[dg2].x,DTA_SrcY,fnt[dg2].y,DTA_SrcWidth,20,DTA_SrcHeight,35,DTA_DestWidth,20,DTA_DestHeight,35,DTA_Color,0xFFFF0000);
		AmmoLed.DrawTexture(LedFont,false,74,14,DTA_SrcX,fnt[dg1].x,DTA_SrcY,fnt[dg1].y,DTA_SrcWidth,20,DTA_SrcHeight,35,DTA_DestWidth,20,DTA_DestHeight,35,DTA_Color,0xFFFF0000);
	}

	action void A_Loading( bool first = false )
	{
		if ( first ) A_StartSound("flak/load",CHAN_WEAPONMISC,CHANF_OVERLAP);
		else A_StartSound("flak/reload",CHAN_WEAPONMISC,CHANF_OVERLAP);
	}
	action void A_FireChunks()
	{
		Weapon weap = Weapon(invoker);
		if ( !weap ) return;
		if ( weap.Ammo1.Amount <= 0 ) return;
		if ( !weap.DepleteAmmo(weap.bAltFire,true,1) ) return;
		A_StartSound("flak/fire",CHAN_WEAPON);
		invoker.FireEffect();
		UTMainHandler.DoFlash(self,Color(160,255,96,0),1);
		A_AlertMonsters();
		A_QuakeEx(1,1,1,3,0,1,"",QF_RELATIVE|QF_SCALEDOWN,rollIntensity:0.05);
		Vector3 x, y, z;
		double a, s;
		[x, y, z] = dt_CoordUtil.GetAxes(pitch,angle,roll);
		Vector3 origin = level.Vec3Offset(Vec2OffsetZ(0,0,player.viewz),10*x+4*y-3*z);
		A_Overlay(-2,"MuzzleFlash");
		A_OverlayFlags(-2,PSPF_RENDERSTYLE|PSPF_FORCESTYLE,true);
		A_OverlayRenderstyle(-2,STYLE_Add);
		[x, y, z] = dt_CoordUtil.GetAxes(BulletSlope(),angle,roll);
		Vector3 offsets[8];	// vanilla adds these to each chunk
		offsets[0] = (0,0,0);
		offsets[1] = -z;
		offsets[2] = 2*y+z;
		offsets[3] = -y;
		offsets[4] = 2*y-z;
		offsets[5] = (0,0,0);
		offsets[6] = y-z;
		offsets[7] = 2*y+z;
		Actor p;
		for ( int i=0; i<8; i++ )
		{
			p = Spawn("FlakChunk",level.Vec3Offset(origin,offsets[i]));
			a = FRandom[Flak](0,360);
			s = FRandom[Flak](0,0.1);
			Vector3 dir = dt_Utility.ConeSpread(x,y,z,a,s);
			p.angle = atan2(dir.y,dir.x);
			p.pitch = -asin(dir.z);
			p.vel = dt_Utility.Vec3FromAngle(p.angle,p.pitch)*(p.speed+FRandom[Flak](-3,3));
			p.target = self;
		}
		int numpt = Random[Flak](20,30);
		for ( int i=0; i<numpt; i++ )
		{
			let s = Spawn("UTViewSpark",origin);
			UTViewSpark(s).ofs = (10,2,-3);
			UTViewSpark(s).vvel = (FRandom[Flak](3,12),FRandom[Flak](-4,4),FRandom[Flak](-4,4));
			s.target = self;
		}
		for ( int i=0; i<12; i++ )
		{
			let s = Spawn("UTViewSmoke",origin);
			UTViewSmoke(s).ofs = (10,2,-3);
			UTViewSmoke(s).vvel = (FRandom[Flak](0,1.2),FRandom[Flak](-.4,.4),FRandom[Flak](-.4,.4));
			s.target = self;
			s.scale *= 2.4;
			s.alpha *= 0.5;
		}
	}
	action void A_FireSlug()
	{
		Weapon weap = Weapon(invoker);
		if ( !weap ) return;
		if ( weap.Ammo1.Amount <= 0 ) return;
		if ( !weap.DepleteAmmo(weap.bAltFire,true,1) ) return;
		A_StartSound("flak/altfire",CHAN_WEAPON);
		invoker.FireEffect();
		UTMainHandler.DoFlash(self,Color(128,255,96,0),1);
		A_AlertMonsters();
		A_QuakeEx(2,2,2,6,0,1,"",QF_RELATIVE|QF_SCALEDOWN,rollIntensity:0.1);
		Vector3 x, y, z;
		double a, s;
		[x, y, z] = dt_CoordUtil.GetAxes(pitch,angle,roll);
		Vector3 origin = level.Vec3Offset(Vec2OffsetZ(0,0,player.viewz),10*x+2*y-3*z);
		A_Overlay(-2,"MuzzleFlash");
		A_OverlayFlags(-2,PSPF_RENDERSTYLE|PSPF_FORCESTYLE,true);
		A_OverlayRenderstyle(-2,STYLE_Add);
		Actor p = Spawn("FlakSlug",origin);
		p.angle = angle;
		p.pitch = BulletSlope();
		p.vel = dt_Utility.Vec3FromAngle(p.angle,p.pitch)*p.speed;
		p.target = self;
		int numpt = Random[Flak](10,15);
		for ( int i=0; i<numpt; i++ )
		{
			let s = Spawn("UTViewSpark",origin);
			UTViewSpark(s).ofs = (10,2,-3);
			UTViewSpark(s).vvel = (FRandom[Flak](3,12),FRandom[Flak](-4,4),FRandom[Flak](-4,4));
			s.target = self;
		}
		for ( int i=0; i<16; i++ )
		{
			let s = Spawn("UTViewSmoke",origin);
			UTViewSmoke(s).ofs = (10,2,-3);
			UTViewSmoke(s).vvel = (FRandom[Flak](0,1.2),FRandom[Flak](-.8,.8),FRandom[Flak](-.8,.8));
			s.target = self;
			s.scale *= 2.4;
			s.alpha *= 0.5;
		}
		let c = Spawn("FlakMag",origin);
		c.angle = angle;
		c.pitch = BulletSlope();
		c.vel = x*FRandom[Junk](15.,20.)+y*FRandom[Junk](-.1,.1)+z*FRandom[Junk](.1,.8);
		c.special1 = 1;
	}

	Default
	{
		Tag "$T_FLAKCANNON";
		Inventory.PickupMessage "$I_FLAKCANNON";
		Weapon.UpSound "flak/select";
		Weapon.SlotNumber 8;
		Weapon.SelectionOrder 2;
		Weapon.AmmoType "FlakAmmo";
		Weapon.AmmoUse 1;
		Weapon.AmmoType2 "FlakAmmo";
		Weapon.AmmoUse2 1;
		Weapon.AmmoGive 10;
		UTWeapon.DropAmmo 5;
		UTWeapon.NameColor "FF 60 00";
	}
	States
	{
	Spawn:
		FPCK A -1;
		Stop;
		FPCK B -1;
		Stop;
	Ready:
		FLKS ABDEGHJKMNPQSTVWYZ 1 A_WeaponReady(WRF_NOFIRE);
		FKS2 BC 1 A_WeaponReady(WRF_NOFIRE);
		FLKL A 1 A_Loading(true);
		FLKL BCEFGIJKMNO 1;
		Goto Idle;
	Loading:
		FLKL A 1
		{
			A_CheckReload();
			if ( invoker.Ammo1.Amount > 0 ) A_Loading();
		}
		FLKL BCEFGIJKMNO 1;
		Goto Idle;
	AltLoading:
		FLKL A 2
		{
			A_CheckReload();
			if ( invoker.Ammo1.Amount > 0 ) A_Loading();
		}
		FLKL BCEFGIJKMNO 2;
		Goto Idle;
	Idle:
		FLKI A 1 A_WeaponReady();
		Wait;
	Fire:
		FLKF A 1 A_FireChunks();
		FLKF BCDEFGHI 1;
		FLKF J 4
		{
			Vector3 x, y, z, origin;
			[x,y,z] = dt_CoordUtil.GetAxes(pitch,angle,roll);
			origin = level.Vec3Offset(Vec2OffsetZ(0,0,player.viewz),x*4.+y*3.-z*8.);
			let c = Spawn("FlakMag",origin);
			c.angle = angle;
			c.pitch = pitch;
			c.vel = vel*.5+x*FRandom[Junk](-.8,.1)+y*FRandom[Junk](-.2,.2)-z*FRandom[Junk](1,2);
		}
		Goto Loading;
	AltFire:
		FLKA A 1 A_FireSlug();
		FLKA BCDEFGHIJK 1;
		FLKA K 4;
		Goto AltLoading;
	Select:
		FLKS A 1 A_Raise(int.max);
		Wait;
	Deselect:
		FLKD ABCDEFGHIJ 1;
		FLKD J 1 A_Lower(int.max);
		Wait;
	MuzzleFlash:
		FMUZ A 3 Bright
		{
			let l = Spawn("FlakLight",pos);
			l.target = self;
		}
		Stop;
	}
}