bot_navmesh: m_isBlocked team check, avoidance obstacle penalty, class-aware JUMP cost, AVOID penalty, shortcut obstacle check, frustration memory

Author: pongo1231

rcbot2/bot_cvars.cpp

@@ -93,6 +93,7 @@ ConVar *rcbot_debug_navmesh = nullptr;
 ConVar *rcbot_navmesh_jump_obstacle_min = nullptr;
 ConVar *rcbot_navmesh_jump_obstacle_max = nullptr;
 ConVar *rcbot_navmesh_jump_obstacle_range = nullptr;
+ConVar *rcbot_navmesh_max_jump_height = nullptr;
 ConVar *rcbot_use_navmesh = nullptr;
 ConVar *rcbot_tf2_autoupdate_point_time = nullptr;
 ConVar *rcbot_tf2_payload_dist_retreat = nullptr;

rcbot2/bot_cvars.h

@@ -89,6 +89,7 @@ extern ConVar *rcbot_debug_navmesh;
 extern ConVar *rcbot_navmesh_jump_obstacle_min;
 extern ConVar *rcbot_navmesh_jump_obstacle_max;
 extern ConVar *rcbot_navmesh_jump_obstacle_range;
+extern ConVar *rcbot_navmesh_max_jump_height;
 extern ConVar *rcbot_use_navmesh;
 extern ConVar *rcbot_tf2_autoupdate_point_time;
 extern ConVar *rcbot_tf2_payload_dist_retreat;

rcbot2/bot_cvars_register.cpp

@@ -165,6 +165,7 @@ void RCBOT2_Cvar_Register(ICvar *cvar)
 	rcbot_navmesh_jump_obstacle_min = new ConVar("rcbot_navmesh_jump_obstacle_min", "18", 0, "Min obstacle height to trigger a preemptive jump");
 	rcbot_navmesh_jump_obstacle_max = new ConVar("rcbot_navmesh_jump_obstacle_max", "72", 0, "Max obstacle height to trigger a preemptive jump");
 	rcbot_navmesh_jump_obstacle_range = new ConVar("rcbot_navmesh_jump_obstacle_range", "160", 0, "Max distance at which to preemptively jump obstacles");
+	rcbot_navmesh_max_jump_height = new ConVar("rcbot_navmesh_max_jump_height", "72", 0, "Baseline max jump height for non-enhanced classes in navmesh A*");
 
 	rcbot_use_navmesh = new ConVar("rcbot_use_navmesh", "1", 0, "");
 
@@ -369,6 +370,8 @@ void RCBOT2_Cvar_Unlink(ICvar *cvar)
 		cvar->UnregisterConCommand(rcbot_navmesh_jump_obstacle_max);
 	if (rcbot_navmesh_jump_obstacle_range)
 		cvar->UnregisterConCommand(rcbot_navmesh_jump_obstacle_range);
+	if (rcbot_navmesh_max_jump_height)
+		cvar->UnregisterConCommand(rcbot_navmesh_max_jump_height);
 	if (rcbot_use_navmesh)
 		cvar->UnregisterConCommand(rcbot_use_navmesh);
 	if (rcbot_tf2_autoupdate_point_time)
@@ -573,6 +576,8 @@ void RCBOT2_Cvar_Unregister()
 	rcbot_navmesh_jump_obstacle_max = nullptr;
 	delete rcbot_navmesh_jump_obstacle_range;
 	rcbot_navmesh_jump_obstacle_range = nullptr;
+	delete rcbot_navmesh_max_jump_height;
+	rcbot_navmesh_max_jump_height = nullptr;
 	delete rcbot_use_navmesh;
 	rcbot_use_navmesh = nullptr;
 	delete rcbot_tf2_autoupdate_point_time;

rcbot2/bot_navmesh.cpp

@@ -282,6 +282,8 @@ void CNavMeshAccessor::scanGrid()
 	}
 
 	detectConnectOffset();
+	detectBlockedOffset();
+	detectAvoidanceObstacleOffset();
 
 	m_teleportLinks.clear();
 
@@ -488,6 +490,67 @@ bool CNavMeshAccessor::detectConnectOffset()
 	return false;
 }
 
+// m_isBlocked[2] is at offset 0x36 (54) in the SDK CNavAreaCriticalData struct.
+// The accessor adds +4 for the vtable, so the arena-space offset is 0x3A (58).
+// per the SDK comment [7/24/2008 tom], so it should be stable across engine builds.
+bool CNavMeshAccessor::detectBlockedOffset()
+{
+	m_iBlockedOffset = -1;
+	if (m_Areas.size() < 4) return false;
+	int good = 0;
+	for (int s = 0; s < 8 && (size_t)s < m_Areas.size(); s++)
+	{
+		unsigned char *area = m_Areas[s];
+		if (!area) continue;
+		unsigned char b0 = *(unsigned char*)(area + 0x3A);
+		unsigned char b1 = *(unsigned char*)(area + 0x3B);
+		if ((b0 <= 1) && (b1 <= 1))
+			good++;
+	}
+	if (good >= 4)
+	{
+		m_iBlockedOffset = 0x3A;
+		return true;
+	}
+	return false;
+}
+
+// m_avoidanceObstacleHeight is a float at the end of CNavArea's non-critical
+// data. The exact offset varies between builds, so we probe a range.
+bool CNavMeshAccessor::detectAvoidanceObstacleOffset()
+{
+	m_iAvoidanceObstacleOffset = -1;
+	if (m_Areas.size() < 4) return false;
+
+	const int kMinOff = 0xA8, kMaxOff = 0x2FC;
+	int bestOff = -1;
+	float bestScore = 0.0f;
+
+	for (int off = kMinOff; off <= kMaxOff; off += 4)
+	{
+		int zeroCnt = 0, posCnt = 0;
+		for (int s = 0; s < 16 && (size_t)s < m_Areas.size(); s++)
+		{
+			unsigned char *area = m_Areas[s];
+			if (!area) continue;
+			float v = *(float*)(area + off);
+			if (!(v >= 0.0f && v <= 4096.0f)) { zeroCnt = posCnt = -99; break; }
+			if (v == 0.0f) zeroCnt++;
+			else if (v > 0.0f) posCnt++;
+		}
+		if (zeroCnt < 0) continue;
+		float score = (float)zeroCnt * 0.5f + (float)posCnt * 1.5f;
+		if (score > bestScore) { bestScore = score; bestOff = off; }
+	}
+
+	if (bestOff >= 0 && bestScore >= 10.0f)
+	{
+		m_iAvoidanceObstacleOffset = bestOff;
+		return true;
+	}
+	return false;
+}
+
 unsigned char *CNavMeshAccessor::getAreaByIndex(int i) const
 {
 	if (i < 0 || i >= (int)m_Areas.size()) return nullptr;
@@ -726,6 +789,75 @@ bool CNavMeshNavigator::workRoute(Vector vFrom, Vector vTo, bool *bFail,
 				float stepCost = dx * dx + dy * dy + dz * dz;
 				if (nCenter[2] < vCurCenter.z - 128.0f)
 					stepCost += (vCurCenter.z - nCenter[2]) * (vCurCenter.z - nCenter[2]) * 3.0f;
+
+				// --- Blocked-area check (team-specific) ---
+				{
+					int blkOff = m_pAccessor->getBlockedOffset();
+					if (blkOff >= 0)
+					{
+						int team = m_pBot ? m_pBot->getTeam() : 0;
+						if (team >= 0 && team < 2)
+						{
+							unsigned char blocked = *(unsigned char*)((unsigned char*)neighbor + blkOff + team);
+							if (blocked) continue;
+						}
+					}
+				}
+
+				// --- Avoidance-obstacle penalty ---
+				{
+					int obsOff = m_pAccessor->getAvoidanceObstacleOffset();
+					if (obsOff >= 0)
+					{
+						float obsH = *(float*)((unsigned char*)neighbor + obsOff);
+						if (obsH > 0.0f && obsH <= 512.0f)
+							stepCost += obsH * 10.0f;
+					}
+				}
+
+				// --- Class-aware JUMP connection cost ---
+				int curAttr = *(int *)((unsigned char *)current + NAV_M_ATTR);
+				if (curAttr & NAV_ATTR_JUMP)
+				{
+					float zDelta = fabsf(nCenter[2] - vCurCenter.z);
+					float maxJump = 72.0f; // default baseline
+					float enhCostMul = 2.0f;
+					if (m_pBot && m_pBot->isTF2())
+					{
+						CBotTF2 *pTF2 = (CBotTF2 *)m_pBot;
+						int tfClass = pTF2->getClass();
+						if (tfClass == TF_CLASS_SCOUT)
+							maxJump = 108.0f;
+						else if (tfClass == TF_CLASS_SOLDIER && pTF2->getHealthPercent() > 0.5f)
+							maxJump = 128.0f;
+						else if (tfClass == TF_CLASS_DEMOMAN && rcbot_demo_jump && rcbot_demo_jump->GetInt())
+						maxJump = 128.0f;
+					else
+					{
+						if (rcbot_navmesh_max_jump_height)
+							maxJump = rcbot_navmesh_max_jump_height->GetFloat();
+							extern ConVar *rcbot_navmesh_max_jump_height;
+							if (rcbot_navmesh_max_jump_height)
+								maxJump = rcbot_navmesh_max_jump_height->GetFloat();
+						}
+					}
+					if (zDelta > maxJump)
+						continue; // too high for this class
+					if (zDelta > 72.0f)
+						stepCost *= (zDelta / 72.0f) * enhCostMul;
+				}
+
+				// --- NAV_MESH_AVOID penalty ---
+				if (curAttr & NAV_MESH_AVOID)
+					stepCost *= 2.0f;
+
+				// --- Frustration penalty ---
+				{
+					auto fit = m_mapAreaFrustration.find(neighbor);
+					if (fit != m_mapAreaFrustration.end() && fit->second > 0.01f)
+						stepCost *= (1.0f + fit->second);
+				}
+
 				float tentativeG = gScore[current] + stepCost;
 
 				auto gIt = gScore.find(neighbor);
@@ -1083,6 +1215,19 @@ void CNavMeshNavigator::optimizePath()
 			if (!isPotentiallyTraversable(posA, posC))
 				continue;
 
+			// Obstacle check: trace from waist height A→C.
+			// If a vertical obstacle sits between them, this shortcut would
+			// pass through a crate or low wall — reject.
+			{
+				CTraceFilterWorldAndPropsOnly trF;
+				Vector vTraceA = posA + Vector(0,0,18);
+				Vector vTraceC = posC + Vector(0,0,18);
+				CBotGlobals::traceLine(vTraceA, vTraceC, MASK_PLAYERSOLID, &trF);
+				trace_t *tr = CBotGlobals::getTraceResult();
+				if (tr && tr->fraction < 0.75f && tr->plane.normal.z < 0.5f)
+					continue;
+			}
+
 			// Remove node B at index i-1
 			m_route.erase(m_route.begin() + (i - 1));
 			removed = true;
@@ -1269,6 +1414,22 @@ bool CNavMeshNavigator::hasNextPoint() { return !m_route.empty(); }
 void CNavMeshNavigator::updatePosition()
 {
 	if (!m_pBot) return;
+
+	// Frustration decay: reduce all area frustration scores by 10% per frame.
+	// Prune entries that have decayed below 0.01.
+	{
+		auto it = m_mapAreaFrustration.begin();
+		while (it != m_mapAreaFrustration.end())
+		{
+			it->second *= 0.9f;
+			if (it->second < 0.01f)
+				it = m_mapAreaFrustration.erase(it);
+			else
+				++it;
+		}
+	}
+
+	if (!m_pAccessor || !m_pAccessor->ready()) { freeMapMemory(); return; }
 	if (!m_pAccessor || !m_pAccessor->ready()) { freeMapMemory(); return; }
 
 	// Phase 1: Escape mode (handles its own early-return if active)
@@ -1420,6 +1581,14 @@ void CNavMeshNavigator::updatePosition()
 							else
 							{
 								m_iConsecutiveHits++;
+								// Frustration memory: when stuck hitting walls in this area,
+								// increment its cost for future A* searches.
+								if (m_iConsecutiveHits >= 8 && m_pCurrentArea)
+								{
+									float &scr = m_mapAreaFrustration[m_pCurrentArea];
+									scr += 1.0f;
+									if (scr > 5.0f) scr = 5.0f;
+								}
 								if (m_iConsecutiveHits >= 60)
 								{
 									void *stuckDst = (!m_route.empty()) ? m_route.back().area : nullptr;

rcbot2/bot_navmesh.h

@@ -31,6 +31,7 @@
 #define NAV_ATTR_RUN     0x00000020 // NAV_MESH_RUN
 #define NAV_ATTR_WALK    0x00000040 // NAV_MESH_WALK
 #define NAV_ATTR_STAIRS  0x00001000 // NAV_MESH_STAIRS
+#define NAV_MESH_AVOID  0x00000080 // NAV_MESH_AVOID — avoid unless no alternative
 
 // TF2-specific nav attributes (CTFNavArea subclass, offset 0x1C4)
 #define TF_NAV_ATTR_OFFSET  0x1C4  // CTFNavArea::m_attributeFlags
@@ -81,7 +82,7 @@ class CNavMeshAccessor : public CSignatureFunction
 {
   public:
 	CNavMeshAccessor() : m_pNavMesh(nullptr), m_nAreaCount(0), m_bReady(false), m_pBase(nullptr),
-		m_connectOffset(-1), m_areaMin(0), m_areaMax(0) {}
+		m_connectOffset(-1), m_iBlockedOffset(-1), m_iAvoidanceObstacleOffset(-1), m_areaMin(0), m_areaMax(0) {}
 	~CNavMeshAccessor() {}
 
 	void init(class CRCBotKeyValueList &kv, void *pBase);
@@ -92,6 +93,7 @@ class CNavMeshAccessor : public CSignatureFunction
 	inline void *getBase() { return m_pBase; }
 	int  getAreaCount() const { return m_nAreaCount; }
 	void invalidate() { m_Areas.clear(); m_nAreaCount = 0; m_bReady = false; m_connectOffset = -1;
+		m_iBlockedOffset = -1; m_iAvoidanceObstacleOffset = -1;
 		m_areaMin = 0; m_areaMax = 0; m_failedGoals.clear(); m_teleportLinks.clear(); }
 	unsigned char *getNearestArea(float x, float y, float z);
 	unsigned char *getNearestArea(Vector v) { return getNearestArea(v.x, v.y, v.z); }
@@ -103,6 +105,8 @@ class CNavMeshAccessor : public CSignatureFunction
 	// CNavArea, detected at runtime (the layout differs between game builds).
 	// Returns -1 if detection failed (navmesh should then stay inert).
 	int  getConnectOffset() const { return m_connectOffset; }
+	int  getBlockedOffset() const { return m_iBlockedOffset; }
+	int  getAvoidanceObstacleOffset() const { return m_iAvoidanceObstacleOffset; }
 	// True if p is one of the cached nav area pointers (O(log n)).
 	bool areaKnown(const void *p) const;
 
@@ -129,13 +133,17 @@ class CNavMeshAccessor : public CSignatureFunction
 
   private:
 	bool detectConnectOffset();
+	bool detectBlockedOffset();
+	bool detectAvoidanceObstacleOffset();
 
 	void *m_pNavMesh;
 	void *m_pBase;
 	std::vector<unsigned char *> m_Areas; // sorted+unique after scanGrid()
 	int  m_nAreaCount;
 	bool m_bReady;
 	int  m_connectOffset;
+	int  m_iBlockedOffset;
+	int  m_iAvoidanceObstacleOffset;
 	uintptr_t m_areaMin; // min/max cached area pointer = heap arena span
 	uintptr_t m_areaMax;
 	std::map<const void *, float> m_failedGoals; // goal area → clear time (180–600 s)
@@ -327,6 +335,10 @@ class CNavMeshNavigator : public IBotNavigator
 	float  m_tnPhaseStartTime;   // when current phase began
 	Vector m_vTnExploreStart;    // position where explore phase started
 	float  m_fTnExploreRadius;   // how far we've covered from explore start
+
+	// Per-area frustration scores: increment when bot repeatedly hits walls
+	// in an area, decay per frame. Used as A* cost multiplier.
+	std::map<void*, float> m_mapAreaFrustration;
 };
 
 // ---------- CNavMeshAccessor ----------