ZDoom

Spoiler:

---

ZScript: ID_Point marker in a sector

Code: Select all

// ID_Point marker in (ZDoom) center of sector
class ID_Point : Actor
{
	Default
	{
		+FLATSPRITE
	}
	
	States
	{
	Spawn:
		APLS B -1;
		Stop;
	}
}

flank()

Code: Select all

	void flank(float distance)
	{
		Actor mo;
		int x, y, z;
		vector2 v2;
		vector3 v3;
		ID_Point idpoint;

		MonsterFinder.Reinit();
		while (mo = Actor(MonsterFinder.Next()))
		{
			if (mo.bIsMonster && mo.args[MOFLAG] != 0 && mo.InStateSequence(mo.CurState, mo.ResolveState("See")))
			{
				float pldist = mo.Distance2D(player.mo);
				if (pldist <= distance)
				{
					int floorZ = mo.pos.z;
					ID_Point ptr;

					ID_PointFinder.Reinit();
					while (idpoint = ID_Point(ID_PointFinder.Next())) // find the first sector point farther away than the player
					{
						float modist = mo.Distance2D(idpoint);
						float va_player = VectorAngle(mo.pos.x - player.mo.pos.x, mo.pos.y - player.mo.pos.y);
						float va_idpoint = VectorAngle(mo.pos.x - idpoint.pos.x, mo.pos.y - idpoint.pos.y);
						if ((va_player < 0 && va_idpoint < 0) || (va_player > 0 && va_idpoint > 0) && modist > pldist)
						{
							double idangle = abs(player.mo.AngleTo(idpoint));
							if (idangle < 80 || idangle > 100) // flank
							{
								ptr = idpoint;
								break;
							}
						}
					}
					if (ptr) // a sector point was found to move toward
					{
						x = ptr.pos.x > mo.pos.x ? 1 : -1;
						y = ptr.pos.y > mo.pos.y ? 1 : -1;
						v2 = (mo.pos.x + x, mo.pos.y + y);
						v3 = (mo.pos.x + x, mo.pos.y + y, ptr.GetZAt(mo.pos.x + x, mo.pos.y + y, 0, GZF_ABSOLUTEPOS));

						if (mo.CheckMove(v2))
						{
							mo.SetOrigin(v3, true);
							mo.A_SetRenderStyle(0.5, STYLE_Add);
						}
					}
					else
					{
						mo.A_SetRenderStyle(1.0, STYLE_Normal);
					}
				}
			}
			else
			{
				if (mo.bIsMonster && mo.args[MOFLAG] != 0 && !mo.InStateSequence(mo.CurState, mo.ResolveState("See")))
				{
					mo.A_SetRenderStyle(1.0, STYLE_Normal);
				}
			}
		}
	}

Spoiler:

---

Just an update. Interesting problem.

It seems to me after reviewing AI mods that the path finding hinges on monsters being dormant traveling between points. In a battle soldiers are hardly this. They may run to the flank while keeping one eye out for the enemy. To keep the monster active means overriding the Doom AI to some extent, which thus far leads to jittering. Just an observation as I've looked at this.

The "CenterSpot" of a sector is the center of the block map, apparently, and I'm unable to find a way given the shapes of sectors to produce anything other than a crude approximation of a centroid for now. Interestingly, not that much different from the blockmap center.

Code: Select all

	vector2 polygonCentroid(Sector sec)
	{
		// approximation adding up points and dividing by n
		float X = 0;
		float Y = 0;
		int i = 0;
		while (i < sec.Lines.Size())
		{
			int v1x = int(sec.Lines[i].V1.P.x);
			int v1y = int(sec.Lines[i].V1.P.y);

			int v2x = int(sec.Lines[i].V2.P.x);
			int v2y = int(sec.Lines[i].V2.P.y);
			float a = v1x * v2y - v2x * v1y;
			X += v1x + v2x;
			Y += v1y + v2y;
			
			i += 2;
		}
		X /= sec.Lines.Size();
		Y /= sec.Lines.Size();

		return (int(X), int(Y));
	}

The geometry of Doom is also interesting, since most angles are calculated on the game grid itself. So the above method of finding direction to the player works great if both are in a N-S orientation. I've changed this to a simpler approach where the monster chooses the closest point between itself and the player, so they close on all sides. This isn't quite flanking, of course.

• A thinker searches for monsters that are flankers in a See state within a certain radius of the player
• If a monster has already targeted a sector ID_Point, it keeps going unless it's flanking the player
• If a monster isn't targeting a sector ID_Point, it looks for one between itself and the player, preferring those that flank the player

	void flank(float distance)
	{
		ThinkerIterator MonsterFinder;
		ThinkerIterator ID_PointFinder;
		MonsterFinder = ThinkerIterator.Create("Actor");
		ID_PointFinder = ThinkerIterator.Create("ID_Point");

		Actor mo;
		int x, y, z;
		vector2 v2;
		vector3 v3;
		ID_Point idpoint;

		MonsterFinder.Reinit();
		while (mo = Actor(MonsterFinder.Next()))
		{
			if (mo.bIsMonster && mo.args[MOFLAG] == 1)
			{
				if (!mo.InStateSequence(mo.CurState, mo.ResolveState("See")))
				{
					mo.args[FLSTATUS] = 0;
					mo.A_SetRenderStyle(1.0, STYLE_Normal);
				}
				else
				{
					if (mo.args[FLSTATUS] > 0) // still on target
					{
						mo.A_FaceMovementDirection(0, 0, 0, FMDF_INTERPOLATE);

						if (mo.CheckIfTargetInLOS())
						{
							double fAngle = mo.AbsAngle(mo.AngleTo(player.mo),mo.angle);
							if (fAngle < 45 || (fAngle > 135 && fAngle < 225) || fAngle > 315)
							{
								mo.args[FLSTATUS] = 0;
							}
						}
						else
						{
							mo.args[FLSTATUS]--;
						}
						if (mo.args[FLSTATUS] == 0)
						{
							mo.bNOTARGETSWITCH = false;
							mo.target = null;
							mo.A_Face(player.mo);
						}
					}
					else // find new target
					{
						float pldist = mo.Distance2D(player.mo);
						if (pldist < distance)
						{
							float nearest = distance;

							ID_Point ptr = null;
							ID_PointFinder.Reinit();
							while (idpoint = ID_Point(ID_PointFinder.Next()))
							{
								// z height that is reachable
								if ((idpoint.floorz > mo.floorz && (idpoint.floorz - mo.floorz) >= mo.maxstepheight)
								|| (idpoint.floorz < mo.floorz && (mo.floorz - idpoint.floorz) <= mo.maxdropoffheight)
								|| (idpoint.floorz == mo.floorz) && mo.isVisible(idpoint, true))
								{
									// always move closer to player
									float iddist = player.mo.Distance2D(idpoint);
									float modist = mo.Distance2D(idpoint);

									if (modist < nearest && iddist < pldist)
									{
										ptr = idpoint;
										nearest = pldist;

										double fAngle = player.mo.AbsAngle(player.mo.AngleTo(idpoint),player.mo.angle);
										if (fAngle < 45 || (fAngle > 135 && fAngle < 225) || fAngle > 315)
										{
											break; // always flank
										}
									}
								}
							}
							if (ptr) // a sector point was found to move toward
							{
								mo.target = ptr;
								mo.bNOTARGETSWITCH = true;
								mo.args[FLSTATUS] = 5; // stay on this target x5
								mo.A_SetRenderStyle(1.0, STYLE_Shadow);

								int steps = 5;
								while (steps--)
								{
									x = mo.pos.x + (mo.pos.x == ptr.pos.x ? 0 : mo.pos.x > ptr.pos.x ? Random(-1,-2) : Random(1,2));
									y = mo.pos.y + (mo.pos.y == ptr.pos.y ? 0 : mo.pos.y > ptr.pos.y ? Random(-1,-2) : Random(1,2));

									v2 = (x, y);
									if (ptr.floorz <= mo.floorz)
									{
										v3 = (x, y, mo.floorz); // drop off
									}
									else
									{
										v3 = (x, y, ptr.GetZAt(x, y, 0, GZF_ABSOLUTEPOS)); // climb
									}

									if (mo.CheckPosition(v2))
									{
										mo.A_StartSound("breath", CHAN_AUTO, CHANF_OVERLAP, 0.5, ATTN_STATIC);
										mo.SetOrigin(v3, true);
										mo.A_FaceMovementDirection(0, 0, 0, FMDF_INTERPOLATE);
									}
								}
							}
						}
					}
				}
			}
		}
	}

Enjay wrote:It took me a while to figure out what was going on until I re-read the description. It seems to be doing much as you described (including the health warnings about getting stuck etc).

I noticed a couple of warnings on startup:

Code: Select all

Script warning, "flankers.pk3:flankers_events.zs" line 142:
Truncation of floating point value
Script warning, "flankers.pk3:flankers_events.zs" line 143:
Truncation of floating point value

openroadracer wrote:I just have to ask: How does this mod interact with this other AI Enhancer mod, if at all?

I wonder how having enemies that can intelligently chase and hunt the player would interact with having enemies that intelligently flank the player would work...

Hey Doomer wrote:

openroadracer wrote:I just have to ask: How does this mod interact with this other AI Enhancer mod, if at all?

I wonder how having enemies that can intelligently chase and hunt the player would interact with having enemies that intelligently flank the player would work...

I think these will be compatible, because I'm taking a different approach and modifying different behavior. Testing will tell.

openroadracer wrote:

Hey Doomer wrote:

openroadracer wrote:I just have to ask: How does this mod interact with this other AI Enhancer mod, if at all?

I wonder how having enemies that can intelligently chase and hunt the player would interact with having enemies that intelligently flank the player would work...

I think these will be compatible, because I'm taking a different approach and modifying different behavior. Testing will tell.

Guess I'll just have to download this and let you know how it goes, then. Any suggestions on relative load order?

					if (mo.CurState == mo.ResolveState("See"))
					{
						ID_Point ptr = findtarget(mo, player.mo, distance);
						if (ptr)
						{
							flankon(mo, ptr);
							seekflank(mo, ptr);
						}
					}

Spoiler:

---

Screenshot_Doom_20211218_095245-576x324.png

Screenshot_Doom_20211218_125145-20x11.png

• Decided to keep CenterSpot after testing various centroid calculations, most of which aren't any better with an irregular polygon
• Made the movement code less random and now factored around getting closer to the target
• Cleaned up target point selection, although I'm still having trouble up and down stairs. Not sure Distance3D is accurate.
• Completely rewrote flank test to use CheckLOF by casting rays to see if the monster can be seen between angles
• Added menu settings
• Added a debug mode that shows the sector points as well as a flanking camera view

					else if (mo.CurState == mo.ResolveState("See"))
					{
						ID_Point ptr = findtarget(mo, player.mo);
						if (ptr)
						{
							flankon(mo, ptr);
						}
					}

• Since a monster is "targeting" an ID_Point, using A_Chase(). This bypasses movement code although still having trouble with some stairs.
• Swapped out ray tracing flank detection with an angle comparison (much cleaner):

  Spoiler:

  ---

  Code: Select all

  		double plnorm = Actor.Normalize180(player.mo.angle);
  		double mAngle = VectorAngle(mo.pos.x - player.mo.pos.x, mo.pos.y - player.mo.pos.y);
  		double dAngle = abs(NormalizeAngle(plnorm - mAngle));
  
  		if (dAngle > fl_Angle)
  		{
  			if (fl_debug && mo.GetSpecies() != "ID_Point")
  			{
  				player.mo.SetCamera(mo);
  				console.printf("player va: %f, angle to mo: %f, delta: %f", plnorm, mAngle, NormalizeAngle(plnorm - mAngle));
  			}
  			return true;
  		}
  		else
  		{
  			if (fl_debug && mo.GetSpecies() != "ID_Point")
  			{
  				player.mo.SetCamera(player.mo);
  			}
  			return false;
  		}
  

• Simplified the flanking action.

  Spoiler:

  ---

  Code: Select all

  		while (mo = Actor(MonsterFinder.Next()))
  		{
  			if (mo.bIsMonster && mo.args[MOFLAG] == 1)
  			{
  				if (mo.Distance2D(player.mo) < distance)
  				{
  					if (mo.args[FLSTATUS] == 1)
  					{
  						mo.A_Chase();
  						if (isflanked(mo))
  						{
  							flankoff(mo);
  						}
  					}
  					else if (mo.CurState == mo.ResolveState("See"))
  					{
  						ID_Point ptr = findflank(mo, player.mo);
  						if (ptr)
  						{
  							flankon(mo, ptr);
  						}
  					}
  				}
  				else // out of flanking range!
  				{
  					flankoff(mo);
  				}
  			}
  		}
  

• Choose flanking ID_Points over anything else.
• Added menu options for different center finding techniques (there are now three).

• CenterSpot - a GZDoom sector property (blockmap center)
• Centroid - a simple average of all vectors
• CenterOfMass - average of center of all triangles defined by the sector

inkoalawetrust wrote:Any chance that you could make this and the Ambushers script also work when two NPCs are fighting each other (e.g a friendly NPC fighting hostile NPCs). Instead of only working with NPCs fighting the player(s) specifically ? Would also be useful if these two scripts could be toggled on a per-monster basis instead of universally applying on all NPCs.

I've also noticed a weird bug with the Ambushers script specifically, when I started it up on E1M1 a few times. It seems to cause some monster to move around while only running the first frame of their See state. While also making their sight sound every time they move.