Enable attacks on foes visible through shared LOS

Adds a baseRange parameter to parabolic queries providing simple
2D detection alongside parabolic detection.
StandGround and Chase stances now use full attack parabolic range
with vision range as baseRange, allowing units to attack enemies
visible through friendly vision.

binaries/data/mods/public/simulation/components/Attack.js

@@ -271,17 +271,21 @@ Attack.prototype.CanAttack = function(target, wantedTypes)
 	if (!cmpTargetPlayer || !cmpEntityPlayer)
 		return false;
 
+	// Must be visible or miraged / with retainInFog flag, not completely hidden
+	const cmpRangeManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_RangeManager);
+	if (cmpRangeManager)
+	{
+		const visibility = cmpRangeManager.GetLosVisibility(target, cmpEntityPlayer.GetPlayerID());
+		if (visibility == "hidden")
+			return false;
+	}
+
 	const types = this.GetAttackTypes(wantedTypes);
 	const entityOwner = cmpEntityPlayer.GetPlayerID();
 	const targetOwner = cmpTargetPlayer.GetPlayerID();
 	const cmpCapturable = QueryMiragedInterface(target, IID_Capturable);
 	const cmpDiplomacy = QueryPlayerIDInterface(entityOwner, IID_Diplomacy);
 
-	// Check if the relative height difference is larger than the attack range
-	// If the relative height is bigger, it means they will never be able to
-	// reach each other, no matter how close they come.
-	const heightDiff = Math.abs(cmpThisPosition.GetHeightOffset() - cmpTargetPosition.GetHeightOffset());
-
 	for (const type of types)
 	{
 		if (type != "Capture" && (!cmpDiplomacy?.IsEnemy(targetOwner) || !cmpHealth || !cmpHealth.GetHitpoints()))
@@ -290,7 +294,8 @@ Attack.prototype.CanAttack = function(target, wantedTypes)
 		if (type == "Capture" && (!cmpCapturable || !cmpCapturable.CanCapture(entityOwner)))
 			continue;
 
-		if (heightDiff > this.GetRange(type).max)
+		// Check if the target is currently in range, or could ever be reached
+		if (!this.IsTargetInRange(target, type) && !this.CanEverReachTarget(target, type))
 			continue;
 
 		const restrictedClasses = this.GetRestrictedClasses(type);
@@ -304,6 +309,77 @@ Attack.prototype.CanAttack = function(target, wantedTypes)
 	return false;
 };
 
+/**
+ * Check if the target could potentially ever be reached with the given attack type,
+ * as an optimistic estimate. This assumes the attacker can move to the closest
+ * possible position to the target — ignoring obstructions and terrain features
+ * (e.g., hills) that might help or hinder.
+ *
+ * This is a best-effort guess:
+ *  - It may return true even when the target is actually unreachable (e.g., turreted
+ *    units on walls with a height offset too large for the projectile to overcome).
+ *  - It may return false even when the target is reachable (e.g., a nearby hill could
+ *    provide enough elevation to hit a "too high" target, but we don't check for that).
+ *
+ * Currently these checks are mostly useful to determine if we can reach turreted units
+ * (e.g. on a wall, outpost...).
+ *
+ * @param {number} targetId - The target entity ID.
+ * @param {string} type - The attack type.
+ * @return {boolean} - Whether the target is estimated to be reachable (see caveats above).
+ */
+Attack.prototype.CanEverReachTarget = function(targetId, type)
+{
+	const cmpThisPosition = Engine.QueryInterface(this.entity, IID_Position);
+	const cmpTargetPosition = Engine.QueryInterface(targetId, IID_Position);
+
+	const thisHeightOffset = cmpThisPosition.GetHeightOffset();
+	const targetHeightOffset = cmpTargetPosition.GetHeightOffset();
+
+	const range = this.GetRange(type);
+
+	// Find the closest horizontal distance we could ever get to the target.
+	// We first determine the closest horizontal distance we could ever get to the target,
+	// accounting for turreted units inside buildings:
+	//  - If the building blocks movement, we can only reach its exterior edge.
+	//  - If the building is passable, we can walk right up to the turret point.
+	const cmpTurretable = Engine.QueryInterface(targetId, IID_Turretable);
+	const holderId = cmpTurretable?.HolderID();
+	let closestDistance = 0;
+	if (holderId && holderId != INVALID_ENTITY)
+	{
+		const cmpTurretHolder = Engine.QueryInterface(holderId, IID_TurretHolder);
+		if (cmpTurretHolder)
+		{
+			const turretPoint = cmpTurretHolder.GetOccupiedTurretPoint(targetId);
+			closestDistance = cmpTurretHolder.GetClosestApproachDistanceToTurretPoint(turretPoint);
+		}
+	}
+
+	if (!range.parabolic)
+	{
+		// For non-parabolic attacks (e.g., "Melee" attack type), we check if the height offset
+		// is within max range at the closest possible horizontal distance (simple 3D distance check).
+		const heightDiff = Math.abs(targetHeightOffset - thisHeightOffset);
+		return Math.sqrt(closestDistance * closestDistance + heightDiff * heightDiff) <= range.max;
+	}
+
+	// For parabolic attacks (generally "Ranged" attack type), we use the parabolic formula
+	// to determine if the height offset is surmountable at the closest possible distance.
+	// Typical scenario: units on walls/towers may be unreachable if the attacker's
+	// projectiles can't arc high enough, even at point-blank range.
+	const cmpRangeManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_RangeManager);
+	if (!cmpRangeManager)
+		return true;
+
+	const yOrigin = this.GetAttackYOrigin(type);
+
+	const maxReachableHeightDiff = cmpRangeManager.GetMaxReachableParabolicHeight(
+		range.max, yOrigin, closestDistance);
+
+	return targetHeightOffset - thisHeightOffset <= maxReachableHeightDiff;
+};
+
 /**
  * Returns undefined if we have no preference or the lowest index of a preferred class.
  */
@@ -338,12 +414,14 @@ Attack.prototype.GetPreference = function(target)
  */
 Attack.prototype.GetFullAttackRange = function()
 {
-	const ret = { "min": Infinity, "max": 0 };
+	const ret = { "min": Infinity, "max": 0, "parabolic": false };
 	for (const type of this.GetAttackTypes())
 	{
 		const range = this.GetRange(type);
 		ret.min = Math.min(ret.min, range.min);
 		ret.max = Math.max(ret.max, range.max);
+		if (range.parabolic)
+			ret.parabolic = true;
 	}
 	return ret;
 };
@@ -460,7 +538,39 @@ Attack.prototype.GetRange = function(type)
 	let min = +(this.template[type].MinRange || 0);
 	min = ApplyValueModificationsToEntity("Attack/" + type + "/MinRange", min, this.entity);
 
-	return { "max": max, "min": min };
+	return {
+		"max": max,
+		"min": min,
+		"parabolic": type === "Ranged"
+	};
+};
+
+/**
+ * Get the effective range for attacking a specific target, accounting
+ * for elevation and projectile physics where applicable.
+ * @param {number} target - The target entity ID.
+ * @param {string} type - The attack type.
+ * @return {{ min: number, max: number }} - The min and max effective range.
+ */
+Attack.prototype.GetEffectiveAttackRange = function(target, type)
+{
+	const range = this.GetRange(type);
+
+	// Only Parabolic attacks get parabolic elevation adjustment
+	if (!range.parabolic)
+		return range;
+
+	const cmpRangeManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_RangeManager);
+	if (!cmpRangeManager)
+		return range;
+
+	const effectiveMax = cmpRangeManager.GetEffectiveParabolicRange(
+		this.entity, target, range.max, this.GetAttackYOrigin(type));
+
+	if (effectiveMax < 0)
+		return { "min": Infinity, "max": 0 }; // Out of range
+
+	return { "min": range.min, "max": effectiveMax };
 };
 
 Attack.prototype.GetAttackYOrigin = function(type)
@@ -775,14 +885,9 @@ Attack.prototype.PerformAttack = function(type, target)
  */
 Attack.prototype.IsTargetInRange = function(target, type)
 {
-	const range = this.GetRange(type);
-	return Engine.QueryInterface(SYSTEM_ENTITY, IID_ObstructionManager).IsInTargetParabolicRange(
-		this.entity,
-		target,
-		range.min,
-		range.max,
-		this.GetAttackYOrigin(type),
-		false);
+	const range = this.GetEffectiveAttackRange(target, type);
+	return Engine.QueryInterface(SYSTEM_ENTITY, IID_ObstructionManager).IsInTargetRange(
+		this.entity, target, range.min, range.max, false);
 };
 
 Attack.prototype.OnValueModification = function(msg)

binaries/data/mods/public/simulation/components/BuildingAI.js

@@ -127,9 +127,17 @@ BuildingAI.prototype.SetupRangeQuery = function()
 
 	const range = cmpAttack.GetRange(attackType);
 	const yOrigin = cmpAttack.GetAttackYOrigin(attackType);
+
+	// Get building's vision range
+	const cmpVision = Engine.QueryInterface(this.entity, IID_Vision);
+	const visionRange = cmpVision ? cmpVision.GetRange() : 0;
+
+	// Base range
+	const baseRange = Math.min(visionRange, range.max);
+
 	// This takes entity sizes into accounts, so no need to compensate for structure size.
 	this.enemyUnitsQuery = cmpRangeManager.CreateActiveParabolicQuery(
-		this.entity, range.min, range.max, yOrigin,
+		this.entity, range.min, range.max, baseRange, yOrigin,
 		enemies, IID_Resistance, cmpRangeManager.GetEntityFlagMask("normal"));
 
 	cmpRangeManager.EnableActiveQuery(this.enemyUnitsQuery);
@@ -156,10 +164,17 @@ BuildingAI.prototype.SetupGaiaRangeQuery = function()
 	const range = cmpAttack.GetRange(attackType);
 	const yOrigin = cmpAttack.GetAttackYOrigin(attackType);
 
+	// Get building's vision range
+	const cmpVision = Engine.QueryInterface(this.entity, IID_Vision);
+	const visionRange = cmpVision ? cmpVision.GetRange() : 0;
+
+	// Base range
+	const baseRange = Math.min(visionRange, range.max);
+
 	// This query is only interested in Gaia entities that can attack.
 	// This takes entity sizes into accounts, so no need to compensate for structure size.
 	this.gaiaUnitsQuery = cmpRangeManager.CreateActiveParabolicQuery(
-		this.entity, range.min, range.max, yOrigin,
+		this.entity, range.min, range.max, baseRange, yOrigin,
 		[0], IID_Attack, cmpRangeManager.GetEntityFlagMask("normal"));
 
 	cmpRangeManager.EnableActiveQuery(this.gaiaUnitsQuery);
@@ -170,7 +185,6 @@ BuildingAI.prototype.SetupGaiaRangeQuery = function()
  */
 BuildingAI.prototype.OnRangeUpdate = function(msg)
 {
-
 	var cmpAttack = Engine.QueryInterface(this.entity, IID_Attack);
 	if (!cmpAttack)
 		return;
@@ -189,10 +203,10 @@ BuildingAI.prototype.OnRangeUpdate = function(msg)
 
 	// Add new targets.
 	for (const entity of msg.added)
-		if (cmpAttack.CanAttack(entity))
+		if (!this.targetUnits.includes(entity))
 			this.targetUnits.push(entity);
 
-	// Remove targets outside of vision-range.
+	// Remove targets out of range.
 	for (const entity of msg.removed)
 	{
 		const index = this.targetUnits.indexOf(entity);
@@ -375,13 +389,7 @@ BuildingAI.prototype.FireArrows = function()
 	{
 
 		const selectedTarget = targets[targetIndex].entityId;
-		if (this.CheckTargetVisible(selectedTarget) && cmpObstructionManager.IsInTargetParabolicRange(
-			this.entity,
-			selectedTarget,
-			range.min,
-			range.max,
-			yOrigin,
-			false))
+		if (cmpAttack.CanAttack(selectedTarget, [attackType]))
 		{
 			cmpAttack.PerformAttack(attackType, selectedTarget);
 			PlaySound("attack_" + attackType.toLowerCase(), this.entity);

binaries/data/mods/public/simulation/components/TurretHolder.js

@@ -240,6 +240,39 @@ class TurretHolder
 		return turret ? turret.name : "";
 	}
 
+	/**
+	 * Calculate the closest horizontal distance an external entity could ever get
+	 * to the specified turret point. If the holder is passable, returns 0.
+	 * Otherwise returns the perpendicular distance from the turret point to the
+	 * nearest edge of the holder's obstruction.
+	 *
+	 * @param {string|Object} turretPoint - The turret point name or object.
+	 * @return {number} - The minimum possible horizontal distance.
+	 */
+	GetClosestApproachDistanceToTurretPoint(turretPoint)
+	{
+		if (typeof turretPoint === "string")
+			turretPoint = this.TurretPointByName(turretPoint);
+		if (!turretPoint)
+			return 0;
+
+		const cmpObstruction = Engine.QueryInterface(this.entity, IID_Obstruction);
+		if (!cmpObstruction || !cmpObstruction.GetBlockMovementFlag(false))
+			return 0;
+
+		const dxLocal = turretPoint.offset.x;
+		const dzLocal = turretPoint.offset.z;
+
+		const halfSizes = cmpObstruction.GetObstructionHalfSizes();
+		const hw = halfSizes.x;
+		const hh = halfSizes.y;
+
+		if (hw == null || hh == null || hw < 0 || hh < 0)
+			return 0;
+
+		return Math.max(0, Math.min(hw - Math.abs(dxLocal), hh - Math.abs(dzLocal)));
+	}
+
 	/**
 	 * @return {number[]} - The turretted entityIDs.
 	 */

binaries/data/mods/public/simulation/components/UnitAI.js

@@ -4026,6 +4026,7 @@ UnitAI.prototype.SetupHealRangeQuery = function(enable = true)
 /**
  * Set up a range query for all enemy and gaia units within range
  * which can be attacked.
+ *
  * @param {boolean} enable - Optional parameter whether to enable the query.
  */
 UnitAI.prototype.SetupAttackRangeQuery = function(enable = true)
@@ -4048,10 +4049,27 @@ UnitAI.prototype.SetupAttackRangeQuery = function(enable = true)
 		return;
 
 	const range = this.GetQueryRange(IID_Attack);
-	// Do not compensate for entity sizes: LOS doesn't, and UnitAI relies on that.
-	this.losAttackRangeQuery = cmpRangeManager.CreateActiveQuery(this.entity,
-		range.min, range.max, players, IID_Resistance,
-		cmpRangeManager.GetEntityFlagMask("normal"), false);
+	if (range.parabolic)
+	{
+		const cmpAttack = Engine.QueryInterface(this.entity, IID_Attack);
+		const yOrigin = cmpAttack ? cmpAttack.GetAttackYOrigin("Ranged") : 0;
+		const baseRange = range.baseRange;
+
+		// Do not compensate for entity sizes: LOS doesn't, and UnitAI relies on that.
+		this.losAttackRangeQuery = cmpRangeManager.CreateActiveParabolicQuery(
+			this.entity,
+			range.min,
+			range.max,
+			baseRange,
+			yOrigin,
+			players,
+			IID_Resistance,
+			cmpRangeManager.GetEntityFlagMask("normal"));
+	}
+	else
+		this.losAttackRangeQuery = cmpRangeManager.CreateActiveQuery(this.entity,
+			range.min, range.max, players, IID_Resistance,
+			cmpRangeManager.GetEntityFlagMask("normal"), false);
 
 	if (enable)
 		cmpRangeManager.EnableActiveQuery(this.losAttackRangeQuery);
@@ -4948,24 +4966,24 @@ UnitAI.prototype.MoveToTargetAttackRange = function(target, type)
 	if (cmpFormation)
 		target = cmpFormation.GetClosestMemberToEntity(this.entity);
 
-	if (type != "Ranged")
-		return this.MoveToTargetRange(target, IID_Attack, type);
-
 	if (!this.CheckTargetVisible(target))
 		return false;
 
 	const cmpAttack = Engine.QueryInterface(this.entity, IID_Attack);
 	if (!cmpAttack)
 		return false;
-	const range = cmpAttack.GetRange(type);
 
-	// In case the range returns negative, we are probably too high compared to the target. Hope we come close enough.
-	const parabolicMaxRange = Math.max(0, Engine.QueryInterface(SYSTEM_ENTITY, IID_RangeManager).GetEffectiveParabolicRange(this.entity, target, range.max, cmpAttack.GetAttackYOrigin(type)));
+	const flatRange = cmpAttack.GetRange(type);
+	const effectiveRange = cmpAttack.GetEffectiveAttackRange(target, type);
+	if (effectiveRange.max < 0)
+		return false;
 
-	// The parabole changes while walking so be cautious:
-	const guessedMaxRange = parabolicMaxRange > range.max ? (range.max + parabolicMaxRange) / 2 : parabolicMaxRange;
+	// The parabola changes while walking so be cautious:
+	const guessedMaxRange = effectiveRange.max > flatRange.max ?
+		(flatRange.max + effectiveRange.max) / 2 :
+		effectiveRange.max;
 
-	return cmpUnitMotion && cmpUnitMotion.MoveToTargetRange(target, range.min, guessedMaxRange);
+	return cmpUnitMotion && cmpUnitMotion.MoveToTargetRange(target, effectiveRange.min, guessedMaxRange);
 };
 
 UnitAI.prototype.MoveToTargetRangeExplicit = function(target, min, max)
@@ -5372,8 +5390,16 @@ UnitAI.prototype.ShouldChaseTargetedEntity = function(target, force)
 	if (!this.AbleToMove())
 		return false;
 
+	// Check if we should chase based on stance
 	if (this.GetStance().respondChase)
-		return true;
+	{
+		// If we're allowed to chase beyond vision, always chase
+		if (this.GetStance().respondChaseBeyondVision)
+			return true;
+
+		// Otherwise, only chase if the target is within our personal vision
+		return this.CheckTargetIsInVisionRange(target);
+	}
 
 	// If we are guarding/escorting, chase at least as long as the guarded unit is in target range of the attacker
 	if (this.isGuardOf)
@@ -6339,9 +6365,22 @@ UnitAI.prototype.FindWalkAndFightTargets = function()
 	return false;
 };
 
+/**
+ * Returns the detection range for the given interface, adjusted by stance.
+ *
+ * The query range depends on stance because it represents the distance at which
+ * the unit should "notice" an enemy and potentially start moving toward it.
+ *
+ * @param {number} iid - IID_Vision, IID_Heal, or IID_Attack
+ * @returns {{min: number, max: number, baseRange: number, parabolic: boolean}}
+ * 'parabolic' indicates that the caller
+ * should use a parabolic range query (accounting for elevation) instead of a
+ * flat 2D one. Generally used for projectile attacks.
+ * 'baseRange' is a non-parabolic 2D detection range that always counts as in-range.
+ */
 UnitAI.prototype.GetQueryRange = function(iid)
 {
-	const ret = { "min": 0, "max": 0 };
+	const ret = { "min": 0, "max": 0, "baseRange": 0, "parabolic": false };
 
 	const cmpVision = Engine.QueryInterface(this.entity, IID_Vision);
 	if (!cmpVision)
@@ -6354,18 +6393,51 @@ UnitAI.prototype.GetQueryRange = function(iid)
 		return ret;
 	}
 
+	// The query range depends on stance because it represents the distance at which
+	// the unit should "notice" an enemy and potentially start moving toward it:
 	if (this.GetStance().respondStandGround)
 	{
+		// StandGround: flat attack range only (won't move at all)
 		const range = this.GetRange(iid);
 		if (!range)
 			return ret;
 		ret.min = range.min;
-		ret.max = Math.min(range.max, visionRange);
+		ret.max = range.max;
+		ret.baseRange = Math.min(visionRange, range.max);
+		// For StandGround, the 'parabolic' flag is set so that the caller can create a
+		// parabolic query instead of a flat one. This ensures elevation bonuses are
+		// properly accounted for when detecting enemies.
+		// Without this, a unit on a hill could be in parabolic range of an enemy
+		// but never notice them because the flat 2D detection circle is smaller.
+		// Other stances don't need this since they'll chase/approach anyway, and
+		// the attack validation (IsTargetInRange) does a precise parabolic check
+		// before actually attacking.
+		ret.parabolic = range.parabolic;
 	}
+	// In other stances, detect enemies within vision or within parabolic attack range.
+	// This allows attacking enemies visible through allies but outside personal vision.
+	// Base range capped by attack range to avoid querying beyond what we can actually hit.
 	else if (this.GetStance().respondChase)
-		ret.max = visionRange;
+	{
+		const range = this.GetRange(iid);
+		if (range && range.parabolic)
+		{
+			// Detect enemies within vision and
+			// enemies within parabolic attack range
+			ret.parabolic = true;
+			ret.max = range.max;           // Parabolic attack range
+			ret.baseRange = Math.min(visionRange, range.max);   // Always detect within vision
+			ret.min = range.min;
+		}
+		else
+		{
+			// Non-parabolic attacks: simple vision range
+			ret.max = visionRange;
+		}
+	}
 	else if (this.GetStance().respondHoldGround)
 	{
+		// HoldGround: vision range + half attack range (willing to move a bit)
 		const range = this.GetRange(iid);
 		if (!range)
 			return ret;

binaries/data/mods/public/simulation/components/tests/test_Attack.js

@@ -32,6 +32,8 @@ Engine.LoadComponentScript("interfaces/Formation.js");
 Engine.LoadComponentScript("interfaces/Health.js");
 Engine.LoadComponentScript("interfaces/Resistance.js");
 Engine.LoadComponentScript("interfaces/TechnologyManager.js");
+Engine.LoadComponentScript("interfaces/Turretable.js");
+Engine.LoadComponentScript("interfaces/TurretHolder.js");
 Engine.LoadComponentScript("Attack.js");
 
 let entityID = 903;
@@ -52,6 +54,16 @@ function attackComponentTest(defenderClass, isEnemy, test_function)
 		"IsEnemy": () => isEnemy
 	});
 
+	AddMock(SYSTEM_ENTITY, IID_ObstructionManager, {
+		"IsInTargetRange": () => true
+	});
+
+	AddMock(SYSTEM_ENTITY, IID_RangeManager, {
+		"GetEffectiveParabolicRange": () => 25,
+		"GetMaxReachableParabolicHeight": () => 15,
+		"GetLosVisibility": (target, owner) => "visible"
+	});
+
 	const attacker = entityID;
 
 	AddMock(attacker, IID_Position, {
@@ -201,7 +213,7 @@ attackComponentTest(undefined, true, (attacker, cmpAttack, defender) =>
 
 	TS_ASSERT_UNEVAL_EQUALS(cmpAttack.GetPreferredClasses("Melee"), ["Civilian"]);
 	TS_ASSERT_UNEVAL_EQUALS(cmpAttack.GetRestrictedClasses("Melee"), ["Elephant", "Archer"]);
-	TS_ASSERT_UNEVAL_EQUALS(cmpAttack.GetFullAttackRange(), { "min": 0, "max": 80 });
+	TS_ASSERT_UNEVAL_EQUALS(cmpAttack.GetFullAttackRange(), { "min": 0, "max": 80, "parabolic": true });
 	TS_ASSERT_UNEVAL_EQUALS(cmpAttack.GetAttackEffectsData("Capture"), { "Capture": 8 });
 
 	TS_ASSERT_UNEVAL_EQUALS(cmpAttack.GetAttackEffectsData("Ranged"), {
@@ -416,3 +428,101 @@ function testAttackPreference()
 	TS_ASSERT_EQUALS(cmpAttack.GetPreference(attacker+4), undefined);
 }
 testAttackPreference();
+
+function testCanEverReachTarget()
+{
+	const attacker = ++entityID;
+
+	AddMock(attacker, IID_Position, {
+		"IsInWorld": () => true,
+		"GetHeightOffset": () => 0,
+		"GetPosition2D": () => new Vector2D(1, 2)
+	});
+
+	const cmpAttack = ConstructComponent(attacker, "Attack", {
+		"Melee": {
+			"Damage": { "Hack": 10, "Pierce": 0, "Crush": 0 },
+			"MaxRange": 5
+		},
+		"Ranged": {
+			"Damage": { "Hack": 0, "Pierce": 10, "Crush": 0 },
+			"MaxRange": 30,
+			"Projectile": { "Speed": 50, "Spread": 1, "Gravity": 1, "FriendlyFire": "false" }
+		}
+	});
+
+	// Melee target within 3D range
+	{
+		const defender = ++entityID;
+		AddMock(defender, IID_Position, {
+			"IsInWorld": () => true,
+			"GetHeightOffset": () => 0
+		});
+		TS_ASSERT_EQUALS(cmpAttack.CanEverReachTarget(defender, "Melee"), true);
+	}
+
+	// Melee target too high
+	{
+		const defender = ++entityID;
+		AddMock(defender, IID_Position, {
+			"IsInWorld": () => true,
+			"GetHeightOffset": () => 10
+		});
+		TS_ASSERT_EQUALS(cmpAttack.CanEverReachTarget(defender, "Melee"), false);
+	}
+
+	// Melee target at same height, within range (close distance)
+	{
+		const defender = ++entityID;
+		AddMock(defender, IID_Position, {
+			"IsInWorld": () => true,
+			"GetHeightOffset": () => 4
+		});
+		// sqrt(0² + 4²) = 4 <= 5
+		TS_ASSERT_EQUALS(cmpAttack.CanEverReachTarget(defender, "Melee"), true);
+	}
+
+	// Ranged: target at same height — reachable from current position (check 1)
+	{
+		const defender = ++entityID;
+		AddMock(defender, IID_Position, {
+			"IsInWorld": () => true,
+			"GetHeightOffset": () => 0,
+			"GetPosition": () => new Vector3D(1, 0, 2)
+		});
+		// Need RangeManager mock for IsTargetInRange (check 1) to work
+		AddMock(SYSTEM_ENTITY, IID_RangeManager, {
+			"GetEffectiveParabolicRange": () => 25,
+			"GetMaxReachableParabolicHeight": () => 15
+		});
+		AddMock(SYSTEM_ENTITY, IID_ObstructionManager, {
+			"IsInTargetRange": () => true
+		});
+		TS_ASSERT_EQUALS(cmpAttack.CanEverReachTarget(defender, "Ranged"), true);
+	}
+
+	// Ranged: target too high for parabolic arc even at closest approach (check 2)
+	{
+		const defender = ++entityID;
+		AddMock(defender, IID_Position, {
+			"IsInWorld": () => true,
+			"GetHeightOffset": () => 20,
+			"GetPosition": () => new Vector3D(1, 20, 2)
+		});
+
+		AddMock(SYSTEM_ENTITY, IID_RangeManager, {
+			"GetEffectiveParabolicRange": () => -1, // out of range
+			"GetMaxReachableParabolicHeight": () => 10
+		});
+
+		AddMock(SYSTEM_ENTITY, IID_ObstructionManager, {
+			"IsInTargetRange": () => false
+		});
+
+		// heightDiff = 20 - 0 = 20, maxReachableHeightDiff = 10 → unreachable
+		TS_ASSERT_EQUALS(cmpAttack.CanEverReachTarget(defender, "Ranged"), false);
+	}
+}
+testCanEverReachTarget();
+
+

binaries/data/mods/public/simulation/components/tests/test_TurretHolder.js

@@ -15,6 +15,7 @@ const enemyPlayer = 2;
 const alliedPlayer = 3;
 const turretHolderID = 9;
 const entitiesToTest = [10, 11, 12, 13];
+let entityID = 100;
 
 AddMock(turretHolderID, IID_Ownership, {
 	"GetOwner": () => player
@@ -244,3 +245,80 @@ cmpTurretHolder.OnOwnershipChanged({
 	"from": INVALID_PLAYER
 });
 TS_ASSERT(cmpTurretHolder.OccupiesTurretPoint(spawned));
+
+// Test GetClosestApproachDistanceToTurretPoint
+{
+	const holder = ++entityID;
+
+	// Mock the holder's obstruction
+	AddMock(holder, IID_Obstruction, {
+		"GetBlockMovementFlag": () => true,
+		"GetObstructionHalfSizes": () => ({ "x": 10, "y": 15 })
+	});
+
+	const cmpHolder = ConstructComponent(holder, "TurretHolder", {
+		"TurretPoints": {
+			"center": {
+				"X": "0",
+				"Y": "5.0",
+				"Z": "0"
+			},
+			"edge": {
+				"X": "8.0",
+				"Y": "5.0",
+				"Z": "0"
+			},
+			"corner": {
+				"X": "10.0",
+				"Y": "5.0",
+				"Z": "15.0"
+			},
+			"outside": {
+				"X": "15.0",
+				"Y": "5.0",
+				"Z": "0"
+			}
+		}
+	});
+
+	// Center point (0,0) in 20x30 building → min(10, 15) = 10
+	TS_ASSERT_EQUALS(cmpHolder.GetClosestApproachDistanceToTurretPoint("center"), 10);
+
+	// Edge point (8,0) in 20x30 building → min(10-8, 15-0) = 2
+	TS_ASSERT_EQUALS(cmpHolder.GetClosestApproachDistanceToTurretPoint("edge"), 2);
+
+	// Corner point (10,15) in 20x30 building → min(10-10, 15-15) = 0
+	TS_ASSERT_EQUALS(cmpHolder.GetClosestApproachDistanceToTurretPoint("corner"), 0);
+
+	// Outside point (15,0) in 20x30 building → min(10-15, 15-0) = -5 → clamped to 0
+	TS_ASSERT_EQUALS(cmpHolder.GetClosestApproachDistanceToTurretPoint("outside"), 0);
+
+	// Nonexistent turret point
+	TS_ASSERT_EQUALS(cmpHolder.GetClosestApproachDistanceToTurretPoint("nonexistent"), 0);
+
+	// Pass object directly
+	const turretPoint = cmpHolder.TurretPointByName("center");
+	TS_ASSERT_EQUALS(cmpHolder.GetClosestApproachDistanceToTurretPoint(turretPoint), 10);
+
+	// Passable building (no obstruction or doesn't block movement)
+	const passableHolder = ++entityID;
+	AddMock(passableHolder, IID_Obstruction, {
+		"GetBlockMovementFlag": () => false
+	});
+	const cmpHolderPassable = ConstructComponent(passableHolder, "TurretHolder", {
+		"TurretPoints": {
+			"center": { "X": "0", "Y": "5.0", "Z": "0" }
+		}
+	});
+	TS_ASSERT_EQUALS(cmpHolderPassable.GetClosestApproachDistanceToTurretPoint("center"), 0);
+
+	// No obstruction component at all
+	const cmpHolderNoObst = ConstructComponent(++entityID, "TurretHolder", {
+		"TurretPoints": {
+			"center": { "X": "0", "Y": "5.0", "Z": "0" }
+		}
+	});
+	const result = cmpHolderNoObst.GetClosestApproachDistanceToTurretPoint("center");
+	TS_ASSERT_EQUALS(result, 0);
+}
+

binaries/data/mods/public/simulation/templates/template_structure_defensive_tower.xml

@@ -67,7 +67,7 @@
     <HeightOffset>18.0</HeightOffset>
   </StatusBars>
   <Vision>
-    <Range>80</Range>
+    <Range>10</Range>
   </Vision>
   <VisualActor>
     <FoundationActor>structures/fndn_3x3.xml</FoundationActor>

binaries/data/mods/public/simulation/templates/template_unit_infantry.xml

@@ -110,6 +110,6 @@
     </SoundGroups>
   </Sound>
   <Vision>
-    <Range>80</Range>
+    <Range>10</Range>
   </Vision>
 </Entity>

binaries/data/mods/public/simulation/templates/template_unit_siege_boltshooter.xml

@@ -74,6 +74,6 @@
     <Acceleration op="mul">0.75</Acceleration>
   </UnitMotion>
   <Vision>
-    <Range>100</Range>
+    <Range>10</Range>
   </Vision>
 </Entity>

source/simulation2/components/CCmpRangeManager.cpp

@@ -186,8 +186,10 @@ struct Query
 {
 	std::vector<entity_id_t> lastMatch;
 	CEntityHandle source; // TODO: this could crash if an entity is destroyed while a Query is still referencing it
+	player_id_t sourcePlayer; // Player who owns the source entity
 	entity_pos_t minRange;
 	entity_pos_t maxRange;
+	entity_pos_t baseRange;  // Non-parabolic detection range
 	entity_pos_t yOrigin; // Used for parabolas only.
 	u32 ownersMask;
 	i32 interface;
@@ -318,8 +320,10 @@ struct SerializeHelper<Query>
 	template<typename S>
 	void Common(S& serialize, const char* /*name*/, Serialize::qualify<S, Query> value)
 	{
+		serialize.NumberI32_Unbounded("sourcePlayer", value.sourcePlayer);
 		serialize.NumberFixed_Unbounded("min range", value.minRange);
 		serialize.NumberFixed_Unbounded("max range", value.maxRange);
+		serialize.NumberFixed_Unbounded("baseRange", value.baseRange);
 		serialize.NumberFixed_Unbounded("yOrigin", value.yOrigin);
 		serialize.NumberU32_Unbounded("owners mask", value.ownersMask);
 		serialize.NumberI32_Unbounded("interface", value.interface);
@@ -972,12 +976,11 @@ public:
 	}
 
 	tag_t CreateActiveParabolicQuery(entity_id_t source,
-		entity_pos_t minRange, entity_pos_t maxRange, entity_pos_t yOrigin,
+		entity_pos_t minRange, entity_pos_t maxRange, entity_pos_t baseRange, entity_pos_t yOrigin,
 		const std::vector<int>& owners, int requiredInterface, u8 flags) override
 	{
 		tag_t id = m_QueryNext++;
-		m_Queries[id] = ConstructParabolicQuery(source, minRange, maxRange, yOrigin, owners, requiredInterface, flags, true);
-
+		m_Queries[id] = ConstructParabolicQuery(source, minRange, maxRange, baseRange, yOrigin, owners, requiredInterface, flags, true);
 		return id;
 	}
 
@@ -1268,9 +1271,33 @@ public:
 		if (id == q.source.GetId())
 			return false;
 
-		// Ignore if it's missing the required interface
+		// Check if this is a mirage entity
+		CmpPtr<ICmpMirage> cmpMirage(GetSimContext(), id);
+		bool isMirage = !!cmpMirage;
+
+		// Ignore if it's missing the required interface but allow mirages to bypass
 		if (q.interface && !GetSimContext().GetComponentManager().QueryInterface(id, q.interface))
-			return false;
+		{
+			if (!isMirage)
+				return false;
+		}
+
+		// Skip hidden entities (not visible to source player)
+		if (q.source.GetId() != INVALID_ENTITY)
+		{
+			// Look up the source's current owner
+			EntityMap<EntityData>::const_iterator itSource = m_EntityData.find(q.source.GetId());
+			if (itSource != m_EntityData.end())
+			{
+				player_id_t sourceOwner = itSource->second.owner;
+				if (sourceOwner != INVALID_PLAYER)
+				{
+					LosVisibility vis = GetPlayerVisibility(entity.visibilities, sourceOwner);
+					if (vis == LosVisibility::HIDDEN)
+						return false;
+				}
+			}
+		}
 
 		return true;
 	}
@@ -1295,13 +1322,18 @@ public:
 		// Not the entire world, so check a parabolic range, or a regular range.
 		else if (q.parabolic)
 		{
-			// The yOrigin is part of the 3D position, as the source is really that much heigher.
+			// The yOrigin is part of the 3D position, as the source is really that much higher.
 			CmpPtr<ICmpPosition> cmpSourcePosition(q.source);
-			CFixedVector3D pos3d = cmpSourcePosition->GetPosition()+
-			    CFixedVector3D(entity_pos_t::Zero(), q.yOrigin, entity_pos_t::Zero()) ;
-			// Get a quick list of entities that are potentially in range, with a cutoff of 2*maxRange.
+			CFixedVector3D pos3d = cmpSourcePosition->GetPosition() +
+				CFixedVector3D(entity_pos_t::Zero(), q.yOrigin, entity_pos_t::Zero());
+			// Get a quick list of entities that are potentially in range.
+			// For parabolic queries, the search radius must cover:
+			//   1. The baseRange circle (non-parabolic detection)
+			//   2. The maximum possible horizontal extent of the parabolic range
+			// Multiplying maxRange by 2 provides a safe upper bound for all possible height differences.
+			entity_pos_t subdivisionRange = std::max(q.baseRange, q.maxRange * 2);
 			subdivisionResultsBuffer.clear();
-			m_Subdivision.GetNear(subdivisionResultsBuffer, pos, q.maxRange * 2);
+			m_Subdivision.GetNear(subdivisionResultsBuffer, pos, subdivisionRange);
 
 			for (size_t i = 0; i < subdivisionResultsBuffer.size(); ++i)
 			{
@@ -1311,6 +1343,20 @@ public:
 				if (!TestEntityQuery(q, it->first, it->second))
 					continue;
 
+				CFixedVector2D delta2D = CFixedVector2D(it->second.x, it->second.z) - pos;
+
+				// Check base range first
+				bool inBaseRange = !q.baseRange.IsZero() && delta2D.CompareLength(q.baseRange) <= 0;
+
+				if (inBaseRange)
+				{
+					// In base range - no need for parabolic check
+					if (q.minRange.IsZero() || delta2D.CompareLength(q.minRange) >= 0)
+						r.push_back(it->first);
+					continue;
+				}
+
+				// Parabolic check for entities outside base range
 				CmpPtr<ICmpPosition> cmpSecondPosition(GetSimContext(), subdivisionResultsBuffer[i]);
 				if (!cmpSecondPosition || !cmpSecondPosition->IsInWorld())
 					continue;
@@ -1328,7 +1374,7 @@ public:
 					continue;
 
 				if (!q.minRange.IsZero())
-					if ((CFixedVector2D(it->second.x, it->second.z) - pos).CompareLength(q.minRange) < 0)
+					if (delta2D.CompareLength(q.minRange) < 0)
 						continue;
 
 				r.push_back(it->first);
@@ -1365,6 +1411,22 @@ public:
 		}
 	}
 
+	/**
+	 * Compute effective horizontal range given a reference range and height difference.
+	 */
+	static entity_pos_t ComputeParabolicRange(entity_pos_t range, entity_pos_t heightDiff)
+	{
+		if (heightDiff < -range / 2)
+			return NEVER_IN_RANGE;
+
+		entity_pos_t effectiveRange;
+		effectiveRange.SetInternalValue(static_cast<i32>(isqrt64(
+			SQUARE_U64_FIXED(range) +
+			static_cast<i64>(heightDiff.GetInternalValue()) * static_cast<i64>(range.GetInternalValue()) * 2
+		)));
+		return effectiveRange;
+	}
+
 	entity_pos_t GetEffectiveParabolicRange(entity_id_t source, entity_id_t target, entity_pos_t range, entity_pos_t yOrigin) const override
 	{
 		// For non-positive ranges, just return the range.
@@ -1379,13 +1441,32 @@ public:
 		if (!cmpTargetPosition || !cmpTargetPosition->IsInWorld())
 			return NEVER_IN_RANGE;
 
-		entity_pos_t heightDifference = cmpSourcePosition->GetHeightOffset() - cmpTargetPosition->GetHeightOffset() + yOrigin;
-		if (heightDifference < -range / 2)
-			return NEVER_IN_RANGE;
+		// GetPosition() returns the world height (terrain + water + offset)
+		CFixedVector3D sourcePos = cmpSourcePosition->GetPosition();
+		CFixedVector3D targetPos = cmpTargetPosition->GetPosition();
 
-		entity_pos_t effectiveRange;
-		effectiveRange.SetInternalValue(static_cast<i32>(isqrt64(SQUARE_U64_FIXED(range) + static_cast<i64>(heightDifference.GetInternalValue()) * static_cast<i64>(range.GetInternalValue()) * 2)));
-		return effectiveRange;
+		entity_pos_t heightDiff = sourcePos.Y - targetPos.Y + yOrigin;
+		return ComputeParabolicRange(range, heightDiff);
+	}
+
+	entity_pos_t GetMaxReachableParabolicHeight(entity_pos_t range, entity_pos_t yOrigin, entity_pos_t horizDistance) const override
+	{
+		// EffectiveRange² = range² + 2 * range * heightDiff
+		// Solve for heightDiff when effectiveRange = horizDistance:
+		//   heightDiff = (horizDistance² - range²) / (2 * range)
+		// Max target height above source = yOrigin - heightDiff
+		//                               = yOrigin + (range² - horizDistance²) / (2 * range)
+		//
+		// If horizDistance > range, the result is less than yOrigin (can be negative),
+		// meaning the source must be above the target to compensate for the extra horizontal distance.
+		// The caller can decide if that's acceptable.
+		i64 rangeSq = SQUARE_U64_FIXED(range);
+		i64 distSq = SQUARE_U64_FIXED(horizDistance);
+		i64 numerator = rangeSq - distSq;
+
+		entity_pos_t result;
+		result.SetInternalValue(static_cast<i32>(numerator / static_cast<i64>(range.GetInternalValue() * 2)));
+		return yOrigin + result;
 	}
 
 	entity_pos_t GetElevationAdaptedRange(const CFixedVector3D& pos1, const CFixedVector3D& rot, entity_pos_t range, entity_pos_t yOrigin, entity_pos_t angle) const override
@@ -1501,10 +1582,13 @@ public:
 		if (maxRange < entity_pos_t::Zero() && maxRange != ALWAYS_IN_RANGE)
 			LOGWARNING("CCmpRangeManager: Invalid max range %f in query for entity %u", maxRange.ToDouble(), source);
 
+		CmpPtr<ICmpOwnership> cmpOwnership(GetSimContext(), source);
+
 		Query q;
 		q.enabled = false;
 		q.parabolic = false;
 		q.source = GetSimContext().GetComponentManager().LookupEntityHandle(source);
+		q.sourcePlayer = INVALID_PLAYER;
 		q.minRange = minRange;
 		q.maxRange = maxRange;
 		q.yOrigin = entity_pos_t::Zero();
@@ -1545,12 +1629,13 @@ public:
 	}
 
 	Query ConstructParabolicQuery(entity_id_t source,
-		entity_pos_t minRange, entity_pos_t maxRange, entity_pos_t yOrigin,
+		entity_pos_t minRange, entity_pos_t maxRange, entity_pos_t baseRange, entity_pos_t yOrigin,
 		const std::vector<int>& owners, int requiredInterface, u8 flagsMask, bool accountForSize) const
 	{
 		Query q = ConstructQuery(source, minRange, maxRange, owners, requiredInterface, flagsMask, accountForSize);
 		q.parabolic = true;
 		q.yOrigin = yOrigin;
+		q.baseRange = baseRange;
 		return q;
 	}
 

source/simulation2/components/ICmpObstruction.cpp

@@ -1,4 +1,4 @@
-/* Copyright (C) 2025 Wildfire Games.
+/* Copyright (C) 2026 Wildfire Games.
  * This file is part of 0 A.D.
  *
  * 0 A.D. is free software: you can redistribute it and/or modify
@@ -45,6 +45,14 @@ std::string ICmpObstruction::CheckFoundation_wrapper(const std::string& classNam
 	}
 }
 
+CFixedVector2D ICmpObstruction::GetObstructionHalfSizes_wrapper() const
+{
+	ICmpObstructionManager::ObstructionSquare square;
+	if (!GetObstructionSquare(square))
+		return CFixedVector2D(entity_pos_t::FromInt(-1), entity_pos_t::FromInt(-1));
+	return CFixedVector2D(square.hw, square.hh);
+}
+
 BEGIN_INTERFACE_WRAPPER(Obstruction)
 DEFINE_INTERFACE_METHOD("GetSize", ICmpObstruction, GetSize)
 DEFINE_INTERFACE_METHOD("CheckShorePlacement", ICmpObstruction, CheckShorePlacement)
@@ -55,6 +63,7 @@ DEFINE_INTERFACE_METHOD("GetEntitiesBlockingConstruction", ICmpObstruction, GetE
 DEFINE_INTERFACE_METHOD("GetEntitiesDeletedUponConstruction", ICmpObstruction, GetEntitiesDeletedUponConstruction)
 DEFINE_INTERFACE_METHOD("SetActive", ICmpObstruction, SetActive)
 DEFINE_INTERFACE_METHOD("SetDisableBlockMovementPathfinding", ICmpObstruction, SetDisableBlockMovementPathfinding)
+DEFINE_INTERFACE_METHOD("GetObstructionHalfSizes", ICmpObstruction, GetObstructionHalfSizes_wrapper)
 DEFINE_INTERFACE_METHOD("GetBlockMovementFlag", ICmpObstruction, GetBlockMovementFlag)
 DEFINE_INTERFACE_METHOD("SetControlGroup", ICmpObstruction, SetControlGroup)
 DEFINE_INTERFACE_METHOD("GetControlGroup", ICmpObstruction, GetControlGroup)

source/simulation2/components/ICmpObstruction.h

@@ -1,4 +1,4 @@
-/* Copyright (C) 2025 Wildfire Games.
+/* Copyright (C) 2026 Wildfire Games.
  * This file is part of 0 A.D.
  *
  * 0 A.D. is free software: you can redistribute it and/or modify
@@ -104,6 +104,12 @@ public:
 	 */
 	virtual std::string CheckFoundation_wrapper(const std::string& className, bool onlyCenterPoint) const;
 
+	/**
+	 * GetObstructionSquare wrapper for script calls.
+	 * @return [hw, hh] half-sizes of the obstruction square, or empty array on failure.
+	 */
+	virtual CFixedVector2D GetObstructionHalfSizes_wrapper() const;
+
 	/**
 	 * Test whether this entity is colliding with any obstructions that share its
 	 * control groups and block the creation of foundations.

source/simulation2/components/ICmpRangeManager.cpp

@@ -67,6 +67,7 @@ DEFINE_INTERFACE_METHOD("GetLosRevealWholeMap", ICmpRangeManager, GetLosRevealWh
 DEFINE_INTERFACE_METHOD("SetLosRevealWholeMapForAll", ICmpRangeManager, SetLosRevealWholeMapForAll)
 DEFINE_INTERFACE_METHOD("GetLosRevealWholeMapForAll", ICmpRangeManager, GetLosRevealWholeMapForAll)
 DEFINE_INTERFACE_METHOD("GetEffectiveParabolicRange", ICmpRangeManager, GetEffectiveParabolicRange)
+DEFINE_INTERFACE_METHOD("GetMaxReachableParabolicHeight", ICmpRangeManager, GetMaxReachableParabolicHeight)
 DEFINE_INTERFACE_METHOD("GetElevationAdaptedRange", ICmpRangeManager, GetElevationAdaptedRange)
 DEFINE_INTERFACE_METHOD("ActivateScriptedVisibility", ICmpRangeManager, ActivateScriptedVisibility)
 DEFINE_INTERFACE_METHOD("GetLosVisibility", ICmpRangeManager, GetLosVisibility_wrapper)

source/simulation2/components/ICmpRangeManager.h

@@ -174,6 +174,9 @@ public:
 	 * @param maxRange non-negative maximum distance in metres (inclusive) for units on the same elevation;
 	 *      or -1.0 to ignore distance.
 	 *      For units on a different height positions, a physical correct paraboloid with height=maxRange/2 above the unit is used to query them
+	 * @param baseRange non-negative base detection range in metres (inclusive) for simple 2D circle checks.
+	 *      Units within this horizontal distance are always considered in range regardless of height.
+	 *      Set to 0 to disable (original parabolic-only behavior).
 	 * @param yOrigin extra bonus so the source can be placed higher and shoot further
 	 * @param owners list of player IDs that matching entities may have; -1 matches entities with no owner.
 	 * @param requiredInterface if non-zero, an interface ID that matching entities must implement.
@@ -181,7 +184,8 @@ public:
 	 * NB: this one has no accountForSize parameter (assumed true), because we currently can only have 7 arguments for JS functions.
 	 * @return unique non-zero identifier of query.
 	 */
-	virtual tag_t CreateActiveParabolicQuery(entity_id_t source, entity_pos_t minRange, entity_pos_t maxRange, entity_pos_t yOrigin,
+	virtual tag_t CreateActiveParabolicQuery(entity_id_t source,
+		entity_pos_t minRange, entity_pos_t maxRange, entity_pos_t baseRange, entity_pos_t yOrigin,
 		const std::vector<int>& owners, int requiredInterface, u8 flags) = 0;
 
 
@@ -195,6 +199,18 @@ public:
 	 */
 	virtual entity_pos_t GetEffectiveParabolicRange(entity_id_t source, entity_id_t target, entity_pos_t range, entity_pos_t yOrigin) const = 0;
 
+	/**
+	* Get the max height (relative to the source) a parabolic projectile can reach
+	* at a given horizontal distance.
+	* @param source the entity at the origin.
+	* @param range the maximum parabolic range on flat terrain.
+	* @param yOrigin height bonus for the source.
+	* @param horizDistance the horizontal distance to check.
+	* @return the maximum reachable height difference (target height - source height),
+	*         or a very negative value if the horizontal distance exceeds the range.
+	*/
+	virtual entity_pos_t GetMaxReachableParabolicHeight(entity_pos_t range, entity_pos_t yOrigin, entity_pos_t horizDistance) const = 0;
+
 	/**
 	 * Get the average elevation over 8 points on distance range around the entity
 	 * @param id the entity id to look around

source/simulation2/components/tests/test_RangeManager.h

@@ -1,4 +1,4 @@
-/* Copyright (C) 2025 Wildfire Games.
+/* Copyright (C) 2026 Wildfire Games.
  * This file is part of 0 A.D.
  *
  * 0 A.D. is free software: you can redistribute it and/or modify
@@ -62,13 +62,13 @@ public:
 	entity_id_t GetTurretParent() const override {return INVALID_ENTITY;}
 	void UpdateTurretPosition() override {}
 	std::set<entity_id_t>* GetTurrets() override { return nullptr; }
-	bool IsInWorld() const override { return true; }
-	void MoveOutOfWorld() override { }
+	bool IsInWorld() const override { return m_InWorld; }
+	void MoveOutOfWorld() override { m_InWorld = false; }
 	void MoveTo(entity_pos_t /*x*/, entity_pos_t /*z*/) override { }
 	void MoveAndTurnTo(entity_pos_t /*x*/, entity_pos_t /*z*/, entity_angle_t /*a*/) override { }
 	void JumpTo(entity_pos_t /*x*/, entity_pos_t /*z*/) override { }
-	void SetHeightOffset(entity_pos_t /*dy*/) override { }
-	entity_pos_t GetHeightOffset() const override { return entity_pos_t::Zero(); }
+	void SetHeightOffset(entity_pos_t dy) override { m_HeightOffset = dy; }
+	entity_pos_t GetHeightOffset() const override { return m_HeightOffset; }
 	void SetHeightFixed(entity_pos_t /*y*/) override { }
 	entity_pos_t GetHeightFixed() const override { return entity_pos_t::Zero(); }
 	entity_pos_t GetHeightAtFixed(entity_pos_t, entity_pos_t) const override { return entity_pos_t::Zero(); }
@@ -93,6 +93,8 @@ public:
 	CMatrix3D GetInterpolatedTransform(float /*frameOffset*/) const override { return CMatrix3D(); }
 
 	CFixedVector3D m_Pos;
+	entity_pos_t m_HeightOffset = entity_pos_t::Zero();
+	bool m_InWorld = true;
 };
 
 class MockObstructionRgm : public ICmpObstruction
@@ -153,7 +155,7 @@ public:
 	{
 		ComponentTestHelper test(*g_ScriptContext);
 
-		ICmpRangeManager* cmp = test.Add<ICmpRangeManager>(CID_RangeManager, "", SYSTEM_ENTITY);
+		ICmpRangeManager* rangeManager = test.Add<ICmpRangeManager>(CID_RangeManager, "", SYSTEM_ENTITY);
 
 		MockVisionRgm vision;
 		test.AddMock(100, IID_Vision, vision);
@@ -164,41 +166,41 @@ public:
 		// This tests that the incremental computation produces the correct result
 		// in various edge cases
 
-		cmp->SetBounds(entity_pos_t::FromInt(0), entity_pos_t::FromInt(0), entity_pos_t::FromInt(512), entity_pos_t::FromInt(512));
-		cmp->Verify();
-		{ CMessageCreate msg(100); cmp->HandleMessage(msg, false); }
-		cmp->Verify();
-		{ CMessageOwnershipChanged msg(100, -1, 1); cmp->HandleMessage(msg, false); }
-		cmp->Verify();
-		{ CMessagePositionChanged msg(100, true, entity_pos_t::FromInt(247), entity_pos_t::FromDouble(257.95), entity_angle_t::Zero()); cmp->HandleMessage(msg, false); }
-		cmp->Verify();
-		{ CMessagePositionChanged msg(100, true, entity_pos_t::FromInt(247), entity_pos_t::FromInt(253), entity_angle_t::Zero()); cmp->HandleMessage(msg, false); }
-		cmp->Verify();
+		rangeManager->SetBounds(entity_pos_t::FromInt(0), entity_pos_t::FromInt(0), entity_pos_t::FromInt(512), entity_pos_t::FromInt(512));
+		rangeManager->Verify();
+		{ CMessageCreate msg(100); rangeManager->HandleMessage(msg, false); }
+		rangeManager->Verify();
+		{ CMessageOwnershipChanged msg(100, -1, 1); rangeManager->HandleMessage(msg, false); }
+		rangeManager->Verify();
+		{ CMessagePositionChanged msg(100, true, entity_pos_t::FromInt(247), entity_pos_t::FromDouble(257.95), entity_angle_t::Zero()); rangeManager->HandleMessage(msg, false); }
+		rangeManager->Verify();
+		{ CMessagePositionChanged msg(100, true, entity_pos_t::FromInt(247), entity_pos_t::FromInt(253), entity_angle_t::Zero()); rangeManager->HandleMessage(msg, false); }
+		rangeManager->Verify();
 
-		{ CMessagePositionChanged msg(100, true, entity_pos_t::FromInt(256), entity_pos_t::FromInt(256), entity_angle_t::Zero()); cmp->HandleMessage(msg, false); }
-		cmp->Verify();
+		{ CMessagePositionChanged msg(100, true, entity_pos_t::FromInt(256), entity_pos_t::FromInt(256), entity_angle_t::Zero()); rangeManager->HandleMessage(msg, false); }
+		rangeManager->Verify();
 
-		{ CMessagePositionChanged msg(100, true, entity_pos_t::FromInt(256)+entity_pos_t::Epsilon(), entity_pos_t::FromInt(256), entity_angle_t::Zero()); cmp->HandleMessage(msg, false); }
-		cmp->Verify();
-		{ CMessagePositionChanged msg(100, true, entity_pos_t::FromInt(256)-entity_pos_t::Epsilon(), entity_pos_t::FromInt(256), entity_angle_t::Zero()); cmp->HandleMessage(msg, false); }
-		cmp->Verify();
-		{ CMessagePositionChanged msg(100, true, entity_pos_t::FromInt(256), entity_pos_t::FromInt(256)+entity_pos_t::Epsilon(), entity_angle_t::Zero()); cmp->HandleMessage(msg, false); }
-		cmp->Verify();
-		{ CMessagePositionChanged msg(100, true, entity_pos_t::FromInt(256), entity_pos_t::FromInt(256)-entity_pos_t::Epsilon(), entity_angle_t::Zero()); cmp->HandleMessage(msg, false); }
-		cmp->Verify();
+		{ CMessagePositionChanged msg(100, true, entity_pos_t::FromInt(256)+entity_pos_t::Epsilon(), entity_pos_t::FromInt(256), entity_angle_t::Zero()); rangeManager->HandleMessage(msg, false); }
+		rangeManager->Verify();
+		{ CMessagePositionChanged msg(100, true, entity_pos_t::FromInt(256)-entity_pos_t::Epsilon(), entity_pos_t::FromInt(256), entity_angle_t::Zero()); rangeManager->HandleMessage(msg, false); }
+		rangeManager->Verify();
+		{ CMessagePositionChanged msg(100, true, entity_pos_t::FromInt(256), entity_pos_t::FromInt(256)+entity_pos_t::Epsilon(), entity_angle_t::Zero()); rangeManager->HandleMessage(msg, false); }
+		rangeManager->Verify();
+		{ CMessagePositionChanged msg(100, true, entity_pos_t::FromInt(256), entity_pos_t::FromInt(256)-entity_pos_t::Epsilon(), entity_angle_t::Zero()); rangeManager->HandleMessage(msg, false); }
+		rangeManager->Verify();
 
-		{ CMessagePositionChanged msg(100, true, entity_pos_t::FromInt(383), entity_pos_t::FromInt(84), entity_angle_t::Zero()); cmp->HandleMessage(msg, false); }
-		cmp->Verify();
-		{ CMessagePositionChanged msg(100, true, entity_pos_t::FromInt(348), entity_pos_t::FromInt(83), entity_angle_t::Zero()); cmp->HandleMessage(msg, false); }
-		cmp->Verify();
+		{ CMessagePositionChanged msg(100, true, entity_pos_t::FromInt(383), entity_pos_t::FromInt(84), entity_angle_t::Zero()); rangeManager->HandleMessage(msg, false); }
+		rangeManager->Verify();
+		{ CMessagePositionChanged msg(100, true, entity_pos_t::FromInt(348), entity_pos_t::FromInt(83), entity_angle_t::Zero()); rangeManager->HandleMessage(msg, false); }
+		rangeManager->Verify();
 
 		std::mt19937 rng;
 		for (size_t i = 0; i < 1024; ++i)
 		{
 			double x = std::uniform_real_distribution<double>(0.0, 512.0)(rng);
 			double z = std::uniform_real_distribution<double>(0.0, 512.0)(rng);
-			{ CMessagePositionChanged msg(100, true, entity_pos_t::FromDouble(x), entity_pos_t::FromDouble(z), entity_angle_t::Zero()); cmp->HandleMessage(msg, false); }
-			cmp->Verify();
+			{ CMessagePositionChanged msg(100, true, entity_pos_t::FromDouble(x), entity_pos_t::FromDouble(z), entity_angle_t::Zero()); rangeManager->HandleMessage(msg, false); }
+			rangeManager->Verify();
 		}
 
 		// Test OwnershipChange, GetEntitiesByPlayer, GetNonGaiaEntities
@@ -207,12 +209,12 @@ public:
 			for (player_id_t newOwner = 0; newOwner < 8; ++newOwner)
 			{
 				CMessageOwnershipChanged msg(100, previousOwner, newOwner);
-				cmp->HandleMessage(msg, false);
+				rangeManager->HandleMessage(msg, false);
 
 				for (player_id_t i = 0; i < 8; ++i)
-					TS_ASSERT_EQUALS(cmp->GetEntitiesByPlayer(i).size(), i == newOwner ? 1 : 0);
+					TS_ASSERT_EQUALS(rangeManager->GetEntitiesByPlayer(i).size(), i == newOwner ? 1 : 0);
 
-				TS_ASSERT_EQUALS(cmp->GetNonGaiaEntities().size(), newOwner > 0 ? 1 : 0);
+				TS_ASSERT_EQUALS(rangeManager->GetNonGaiaEntities().size(), newOwner > 0 ? 1 : 0);
 				previousOwner = newOwner;
 			}
 		}
@@ -222,7 +224,7 @@ public:
 	{
 		ComponentTestHelper test(*g_ScriptContext);
 
-		ICmpRangeManager* cmp = test.Add<ICmpRangeManager>(CID_RangeManager, "", SYSTEM_ENTITY);
+		ICmpRangeManager* rangeManager = test.Add<ICmpRangeManager>(CID_RangeManager, "", SYSTEM_ENTITY);
 
 		MockVisionRgm vision, vision2;
 		MockPositionRgm position, position2;
@@ -235,100 +237,169 @@ public:
 		test.AddMock(101, IID_Position, position2);
 		test.AddMock(101, IID_Obstruction, obs2);
 
-		cmp->SetBounds(entity_pos_t::FromInt(0), entity_pos_t::FromInt(0), entity_pos_t::FromInt(512), entity_pos_t::FromInt(512));
-		cmp->Verify();
-		{ CMessageCreate msg(100); cmp->HandleMessage(msg, false); }
-		{ CMessageCreate msg(101); cmp->HandleMessage(msg, false); }
+		rangeManager->SetBounds(entity_pos_t::FromInt(0), entity_pos_t::FromInt(0), entity_pos_t::FromInt(512), entity_pos_t::FromInt(512));
+		rangeManager->Verify();
+		{ CMessageCreate msg(100); rangeManager->HandleMessage(msg, false); }
+		{ CMessageCreate msg(101); rangeManager->HandleMessage(msg, false); }
 
-		{ CMessageOwnershipChanged msg(100, -1, 1); cmp->HandleMessage(msg, false); }
-		{ CMessageOwnershipChanged msg(101, -1, 1); cmp->HandleMessage(msg, false); }
+		{ CMessageOwnershipChanged msg(100, -1, 1); rangeManager->HandleMessage(msg, false); }
+		{ CMessageOwnershipChanged msg(101, -1, 1); rangeManager->HandleMessage(msg, false); }
 
-		auto move = [&cmp](entity_id_t ent, MockPositionRgm& pos, fixed x, fixed z) {
+		auto move = [&rangeManager](entity_id_t ent, MockPositionRgm& pos, fixed x, fixed z) {
 			pos.m_Pos = CFixedVector3D(x, fixed::Zero(), z);
-			{ CMessagePositionChanged msg(ent, true, x, z, entity_angle_t::Zero()); cmp->HandleMessage(msg, false); }
+			{ CMessagePositionChanged msg(ent, true, x, z, entity_angle_t::Zero()); rangeManager->HandleMessage(msg, false); }
 		};
 
 		move(100, position, fixed::FromInt(10), fixed::FromInt(10));
 		move(101, position2, fixed::FromInt(10), fixed::FromInt(20));
 
-		std::vector<entity_id_t> nearby = cmp->ExecuteQuery(100, fixed::FromInt(0), fixed::FromInt(4), {1}, 0, true);
+		std::vector<entity_id_t> nearby = rangeManager->ExecuteQuery(100, fixed::FromInt(0), fixed::FromInt(4), {1}, 0, true);
 		TS_ASSERT_EQUALS(nearby, std::vector<entity_id_t>{});
-		nearby = cmp->ExecuteQuery(100, fixed::FromInt(4), fixed::FromInt(50), {1}, 0, true);
+		nearby = rangeManager->ExecuteQuery(100, fixed::FromInt(4), fixed::FromInt(50), {1}, 0, true);
 		TS_ASSERT_EQUALS(nearby, std::vector<entity_id_t>{101});
 
 		move(101, position2, fixed::FromInt(10), fixed::FromInt(10));
-		nearby = cmp->ExecuteQuery(100, fixed::FromInt(0), fixed::FromInt(4), {1}, 0, true);
+		nearby = rangeManager->ExecuteQuery(100, fixed::FromInt(0), fixed::FromInt(4), {1}, 0, true);
 		TS_ASSERT_EQUALS(nearby, std::vector<entity_id_t>{101});
-		nearby = cmp->ExecuteQuery(100, fixed::FromInt(4), fixed::FromInt(50), {1}, 0, true);
+		nearby = rangeManager->ExecuteQuery(100, fixed::FromInt(4), fixed::FromInt(50), {1}, 0, true);
 		TS_ASSERT_EQUALS(nearby, std::vector<entity_id_t>{});
 
 		move(101, position2, fixed::FromInt(10), fixed::FromInt(13));
-		nearby = cmp->ExecuteQuery(100, fixed::FromInt(0), fixed::FromInt(4), {1}, 0, true);
+		nearby = rangeManager->ExecuteQuery(100, fixed::FromInt(0), fixed::FromInt(4), {1}, 0, true);
 		TS_ASSERT_EQUALS(nearby, std::vector<entity_id_t>{101});
-		nearby = cmp->ExecuteQuery(100, fixed::FromInt(4), fixed::FromInt(50), {1}, 0, true);
+		nearby = rangeManager->ExecuteQuery(100, fixed::FromInt(4), fixed::FromInt(50), {1}, 0, true);
 		TS_ASSERT_EQUALS(nearby, std::vector<entity_id_t>{});
 
 		move(101, position2, fixed::FromInt(10), fixed::FromInt(15));
 		// In range thanks to self obstruction size.
-		nearby = cmp->ExecuteQuery(100, fixed::FromInt(0), fixed::FromInt(4), {1}, 0, true);
+		nearby = rangeManager->ExecuteQuery(100, fixed::FromInt(0), fixed::FromInt(4), {1}, 0, true);
 		TS_ASSERT_EQUALS(nearby, std::vector<entity_id_t>{101});
 		// In range thanks to target obstruction size.
-		nearby = cmp->ExecuteQuery(101, fixed::FromInt(0), fixed::FromInt(4), {1}, 0, true);
+		nearby = rangeManager->ExecuteQuery(101, fixed::FromInt(0), fixed::FromInt(4), {1}, 0, true);
 		TS_ASSERT_EQUALS(nearby, std::vector<entity_id_t>{100});
 
 		// Trickier: min-range is closest-to-closest, but rotation may change the real distance.
-		nearby = cmp->ExecuteQuery(100, fixed::FromInt(2), fixed::FromInt(50), {1}, 0, true);
+		nearby = rangeManager->ExecuteQuery(100, fixed::FromInt(2), fixed::FromInt(50), {1}, 0, true);
 		TS_ASSERT_EQUALS(nearby, std::vector<entity_id_t>{101});
-		nearby = cmp->ExecuteQuery(100, fixed::FromInt(5), fixed::FromInt(50), {1}, 0, true);
+		nearby = rangeManager->ExecuteQuery(100, fixed::FromInt(5), fixed::FromInt(50), {1}, 0, true);
 		TS_ASSERT_EQUALS(nearby, std::vector<entity_id_t>{101});
-		nearby = cmp->ExecuteQuery(100, fixed::FromInt(6), fixed::FromInt(50), {1}, 0, true);
+		nearby = rangeManager->ExecuteQuery(100, fixed::FromInt(6), fixed::FromInt(50), {1}, 0, true);
 		TS_ASSERT_EQUALS(nearby, std::vector<entity_id_t>{});
-		nearby = cmp->ExecuteQuery(101, fixed::FromInt(5), fixed::FromInt(50), {1}, 0, true);
+		nearby = rangeManager->ExecuteQuery(101, fixed::FromInt(5), fixed::FromInt(50), {1}, 0, true);
 		TS_ASSERT_EQUALS(nearby, std::vector<entity_id_t>{100});
-		nearby = cmp->ExecuteQuery(101, fixed::FromInt(6), fixed::FromInt(50), {1}, 0, true);
+		nearby = rangeManager->ExecuteQuery(101, fixed::FromInt(6), fixed::FromInt(50), {1}, 0, true);
 		TS_ASSERT_EQUALS(nearby, std::vector<entity_id_t>{});
 
 	}
 
-	void test_IsInTargetParabolicRange()
+	void test_ParabolicRangeBasic()
 	{
 		ComponentTestHelper test(*g_ScriptContext);
-		ICmpRangeManager* cmp = test.Add<ICmpRangeManager>(CID_RangeManager, "", SYSTEM_ENTITY);
+		ICmpRangeManager* rangeManager = test.Add<ICmpRangeManager>(CID_RangeManager, "", SYSTEM_ENTITY);
+
 		const entity_id_t source = 200;
 		const entity_id_t target = 201;
-		entity_pos_t range = fixed::FromInt(-3);
-		entity_pos_t yOrigin = fixed::FromInt(-20);
+		entity_pos_t range{fixed::FromInt(-3)};
+		entity_pos_t yOrigin{fixed::FromInt(-20)};
 
 		// Invalid range.
-		TS_ASSERT_EQUALS(cmp->GetEffectiveParabolicRange(source, target, range, yOrigin), range);
+		TS_ASSERT_EQUALS(rangeManager->GetEffectiveParabolicRange(source, target, range, yOrigin), range);
 
 		// No source ICmpPosition.
 		range = fixed::FromInt(10);
-		TS_ASSERT_EQUALS(cmp->GetEffectiveParabolicRange(source, target, range, yOrigin), NEVER_IN_RANGE);
+		TS_ASSERT_EQUALS(rangeManager->GetEffectiveParabolicRange(source, target, range, yOrigin), NEVER_IN_RANGE);
 
 		// No target ICmpPosition.
 		MockPositionRgm cmpSourcePosition;
 		test.AddMock(source, IID_Position, cmpSourcePosition);
-		TS_ASSERT_EQUALS(cmp->GetEffectiveParabolicRange(source, target, range, yOrigin), NEVER_IN_RANGE);
+		TS_ASSERT_EQUALS(rangeManager->GetEffectiveParabolicRange(source, target, range, yOrigin), NEVER_IN_RANGE);
 
 		// Too much height difference.
 		MockPositionRgm cmpTargetPosition;
 		test.AddMock(target, IID_Position, cmpTargetPosition);
-		TS_ASSERT_EQUALS(cmp->GetEffectiveParabolicRange(source, target, range, yOrigin), NEVER_IN_RANGE);
+		TS_ASSERT_EQUALS(rangeManager->GetEffectiveParabolicRange(source, target, range, yOrigin), NEVER_IN_RANGE);
 
 		// If no offset we get the range.
 		range = fixed::FromInt(20);
 		yOrigin = fixed::Zero();
-		TS_ASSERT_EQUALS(cmp->GetEffectiveParabolicRange(source, target, range, yOrigin), range);
-		TS_ASSERT_EQUALS(cmp->GetEffectiveParabolicRange(source, target, fixed::Zero(), yOrigin), fixed::Zero());
+		TS_ASSERT_EQUALS(rangeManager->GetEffectiveParabolicRange(source, target, range, yOrigin), range);
+		TS_ASSERT_EQUALS(rangeManager->GetEffectiveParabolicRange(source, target, fixed::Zero(), yOrigin), fixed::Zero());
 
-		// Normal case.
+		// Normal case with yOrigin only (no terrain difference)
 		yOrigin = fixed::FromInt(5);
 		range = fixed::FromInt(10);
-		TS_ASSERT_EQUALS(cmp->GetEffectiveParabolicRange(source, target, range, yOrigin), fixed::FromFloat(14.142136f));
+		TS_ASSERT_EQUALS(rangeManager->GetEffectiveParabolicRange(source, target, range, yOrigin), fixed::FromFloat(14.142136f));
 
 		// Big range.
 		range = fixed::FromInt(260);
-		TS_ASSERT_EQUALS(cmp->GetEffectiveParabolicRange(source, target, range, yOrigin), fixed::FromFloat(264.952820f));
+		TS_ASSERT_EQUALS(rangeManager->GetEffectiveParabolicRange(source, target, range, yOrigin), fixed::FromFloat(264.952820f));
+	}
+
+	void test_ParabolicRangeWithTerrain()
+	{
+		ComponentTestHelper test(*g_ScriptContext);
+		ICmpRangeManager* rangeManager = test.Add<ICmpRangeManager>(CID_RangeManager, "", SYSTEM_ENTITY);
+
+		const entity_id_t source{200};
+		const entity_id_t target{201};
+
+		MockPositionRgm sourcePos;
+		MockPositionRgm targetPos;
+		test.AddMock(source, IID_Position, sourcePos);
+		test.AddMock(target, IID_Position, targetPos);
+
+		const entity_pos_t range{fixed::FromInt(100)};
+		const entity_pos_t yOrigin{fixed::Zero()};
+
+		// Source on high ground (Y=10), target on low ground (Y=0)
+		sourcePos.m_Pos = CFixedVector3D(fixed::Zero(), fixed::FromInt(10), fixed::Zero());
+		targetPos.m_Pos = CFixedVector3D(fixed::Zero(), fixed::Zero(), fixed::FromInt(50));
+		entity_pos_t effective = rangeManager->GetEffectiveParabolicRange(source, target, range, yOrigin);
+		TS_ASSERT_DELTA(effective.ToFloat(), 109.5445f, 0.01f); // ~109.54
+
+		// Source on low ground (Y=0), target on high ground (Y=10)
+		sourcePos.m_Pos = CFixedVector3D(fixed::Zero(), fixed::Zero(), fixed::Zero());
+		targetPos.m_Pos = CFixedVector3D(fixed::Zero(), fixed::FromInt(10), fixed::FromInt(50));
+		effective = rangeManager->GetEffectiveParabolicRange(source, target, range, yOrigin);
+		TS_ASSERT_DELTA(effective.ToFloat(), 89.4427f, 0.01f); // ~89.44
+
+		// Source with height offset (Y=15), target on flat ground (Y=0), with yOrigin
+		sourcePos.m_Pos = CFixedVector3D(fixed::Zero(), fixed::FromInt(15), fixed::Zero());
+		targetPos.m_Pos = CFixedVector3D(fixed::Zero(), fixed::Zero(), fixed::FromInt(50));
+		const entity_pos_t yOrigin2{fixed::FromInt(2)};
+		effective = rangeManager->GetEffectiveParabolicRange(source, target, range, yOrigin2);
+		TS_ASSERT_DELTA(effective.ToFloat(), 115.7583f, 0.01f); // ~115.76
+	}
+
+	void test_ParabolicRangeTargetTooHigh()
+	{
+		ComponentTestHelper test(*g_ScriptContext);
+		ICmpRangeManager* rangeManager = test.Add<ICmpRangeManager>(CID_RangeManager, "", SYSTEM_ENTITY);
+
+		const entity_id_t source{200};
+		const entity_id_t target{201};
+
+		MockPositionRgm sourcePos;
+		MockPositionRgm targetPos;
+		test.AddMock(source, IID_Position, sourcePos);
+		test.AddMock(target, IID_Position, targetPos);
+
+		// Source on flat ground (height=0), target very high (height=30)
+		sourcePos.m_Pos = CFixedVector3D(fixed::Zero(), fixed::Zero(), fixed::Zero());
+		targetPos.m_Pos = CFixedVector3D(fixed::Zero(), fixed::FromInt(30), fixed::Zero());
+
+		const entity_pos_t range{fixed::FromInt(50)};
+		const entity_pos_t yOrigin{fixed::Zero()};
+
+		// heightDifference = 0 - 30 = -30, range/2 = 25
+		// -30 < -25 → NEVER_IN_RANGE
+		TS_ASSERT_EQUALS(rangeManager->GetEffectiveParabolicRange(source, target, range, yOrigin), NEVER_IN_RANGE);
+
+		// Target at borderline height (25)
+		targetPos.m_Pos = CFixedVector3D(fixed::Zero(), fixed::FromInt(25), fixed::Zero());
+
+		const entity_pos_t effective = rangeManager->GetEffectiveParabolicRange(source, target, range, yOrigin);
+		TS_ASSERT_DIFFERS(effective, NEVER_IN_RANGE);
+		TS_ASSERT_EQUALS(effective, fixed::Zero());
 	}
 };