Cheater_Detection: update

Author: titaniummachine1

Cheater_Detection/Core/Evidence_system.lua

@@ -55,7 +55,7 @@ Evidence.Config = {
 	Evidence_Tolerance = 50,   -- Evidence threshold % (0–100) to mark as cheater
 	MinWeightFloor = 0,        -- Cannot decay below this
 	AutoPriorityThreshold = 12.0, -- Evidence score threshold to trigger SUSPICIOUS flag
-	ExploitAutoCheaterMin = 70, -- Very high so fake lag alone rarely goes CHEATER
+	ExploitAutoCheaterMin = 70, -- Per-method % of cap; also marks CHEATER (see isExploitAtAutoCheaterMin)
 	MethodScoreCaps = {
 		fake_lag    = 120.0, -- ~24 credits at 5 pts (stricter than old 60 cap)
 		double_tap  = 300.0, -- ~10 usages at DT_USAGE_WEIGHT (30) in double_tap.lua
@@ -242,6 +242,50 @@ local function getEvidenceScoreCap(evidence)
 	return cap
 end
 
+-- Cheater line uses strongest active method cap so a little fake_lag weight does not
+-- inflate the bar when double_tap is already near cap (sum cap would be 300+120=420).
+local function getEvidenceMaxMethodCap(evidence)
+	local maxCap = 0
+	if evidence and evidence.Reasons then
+		for method, reason in pairs(evidence.Reasons) do
+			if reason.Weight and reason.Weight > 0 then
+				maxCap = math.max(maxCap, getMethodScoreCap(method))
+			end
+		end
+	end
+	if maxCap <= 0 then
+		return 200.0
+	end
+	return maxCap
+end
+
+local exploitMethodSet = nil
+local function isExploitMethod(detectionName)
+	if not exploitMethodSet then
+		exploitMethodSet = {}
+		for _, name in ipairs(Evidence.Config.Categories.Exploit or {}) do
+			exploitMethodSet[name] = true
+		end
+	end
+	return exploitMethodSet[detectionName] == true
+end
+
+local function isExploitAtAutoCheaterMin(evidence)
+	local minPct = Evidence.Config.ExploitAutoCheaterMin or 70
+	if not evidence or not evidence.Reasons then
+		return false
+	end
+	for method, reason in pairs(evidence.Reasons) do
+		if isExploitMethod(method) and reason.Weight and reason.Weight > 0 then
+			local cap = getMethodScoreCap(method)
+			if reason.Weight >= cap * (minPct / 100) then
+				return true
+			end
+		end
+	end
+	return false
+end
+
 local function getEvidencePercent(evidence)
 	local cap = getEvidenceScoreCap(evidence)
 	local score = evidence and evidence.TotalScore or 0
@@ -292,6 +336,7 @@ local function syncPlayerStateFromEvidence(steamID, evidence)
 	local primaryMethod, onlyFakeLag = getPrimaryMethod(evidence)
 	local shouldMarkSuspicious = evidence.TotalScore >= threshold
 	local shouldMarkCheater = evidence.TotalScore >= cheaterThreshold
+		or isExploitAtAutoCheaterMin(evidence)
 
 	-- Track active evidence to prevent double-decay in player_cache
 	if evidence.TotalScore > 0 then
@@ -393,7 +438,7 @@ end
 
 function Evidence.GetCheaterThreshold(evidence)
 	local pct = getMenuPercent("Evidence_Tolerance", 85)
-	return getEvidenceScoreCap(evidence) * (pct / 100)
+	return getEvidenceMaxMethodCap(evidence) * (pct / 100)
 end
 
 function Evidence.GetMethodScoreCap(detectionName)

Cheater_Detection/Utils/Commands.lua

@@ -8,6 +8,8 @@ local SteamHistory = require("Cheater_Detection.Database.SteamHistory")
 local Config = require("Cheater_Detection.Utils.Config")
 local Common = require("Cheater_Detection.Utils.Common")
 local DoubleTap = require("Cheater_Detection.detectors.double_tap")
+local FakeLag = require("Cheater_Detection.detectors.fake_lag")
+local DetectionConfig = require("Cheater_Detection.Utils.DetectionConfig")
 local PlayerCache = require("Cheater_Detection.Core.player_cache")
 
 local Commands = {}
@@ -241,6 +243,59 @@ local function setupDiagnostics()
 		printc(200, 200, 200, 255, string.format("  conn block   : %s", tostring(stats.connectionBlock)))
 		printc(200, 200, 200, 255, string.format("  listen bypass: %s", tostring(stats.localListenBypass)))
 		printc(200, 200, 200, 255, string.format("  model        : %s", tostring(stats.model)))
+		printc(200, 200, 200, 255, string.format("  simtime ring : %d ticks (%d delta pairs)",
+			stats.simtimeRetention or 0, (stats.simtimeRetention or 1) - 1))
+		printc(200, 200, 200, 255, string.format("  DT scan      : recent=%d watch=%d",
+			stats.dtRecentScanDeltas or 0, stats.dtWatchingScanDeltas or 0))
+	end)
+
+	Commands.Register("cd_fl_status", function(_args)
+		local block = FakeLag.GetDetectionBlockReason()
+		printc(100, 220, 255, 255, "[CD] FakeLag diagnostic:")
+		printc(200, 200, 200, 255, "  min FPS need  : >= 40 (smoothed)")
+		printc(200, 200, 200, 255, string.format("  allowed       : %s", tostring(FakeLag.IsDetectionAllowed())))
+		printc(200, 200, 200, 255, string.format("  block reason  : %s", block or "none"))
+	end)
+
+	Commands.Register("cd_simhistory", function(args)
+		local targets = DetectionConfig.SimtimeScanTargets
+		local limits = DetectionConfig.GetSimtimeScanLimits()
+
+		if not args or not args[1] or args[1] == "" then
+			printc(100, 220, 255, 255, "[CD] Simtime history (FakeLag + DoubleTap):")
+			printc(200, 200, 200, 255, string.format(
+				"  retention     : %d ticks  (max %d simtime delta pairs)",
+				limits.retentionTicks, limits.maxDeltaPairs))
+			printc(200, 200, 200, 255, string.format(
+				"  effective scan: FL=%d  DT recent=%d  DT watch=%d",
+				limits.flScan, limits.dtRecent, limits.dtWatching))
+			printc(200, 200, 200, 255, string.format(
+				"  targets       : FL=%d  DT recent=%d  DT watch=%d (clamp to ring)",
+				targets.FlScanDeltas, targets.DtRecentScanDeltas, targets.DtWatchingScanDeltas))
+			printc(255, 200, 100, 255, string.format(
+				"  floor: retention >= %d (FL scan %d, DT scan %d)",
+				DetectionConfig.GetSimtimeMinRetentionTicks(),
+				targets.FlScanDeltas, targets.DtRecentScanDeltas))
+			printc(180, 180, 180, 255, "  Usage: cd_simhistory <ticks>  — default 25; lower will be rejected")
+			printc(180, 180, 180, 255, "  Test 330ms FL + full-rage DT after each change; redeploy not required.")
+			return
+		end
+
+		local ok, err = DetectionConfig.SetSimtimeRetentionTicks(args[1])
+		if not ok then
+			printc(255, 100, 100, 255, "[CD] cd_simhistory: " .. tostring(err))
+			return
+		end
+
+		limits = DetectionConfig.GetSimtimeScanLimits()
+		printc(100, 255, 150, 255, string.format(
+			"[CD] Simtime retention set to %d ticks (ring reset). Scans: FL=%d DT recent=%d watch=%d",
+			limits.retentionTicks, limits.flScan, limits.dtRecent, limits.dtWatching))
+		if limits.maxDeltaPairs < DetectionConfig.GetSimtimeMaxScanDeltas() then
+			printc(255, 100, 100, 255, string.format(
+				"[CD] WARNING: only %d delta pairs — increase retention to at least %d.",
+				limits.maxDeltaPairs, DetectionConfig.GetSimtimeMinRetentionTicks()))
+		end
 	end)
 end
 

Cheater_Detection/Utils/DetectionConfig.lua

@@ -17,15 +17,23 @@ DetectionConfig.Detectors = {
 			HistoryManager.Fields.EyePosition,
 		},
 	},
-	-- Simtime + precomputed tick gaps (HistoryManager). FakeLag/DoubleTap only read deltas.
+	-- Simtime ring: 25 ticks => 24 delta pairs. Scans read only newest N gaps (see GetSimDeltaDeltas).
+	-- Live tune: cd_simhistory <ticks>  (floor = GetSimtimeMinRetentionTicks()).
 	Simtime = {
-		retentionTicks = 40,
+		retentionTicks = 25,
 		fields = { HistoryManager.Fields.SimulationTime },
 	},
 }
 
 DetectionConfig.DefaultRetentionTicks = 24
 
+-- Per-detector scan depths (clamped to retention - 1). Ring sized for DT (24), not FL (20).
+DetectionConfig.SimtimeScanTargets = {
+	FlScanDeltas          = 20, -- rhythm/sustained/choke-hold windows <= 20
+	DtRecentScanDeltas    = 24, -- DT band [24,34); one gap can be 24t
+	DtWatchingScanDeltas  = 24,
+}
+
 function DetectionConfig.GetRetentionTicks()
 	local maxTicks = DetectionConfig.DefaultRetentionTicks
 	for _, spec in pairs(DetectionConfig.Detectors) do
@@ -36,6 +44,68 @@ function DetectionConfig.GetRetentionTicks()
 	return maxTicks
 end
 
+function DetectionConfig.GetSimtimeRetentionTicks()
+	local spec = DetectionConfig.Detectors.Simtime
+	return spec and spec.retentionTicks or DetectionConfig.DefaultRetentionTicks
+end
+
+function DetectionConfig.GetSimtimeMaxDeltaPairs()
+	return math.max(0, DetectionConfig.GetSimtimeRetentionTicks() - 1)
+end
+
+--- Smallest ring that fits all configured simtime scan depths.
+function DetectionConfig.GetSimtimeMinRetentionTicks()
+	local targets = DetectionConfig.SimtimeScanTargets
+	return math.max(
+		targets.FlScanDeltas + 1,
+		targets.DtRecentScanDeltas + 1,
+		targets.DtWatchingScanDeltas + 1)
+end
+
+function DetectionConfig.GetSimtimeMaxScanDeltas()
+	local targets = DetectionConfig.SimtimeScanTargets
+	return math.max(
+		targets.FlScanDeltas,
+		targets.DtRecentScanDeltas,
+		targets.DtWatchingScanDeltas)
+end
+
+--- Effective scan windows after clamping to ring size (FakeLag / DoubleTap).
+function DetectionConfig.GetSimtimeScanLimits()
+	local targets = DetectionConfig.SimtimeScanTargets
+	local maxPairs = DetectionConfig.GetSimtimeMaxDeltaPairs()
+	local function clampScan(requested)
+		return math.min(math.max(1, requested), maxPairs)
+	end
+	return {
+		retentionTicks = DetectionConfig.GetSimtimeRetentionTicks(),
+		maxDeltaPairs  = maxPairs,
+		flScan         = clampScan(targets.FlScanDeltas),
+		dtRecent       = clampScan(targets.DtRecentScanDeltas),
+		dtWatching     = clampScan(targets.DtWatchingScanDeltas),
+	}
+end
+
+function DetectionConfig.SetSimtimeRetentionTicks(ticks)
+	local targets = DetectionConfig.SimtimeScanTargets
+	local minRetention = DetectionConfig.GetSimtimeMinRetentionTicks()
+	local maxScan = DetectionConfig.GetSimtimeMaxScanDeltas()
+	local n = math.floor(tonumber(ticks) or 0)
+	if n < minRetention then
+		return false, string.format(
+			"retention must be >= %d (FL scan %d, DT scan %d)",
+			minRetention, targets.FlScanDeltas, targets.DtRecentScanDeltas)
+	end
+	if (n - 1) < maxScan then
+		return false, string.format(
+			"retention %d only gives %d pairs; need >= %d for max scan depth %d",
+			n, n - 1, minRetention, maxScan)
+	end
+	DetectionConfig.Detectors.Simtime.retentionTicks = n
+	DetectionConfig.RegisterWithHistoryManager()
+	return true, nil
+end
+
 function DetectionConfig.GetActiveFields()
 	local fields = {}
 	for _, spec in pairs(DetectionConfig.Detectors) do

Cheater_Detection/Utils/HistoryManager.lua

@@ -350,7 +350,8 @@ function HistoryManager.ClearPlayer(steamID)
 	_storedFieldsByPlayer[id] = nil
 end
 
---- Newest-first simtime gaps in ticks (computed once when simtime is stored).
+--- Newest-first simtime gaps in ticks (precomputed on each simtime store).
+--- Only walks the newest maxDeltas gaps (ring may retain more ticks for other detectors).
 ---@return table buf Reused per-player buffer (do not hold across ticks)
 ---@return number count Dense entries in buf[1..count]
 ---@return number sumTicks Sum of buf[1..count]
@@ -365,13 +366,18 @@ function HistoryManager.GetSimDeltaDeltas(history, maxDeltas)
 		history._simDeltaBuf = buf
 	end
 
-	local n = 0
-	local sum = 0
 	local maxPairs = history._count - 1
 	local limit = math.min(maxDeltas or maxPairs, maxPairs)
+	local head = history._head
+	local cap = maxRetentionTicks
+	local n = 0
+	local sum = 0
 	for offset = 0, limit - 1 do
-		local record = HistoryManager.GetRecordAt(history, offset)
-		local tickDelta = record and record._sim_delta_ticks
+		local idx = head - offset
+		if idx < 1 then
+			idx = idx + cap
+		end
+		local tickDelta = history[idx]._sim_delta_ticks
 		if tickDelta ~= nil then
 			n = n + 1
 			buf[n] = tickDelta