etayn

summons.zsc (11777B)

---

 //TODO: Improve pathfinding (the permanent goal)
 //TODO: Summons make a blood splatter when they hit the player
 //(but deal no damage), fix that
 //TODO: Make summons step back if they're within
 //(say) 100 units of the player
 //TODO: Have ChaseTarget() get called from a function that
 //runs every tick instead of in the state block, so
 //summons don't move slower if they have a running
 //animation with more frames MAYBE ???
 //TODO: Code other two chucklefucks
 //TODO: Jump to higher sectors, maybe?
 //TODO: Summons should pioritize monsters that are behind you.
 //TODO: If summons can't get to a target, should try to 
 //stand in front of it
 
 class TestMark1 : Actor
 {
 	default
 	{
 		+THRUACTORS
 		+NOGRAVITY
 	}
 
 	states
 	{
 		Spawn:
 			BON1 A 1;
 			loop;
 		Death:
 			TNT1 A 0;
 			stop;
 	}
 
 }
 
 class TestMark2 : TestMark1
 {
 	states
 	{
 		Spawn:
 			BON2 A 8;
 		Death:
 			BON2 A 1;
 			stop;
 	}
 }
 
 //for pathfinding
 struct NavSect
 {
 	//line between current and destination sector
 	Line transLine;
 
 	//pointer to destination sector
 	Sector s;
 
 	//dest sector height, or ceiling z - floor z
 	double height;
 
 	//step up or down
 	double deltaZ;
 
 	Vector2 mid;
 }
 
 
 class SummonBase : Actor
 {	
 	//linedef flags for pathfinding
 	const ML_BLOCKING			=	0x00000001;
 	const ML_BLOCKMONSTERS		=	0x00000002;
 	const ML_TWOSIDED			=	0x00000004;
 	const ML_BLOCKEVERYTHING	=	0x00008000;
 
 	const PF_IMPOSSIBLE			=	0;
 	const PF_CLOSERSECT			=	1;
 	const PF_STRAIGHTSHOT		=	2;
 
 	Actor attackTarget;
 	NavSect navGoal;
 	bool pathPlan;
 
 	//emotions!
 	int Anger, Frustration, Happiness;
 
 	//debug
 //	Actor Cmarker;
 //	Actor Fmarker;
 
 	
 	default
 	{
 		Health 400;
 		Speed 15;
 		Radius 16;
 		Height 56;
 		Mass 100;
 		Monster; //TODO: Pick and choose specific flags instead of using the Monster combo
 		-COUNTKILL
 		+FLOORCLIP
 		+THRUSPECIES
 		+DROPOFF
 		Species "Player";
 		DamageFactor "PlayerDamage", 0;
 	}
 
 	override void PostBeginPlay()
 	{
 		self.attackTarget = null;
 		self.Anger = 0;
 		self.Frustration = 0;
 		self.Happiness = 0;
 
 		self.pathPlan = false;
 
 
 		//test
 	//	Cmarker = spawn("TestMark1", pos);
 	//	Fmarker = spawn("TestMark1", pos);
 	}
 
 	override void Tick()
 	{
 		self.ManageEmotions();
 		self.ChooseTarget();
 		super.Tick();
 	}
 
 	//Choose target to attack
 	void ChooseTarget()
 	{
 		if (!master)
 			return;
 
 		let ownerx = DevilbunnyPlayer(master);
 
 		attackTarget = ownerx.summonTarget;
 	}
 
 
 	//TODO: Make this only work when actor's on the ground
 	void SMoveForward()
 	{
 		double move;
 		move = Speed / 5;
 
 		Thrust(move, Angle);	
 	}
 
 
 	//super advanced pathfinding go!
 	int PlanPath()
 	{		
 		//if it's in the same sector, run straight in
 		if (CurSector == attackTarget.CurSector)
 		{
 			return PF_STRAIGHTSHOT;
 		}
 
 		NavSect gsect;
 		//we're comparing the (possible) destination sector's distance from target
 		//to the summon's current distance from target. If it's shorter
 		//move to the destination sector
 		double targ_dist = (CurSector.centerSpot - attackTarget.Pos.xy).Length();
 
 		int plan = PF_IMPOSSIBLE;
 			
 		//check all sectors bordering this one's linedefs
 		for (int it = 0; it < CurSector.lines.Size(); ++it)
 		{
 			//coding this is so much more complicated than it should be
 			line l;
 			sector s;
 			double tdist;
 			Vector2 mid;
 			double h, dz;
 
 			l = CurSector.lines[it];
 
 			if (
 				(l.flags & ML_TWOSIDED) &&
 				!(l.flags & (ML_BLOCKING 
 					| ML_BLOCKEVERYTHING 
 					| ML_BLOCKMONSTERS))
 				)
 			{
 				//either the front or the back of this linedef
 				//should be the sector our summon is standing in
 				//so ignore it
 				if (l.backSector == CurSector)
 				{
 					s = l.frontSector;
 				}
 				else
 				{
 					s = l.backSector;
 				}
 
 				//debug
 	//			Vector3 sp;
 		//		sp.x = s.centerSpot.x;
 		//		sp.y = s.centerSpot.y;
 		//		sp.z = s.floorPlane.d;
 		//		spawn("TestMark2", sp);
 
 				tdist = (s.centerSpot - attackTarget.Pos.xy).Length();
 				mid = s.centerSpot;
 				//probably gets a little janky with sloped floors
 				h = s.ceilingPlane.ZatPoint(mid) - s.floorPlane.ZatPoint(mid);
 				dz = s.floorPlane.ZatPoint(mid) - curSector.floorPlane.ZatPoint(pos.xy);
 
 				//if ceiling is too low to run through
 				if (h < 64)
 				{
 					continue;
 				}
 				
 				//if it's elevated above the current sector
 				if (dz > 16)
 				{
 					continue;
 				}
 
 				//if it's in an adjacent (pathable) sector, just run right in
 				if (s == attackTarget.CurSector)
 				{
 					return PF_STRAIGHTSHOT;
 				}
 
 				//if this distance is lower than any other sector 
 				//checked (and the current distance between 
 				//the summon and the target) then this is the sector we 
 				//want to go to!
 
 				//"struct assignment not implemented yet"
 				//come onnnn, seriously??
 				if (tdist < targ_dist)
 				{
 					plan = PF_CLOSERSECT;
 					//I'm so mad about this
 					navGoal.transLine = l;
 					navGoal.s = s;
 					navGoal.height = h;
 					navGoal.deltaZ = dz;
 					navGoal.mid = mid;
 					//ugh
 				}
 			}
 		}
 		
 		//test
 //		if (plan == PF_CLOSERSECT)
 //		{
 //			Vector3 gp;
 //			gp.x = navGoal.mid.x;
 //			gp.y = navGoal.mid.y;
 //			gp.z = navGoal.s.floorPlane.ZatPoint(gp.xy);
 //			Cmarker.SetOrigin(gp, true);
 //			gp.z = navGoal.s.ceilingPlane.ZatPoint(gp.xy);
 //			Fmarker.SetOrigin(gp, true);
 //		}
 		//--
 
 		return plan;
 	}
 
 	void FacePoint(Vector2 point)
 	{
 		Vector2 offs = point - Pos.xy;
 		Angle = atan2(offs.y, offs.x);
 	}
 
 	void ChaseTarget(StateLabel attackstate = "Melee")
 	{
 		if (!attackTarget)
 			return;
 
 		if (Distance2D(attackTarget) < 130)
 		{
 			A_Face(attackTarget);
 			SetStateLabel(attackstate);
 			return;
 		}
 
 		//can't run around if in the air
 		if (!((pos.z <= floorz) || bOnMobj))
 			return;
 
 		int plan = PlanPath();
 
 		//A_Log(attackTarget.GetClassName() .. " | " .. plan .. " | CSec " .. CurSector.Index() .. " | TSec " .. attackTarget.CurSector.Index());
 
 		//if in the same sector as the target, run straight in
 		if (plan == PF_STRAIGHTSHOT)
 		{
 			A_Face(attackTarget);
 			SMoveForward();
 			return;
 		}
 		if (plan == PF_CLOSERSECT)
 		{
 			FacePoint(navGoal.mid);
 			SMoveForward();
 			return;
 		}
 		if (plan == PF_IMPOSSIBLE)
 			return; //TODO: Try to get between target and player
 
 	}
 
 	void ManageEmotions()
 	{
 		//GetPissed();
 		FindHappiness();
 		FindFrustration();
 	}
 
 	virtual void FindHappiness()
 	{	
 		if (master)
 		{
 			let owner1 = DevilbunnyPlayer(master);
 			if (Distance2D(owner1) <= 500)
 			{
 				if (owner1.hasArmorType == 0)
 				{
 					Happiness = 60;
 				}
 				else
 				{
 					Happiness = 40;
 				}
 			}
 			else
 			{
 				Happiness = 20;
 			}
 		}
 
 		HealThing(Happiness);
 	}
 
 	virtual void FindFrustration()
 	{
 		if (!attackTarget)
 		{
 			Frustration = 0;
 			return;	
 		}
 
 		Frustration += 1;
 	}
 }
 
 
 class ChuckleFuckOne : SummonBase
 {
 	void HammerAttack()
 	{
 		FTranslatedLineTarget t;
 		A_Face(attackTarget);
 		LineAttack(Angle, 130, Pitch, 90 + Happiness, "PlayerDamage", null, 0, t);
 		
 		if (t.linetarget)
 		{
 			Frustration -= 100;
 			if (Frustration < 0)
 			{
 				Frustration = 0;
 			}
 		}
 
 	}
 
 	states
 	{
 		Spawn:
 			CHK1 KL 60;
 		See:
 			CHK1 A 0
 			{
 				if(attackTarget)
 				{
 					SetStateLabel("Run");
 				}
 				else
 				{
 					if (!CheckIfCloser(master, 1024, false))
 					{
 						SetStateLabel("FindMaster");
 					}
 					if (!CheckIfCloser(master, 400))
 					{
 						SetStateLabel("Follow");
 					}
 		
 				}
 			}
 		Lookout:
 			CHK1 A 1 A_FaceMaster();
 			Goto See;
 		Run:
 			CHK1 BBBCCCDDDEEE 2 
 			{
 				ChaseTarget("Swing");
 				if (Frustration > 200)
 				{
 					SetStateLabel("FindMaster");
 					Frustration = 0;
 				}
 			}
 			goto See;
 		Follow:
 			CHK1 BBBCCCDDDEEE 2 
 			{
 				A_FaceMaster();
 				SMoveForward();
 			}
 			goto See;
 		FindMaster:
 			CHK1 KL 8 SetOrigin(master.pos, false);
 			Goto See;
 		Teleport:
 			CHK1 KL 8 SetOrigin(attackTarget.pos, false);
 			Goto See;
 		Swing:
 			CHK1 I 6
 			{
 				HammerAttack();
 			}
 			CHK1 J 6;
 			Goto See;
 		Death:
 			CHK1 FGH 8;
 			CHK1 H -1;
 			Stop;
 	
 	}
 		
 }
 
 class FuckDebris : Actor
 {
 	default
 	{
 		Radius 10;
 		Height 10;
 		+THRUACTORS
 	}
 
 	states
 	{
 		Spawn:
 			RBFI ABCDABCDABCDABCDABCDABCDABCDABCD 4;
 		Death:
 			TNT1 A 2;
 			stop;
 	}
 }
 
 class FuckArrow : Actor
 {
 	default
 	{
 		Radius 10;
 		Height 4;
 		Speed 40;
 		Damage 50;
 		Projectile;
 		DamageType "PlayerDamage";
 		Species "Player";
 		+ROLLSPRITE
 		+THRUSPECIES
 	}
 
 	states
 	{
 		Spawn:
 			RBIN ABCD 2;
 			loop;
 		Crash:
 		Death:
 		XDeath:
 			TNT1 A 2
 			{
 				A_Explode(400, 256);
 				for (int it = 0; it < 8; it++)
 				{
 					actor a;
 					a = spawn("FuckDebris", pos);
 					a.Vel.X = frandom(-10.0, 10.0);
 					a.Vel.Y = frandom(-10.0, 10.0);
 					a.Vel.Z = frandom(-10.0, 10.0);
 				}
 			}
 			stop;
 	}
 }
 
 class ChuckleFuckTwo : SummonBase
 {
 	states
 	{
 		Spawn:
 			CHK2 LM 60 A_FaceMaster;
 		See:
 			CHK2 A 0
 			{
 				if (!CheckIfCloser(master, 1024, false))
 				{
 					SetStateLabel("FindMaster");
 				}
 				if (!CheckIfCloser(master, 400))
 				{
 					SetStateLabel("Follow");
 				}
 				if (attackTarget)
 				{
 					if(CheckSight(attackTarget))
 					{	
 						SetStateLabel("Shoot");
 					}
 				}
 			}
 		Lookout:
 			CHK2 A 1;
 			goto See;
 		Follow:
 			CHK2 BBBCCCDDDEEE 2
 			{
 				A_FaceMaster();
 				SMoveForward();
 			}
 			goto See;
 		FindMaster:
 			CHK2 LM 8 SetOrigin(master.pos, false);
 			goto See;
 		Shoot:
 			CHK2 FFGGHHIJHIJHIJHIJ 4 A_Face(attackTarget);
 			CHK2 K 1
 			{
 				A_Face(attackTarget);
 				//TODO: hacky, should make a function for this
 				target = attackTarget; 
 				A_SpawnProjectile("FuckArrow", 50, 0, 0, CMF_TRACKOWNER);
 			}
 			CHK2 K 8;
 			goto See;
 		Death:
 			CHK2 NOP 8;
 			CHK2 P -1;
 			stop;
 
 			
 	}
 }
 
 class ChuckleFuckThree : SummonBase
 {
 	void AxeAttack()
 	{
 		FTranslatedLineTarget t;
 		A_Face(attackTarget);
 		LineAttack(Angle, 130, Pitch, 200 + Happiness, "PlayerDamage", null, 0, t);
 		
 		if (t.linetarget)
 		{
 			t.linetarget.Thrust(30, Angle);
 			Frustration -= 100;
 			if (Frustration < 0)
 			{
 				Frustration = 0;
 			}
 		}
 
 	}
 
 	states
 	{
 		Spawn:
 			CHK3 KL 60 A_FaceMaster;
 		See:
 			CHK3 A 0
 			{
 				if(attackTarget)
 				{
 					SetStateLabel("Run");
 				}
 				else
 				{
 					if (!CheckIfCloser(master, 1024, false))
 					{
 						SetStateLabel("FindMaster");
 					}
 					if (!CheckIfCloser(master, 400))
 					{
 						SetStateLabel("Follow");
 					}
 		
 				}
 			}
 		Lookout:
 			CHK3 A 1 A_FaceMaster();
 			Goto See;
 		Run:
 			CHK3 BBBCCCDDDEEE 2 
 			{
 				ChaseTarget("Swing");
 				if (Frustration > 200)
 				{
 					SetStateLabel("FindMaster");
 					Frustration = 0;
 				}
 			}
 			goto See;
 		Follow:
 			CHK3 BBBCCCDDDEEE 2 
 			{
 				A_FaceMaster();
 				SMoveForward();
 			}
 			goto See;
 		FindMaster:
 			CHK3 KL 8 SetOrigin(master.pos, false);
 			Goto See;
 		Teleport:
 			CHK3 KL 8 SetOrigin(attackTarget.pos, false);
 			Goto See;
 		Swing:
 			CHK3 F 8;
 			CHK3 G 10;
 			TNT1 A 0
 			{
 				AxeAttack();
 			}
 			CHK3 HIJ 4;
 			Goto See;
 		Death:
 			CHK3 MNO 8;
 			CHK3 O -1;
 			Stop;
 	}
 }
 
 Class SummonFireBall : Actor
 {
 	default
 	{
 		Radius 6;
 		Height 16;
 		Speed 20;
 		Damage 30;
 		Projectile;
 		+THRUSPECIES
 		Species "Player";
 		DamageType "PlayerDamage";
 	}
 	
 	states
 	{
 		Spawn:
 			BAL7 AB 4 Bright;
 			loop;
 		Death:
 			BAL7 CDE 6 Bright;
 			stop;
 	}
 }