跳至主要內容

17. 反作弊

EVOCOSMOS2026/4/13大约 16 分钟

反作弊

游戏做出来了，玩家也来了。然后你发现：排行榜上出现了一个 1 秒通关的玩家，有人金币显示 999999999，有人在地图上瞬移。

这些人就是作弊者。如果不处理，正常玩家会愤怒地离开，你的游戏就废了。

为什么需要反作弊

打个比方：你办了一场跑步比赛，奖金丰厚。有人骑自行车参赛、有人抄近道、有人在终点线前坐出租车。如果不制止这些行为，认真跑步的人以后再也不会来参加你的比赛了。

游戏也是一样：

作弊行为对正常玩家的影响
修改金币/钻石经济系统崩溃，正常玩家的努力毫无意义
修改战斗力数值竞技不公平，正常玩家被打得毫无还手之力
透视/自瞄竞技类游戏直接没法玩
自动刷怪/外挂排行榜被霸占，活动奖励被抢光
加速/瞬移破坏所有人的游戏体验

重要性

反作弊不是锦上添花，而是生死攸关。 一个热门游戏如果没有反作弊机制，作弊者会在几周内毁掉整个游戏生态。正常玩家流失后，作弊者也会因为"没正常人可以欺负"而离开。

要从游戏设计的第一天起就考虑反作弊，而不是出了问题再补救。

作弊者怎么作弊

要防作弊，首先要了解作弊者有哪些手段：

第一类：修改客户端数据

原理：直接修改游戏运行时的内存数据。

作弊方式原理举例
内存修改器扫描并修改游戏内存中的数值用 Cheat Engine 把金币从 100 改成 99999
存档修改直接编辑存档文件打开 JSON 存档，把等级从 1 改成 99
代码注入向游戏进程注入自定义代码修改移动速度的变量，让角色跑得飞快

第二类：篡改网络通信

原理：拦截客户端和服务器之间的消息，修改后再发送。

正常流程：客户端发送"我打了敌人一下" → 服务器验证 → 扣敌人血
作弊流程：客户端发送"我打了敌人一下，伤害 999999" → 服务器没有验证 → 敌人直接死了

第三类：使用外挂程序

原理：独立的程序，通过读取内存或模拟输入来作弊。

外挂类型说明
透视外挂读取游戏内存，显示所有敌人的位置
自动瞄准自动计算射击角度，百发百中
自动打怪自动寻路、自动打怪、自动拾取
加速外挂修改游戏时钟，让所有动作变快

第四类：利用漏洞

原理：利用游戏逻辑中的 bug 来获利。

漏洞类型举例
复制物品漏洞交易时断网，物品同时在两个人手里
穿墙漏洞在特定位置卡进墙里，可以偷看对方
无限刷奖励反复领取同一个活动奖励

反作弊的核心原则

原则一：永远不要信任客户端

这是反作弊的第一法则。客户端就是玩家手里的程序，玩家可以随意修改它。

所有关键逻辑都必须在服务器上执行：

操作客户端只做服务器负责
移动发送"我要向左走"计算新位置，检查是否合法（没有穿墙、没有瞬移）
攻击发送"我要攻击"计算伤害，检查是否在攻击范围内
交易发送"我要交易"检查双方物品是否足够，执行物品转移
摸牌发送"我要摸牌"决定摸什么牌，发给客户端

记住

客户端只是"显示器 + 遥控器"。 所有真正的"计算"都在服务器上做。客户端告诉服务器"我按了什么键"，服务器告诉客户端"你应该显示什么画面"。

原则二：服务端校验一切

每个从客户端发来的请求，服务器都要校验：

校验项说明举例
合法性这个操作在当前状态下允许吗？没轮到你就不能出牌
范围校验数值在合理范围内吗？一次攻击伤害不能超过 999
频率校验这个玩家操作太频繁了吗？1 秒内发送了 100 次攻击请求
状态校验玩家状态允许这个操作吗？已经死了就不能攻击
资源校验玩家有足够的资源吗？买道具前检查金币够不够

原则三：纵深防御

不要只靠一层防护，要多层叠加：

第一层：客户端校验（防止小白作弊，体验好）
第二层：服务器校验（核心防线，必须严格）
第三层：行为分析（发现异常模式）
第四层：玩家举报 + 人工审核（兜底方案）

服务端校验实现

请求校验框架

C
// 服务端请求校验框架
using Godot;
using System;

public partial class ServerValidator : Node
{
    // 校验结果
    public class ValidationResult
    {
        public bool IsValid { get; set; }
        public string ErrorMessage { get; set; }
        public static ValidationResult Ok => new() { IsValid = true };
        public static ValidationResult Fail(string msg) =>
            new() { IsValid = false, ErrorMessage = msg };
    }

    // 玩家上下文——记录每个玩家的状态
    private class PlayerContext
    {
        public int PlayerId { get; set; }
        public double LastActionTime { get; set; }
        public int ActionsThisSecond { get; set; }
        public Vector2 LastPosition { get; set; }
        public double LastPositionTime { get; set; }
    }

    private Dictionary<int, PlayerContext> _players = new();

    // 校验移动请求
    public ValidationResult ValidateMove(int playerId, Vector2 newPosition)
    {
        var ctx = GetPlayerContext(playerId);

        // 1. 频率校验：每秒最多 20 次移动请求
        ctx.ActionsThisSecond++;
        if (ctx.ActionsThisSecond > 20)
            return ValidationResult.Fail("移动请求过于频繁");

        // 2. 速度校验：一帧内移动距离不能超过最大速度
        double now = Time.GetTicksMsec() / 1000.0;
        double deltaTime = now - ctx.LastPositionTime;

        if (deltaTime > 0 && ctx.LastPosition != Vector2.Zero)
        {
            float distance = ctx.LastPosition.DistanceTo(newPosition);
            float maxSpeed = 400.0f; // 最大移动速度（像素/秒）
            float maxDistance = maxSpeed * (float)deltaTime;

            // 允许 20% 的误差（网络延迟导致的时间差）
            if (distance > maxDistance * 1.2f)
            {
                GD.Print($"玩家 {playerId} 疑似瞬移：" +
                    $"距离 {distance:F0}，最大允许 {maxDistance:F0}");
                return ValidationResult.Fail("移动距离异常");
            }
        }

        // 3. 边界校验：位置不能超出地图范围
        if (newPosition.X < 0 || newPosition.X > 2000 ||
            newPosition.Y < 0 || newPosition.Y > 1500)
        {
            return ValidationResult.Fail("位置超出地图边界");
        }

        // 更新上下文
        ctx.LastPosition = newPosition;
        ctx.LastPositionTime = now;

        return ValidationResult.Ok;
    }

    // 校验攻击请求
    public ValidationResult ValidateAttack(
        int playerId, Vector2 attackerPos, Vector2 targetPos, int damage)
    {
        // 1. 伤害范围校验
        const int MaxDamage = 999;
        if (damage <= 0 || damage > MaxDamage)
            return ValidationResult.Fail($"伤害值 {damage} 不在合法范围内 [1, {MaxDamage}]");

        // 2. 攻击距离校验
        float distance = attackerPos.DistanceTo(targetPos);
        float maxAttackRange = 150.0f; // 近战最大攻击距离

        if (distance > maxAttackRange)
            return ValidationResult.Fail(
                $"攻击距离 {distance:F0} 超过最大范围 {maxAttackRange}");

        // 3. 频率校验：每秒最多 3 次攻击
        var ctx = GetPlayerContext(playerId);
        ctx.ActionsThisSecond++;
        if (ctx.ActionsThisSecond > 3)
            return ValidationResult.Fail("攻击过于频繁");

        return ValidationResult.Ok;
    }

    // 校验交易请求
    public ValidationResult ValidateTrade(
        int fromPlayer, int toPlayer, int itemId, int count)
    {
        // 1. 数量校验
        if (count <= 0 || count > 999)
            return ValidationResult.Fail("交易数量不合法");

        // 2. 不能和自己交易
        if (fromPlayer == toPlayer)
            return ValidationResult.Fail("不能和自己交易");

        // 3. 检查物品是否存在（需要查询数据库/缓存）
        // var hasItem = CheckPlayerHasItem(fromPlayer, itemId, count);
        // if (!hasItem) return ValidationResult.Fail("物品不足");

        return ValidationResult.Ok;
    }

    // 每秒重置操作计数
    public override void _Process(double delta)
    {
        // 定期重置每秒操作计数（简化实现）
    }

    private PlayerContext GetPlayerContext(int playerId)
    {
        if (!_players.ContainsKey(playerId))
            _players[playerId] = new PlayerContext { PlayerId = playerId };
        return _players[playerId];
    }
}

行为分析——用数据发现作弊

除了实时校验，还可以通过分析玩家的行为数据来发现异常。

什么是"正常"行为

指标正常范围异常信号
每秒操作次数3-10 次超过 50 次（可能是脚本/外挂）
移动速度不超过游戏设定最大速度瞬间移动很远
游戏时长每天 0-16 小时连续在线超过 24 小时（可能是挂机脚本）
胜率30%-70%（大多数玩家）胜率超过 95%（可能是自瞄/透视）
资源增长符合游戏经济曲线金币突然增加 100 万（可能是复制漏洞）
点击间隔100-500 毫秒固定 16 毫秒（机器精确间隔，非人类）

统计与告警

C
// 玩家行为监控器
using Godot;
using System.Collections.Generic;

public partial class BehaviorMonitor : Node
{
    // 统计数据
    private class PlayerStats
    {
        public int TotalActions { get; set; }
        public int ActionsThisMinute { get; set; }
        public double TotalOnlineTime { get; set; }
        public double SessionStartTime { get; set; }
        public int GamesPlayed { get; set; }
        public int GamesWon { get; set; }
        public List<double> ClickIntervals { get; set; } = new();
        public double LastClickTime { get; set; }
        public int SuspiciousScore { get; set; }  // 可疑分数
    }

    private Dictionary<int, PlayerStats> _stats = new();

    // 记录玩家操作
    public void RecordAction(int playerId, string actionType)
    {
        var stats = GetOrCreateStats(playerId);
        stats.TotalActions++;
        stats.ActionsThisMinute++;

        // 记录点击间隔（用于检测机器人）
        double now = Time.GetTicksMsec() / 1000.0;
        if (stats.LastClickTime > 0)
        {
            double interval = now - stats.LastClickTime;
            stats.ClickIntervals.Add(interval);

            // 只保留最近 100 次的间隔
            if (stats.ClickIntervals.Count > 100)
                stats.ClickIntervals.RemoveAt(0);
        }
        stats.LastClickTime = now;

        // 检测异常
        CheckAnomalies(playerId, stats);
    }

    // 记录游戏结果
    public void RecordGameResult(int playerId, bool won)
    {
        var stats = GetOrCreateStats(playerId);
        stats.GamesPlayed++;
        if (won) stats.GamesWon++;

        // 胜率异常检测
        if (stats.GamesPlayed >= 20)
        {
            float winRate = (float)stats.GamesWon / stats.GamesPlayed;
            if (winRate > 0.95f)
            {
                GD.Print($"警告：玩家 {playerId} 胜率异常 " +
                    $"({winRate:P0}，{stats.GamesPlayed} 场)");
                stats.SuspiciousScore += 10;
            }
        }
    }

    // 检测异常行为
    private void CheckAnomalies(int playerId, PlayerStats stats)
    {
        // 1. 操作频率异常
        if (stats.ActionsThisMinute > 600)
        {
            GD.Print($"警告：玩家 {playerId} 每分钟操作 {stats.ActionsThisMinute} 次");
            stats.SuspiciousScore += 20;
        }

        // 2. 检测机器精确间隔
        if (stats.ClickIntervals.Count >= 50)
        {
            double avg = 0;
            double variance = 0;
            foreach (var interval in stats.ClickIntervals)
                avg += interval;
            avg /= stats.ClickIntervals.Count;

            foreach (var interval in stats.ClickIntervals)
                variance += (interval - avg) * (interval - avg);
            variance /= stats.ClickIntervals.Count;
            double stdDev = System.Math.Sqrt(variance);

            // 人类点击间隔的标准差通常 > 50ms
            // 机器人的标准差通常 < 5ms
            if (stdDev < 5.0 && avg < 50.0)
            {
                GD.Print($"警告：玩家 {playerId} 疑似使用自动脚本 " +
                    $"(平均间隔 {avg:F1}ms, 标准差 {stdDev:F1}ms)");
                stats.SuspiciousScore += 30;
            }
        }

        // 3. 可疑分数过高，自动封禁
        if (stats.SuspiciousScore >= 100)
        {
            GD.Print($"玩家 {playerId} 可疑分数 {stats.SuspiciousScore}，自动封禁");
            AutoBan(playerId);
        }
    }

    private void AutoBan(int playerId)
    {
        // 自动封禁逻辑（通知账号系统）
        GD.Print($"已自动封禁玩家 {playerId}");
    }

    private PlayerStats GetOrCreateStats(int playerId)
    {
        if (!_stats.ContainsKey(playerId))
        {
            _stats[playerId] = new PlayerStats
            {
                SessionStartTime = Time.GetTicksMsec() / 1000.0
            };
        }
        return _stats[playerId];
    }
}

客户端保护措施

虽然客户端保护不能完全防止作弊，但可以提高作弊门槛：

措施说明效果
代码混淆把代码变量名变成无意义的字符增加逆向难度
内存加密关键数值在内存中加密存储防止简单的内存搜索
完整性校验检测游戏文件是否被修改防止修改资源文件
反调试检测是否有调试器附加增加调试分析难度
心跳检测定期向服务器报告客户端状态检测异常的客户端行为

内存加密示例

C
// 简单的内存加密——防止 Cheat Engine 直接搜索数值
using Godot;
using System;

public partial class SecureValue
{
    private int _encryptedValue;
    private readonly int _key;

    public SecureValue(int initialValue, int key = 0)
    {
        _key = key == 0 ? GD.RandRange(10000, 99999) : key;
        _encryptedValue = initialValue ^ _key;
    }

    // 获取真实值
    public int Value
    {
        get => _encryptedValue ^ _key;
        set => _encryptedValue = value ^ _key;
    }

    // 带校验的设置（检测值是否被外部修改）
    public bool TrySetValue(int newValue, int expectedCurrentValue)
    {
        if (Value != expectedCurrentValue)
        {
            GD.PrintErr("值被外部修改！检测到作弊行为");
            return false;
        }
        Value = newValue;
        return true;
    }
}

// 使用示例
public partial class PlayerInventory : Node
{
    // 金币在内存中不是明文存储的
    private SecureValue _gold;

    public override void _Ready()
    {
        _gold = new SecureValue(1000);
    }

    public int GetGold()
    {
        return _gold.Value;
    }

    public bool SpendGold(int amount)
    {
        int current = _gold.Value;
        if (current < amount)
            return false;

        // 带校验的修改：如果值被外部改过，会失败
        return _gold.TrySetValue(current - amount, current);
    }
}

客户端保护不是万能的

客户端保护只能提高作弊门槛，不能完全阻止作弊。专业的作弊者可以绕过所有客户端保护。真正的防线永远在服务器端。

通信加密

对客户端和服务器之间的通信进行加密，防止中间人攻击（拦截和修改消息）。

加密方式说明适用场景
HTTPS / WSS传输层加密，最基本的要求所有网络通信
消息签名每条消息附带签名，防止篡改关键操作（交易、充值）
消息加密消息体加密，防止窃听敏感数据（密码、支付信息）

HTTPS/WSS 是最低要求

如果你的游戏还在用 HTTP 而不是 HTTPS，或者用 WebSocket 而不是 WSS（WebSocket Secure），请立刻升级。这不仅仅是安全问题，现代浏览器和操作系统已经默认阻止不加密的连接。

封禁与处罚体系

发现作弊者后，需要有合理的处罚机制：

等级处罚适用场景
警告弹窗提示"检测到异常行为"轻微异常，可能是误判
临时封禁禁止登录 1-72 小时确认使用外挂
永久封禁永久禁止登录严重作弊、多次违规
设备封禁封禁设备 ID防止换号继续作弊
数据回滚撤销作弊获得的收益复制漏洞、刷资源

处罚要有梯度

不要一上来就永久封禁。很多"作弊者"可能只是好奇尝试，给一次警告的机会。但如果屡教不改，再加重处罚。同时要提供申诉渠道，防止误封正常玩家。

反作弊检查清单

服务端（必须做）

客户端（尽量做）

运营层面

恭喜你读完了全部 23 章！从游戏构思到数据管理、网络编程、运营变现、高并发应对、反作弊——你现在拥有了从零开始打造一个完整 2D 网络游戏的知识储备。回到 目录 查看附录中的推荐学习路线，继续你的游戏开发之旅。

最近更新:
贡献者: zefeng.peng
EVOCOSMOS
Copyright © 2026 EVOCOSMOS