上一篇文章介绍了机器人的话术抓取以及双号互聊功能的实现，其实如果只需要无脑水群上篇文章介绍的代码就可以实现这个功能了

discord水群bot教程(1) 双号互聊 脚本

但是在实际使用中我们会发现有些项目方不想让机器人获利,所以他们会对频道内聊天的用户进行bot检测，随着时间推移项目方检测的手段也越来越多，比如@全体成员在指定时间内不要发言，或者@你让你回答一些简单的问题，又或者玩什么123木头人的游戏，总之在这个过程中你如果被逮到那么这个账号基本上就要被送出这个服务器了

所以接下来文章介绍的就是如何利用消息监控,让你避开一些项目方的突击检测

教程开始

项目环境配置等一些基础问题,请参考上篇文章的介绍,这里就不多做说明了

首先我们要监控项目方的检测手段,自然先要获取频道内的聊天消息,然后通过对聊天消息分析来判断是否有人在检查机器人,我们还是F12打开浏览器控制台,然后在网页版discord进入我们需要监控的频道,在浏览器控制台network内找到messages请求

请求参数的介绍可以参考上篇文章,这里我们主要是分析接口返回的数据,我们切换到Preview

可以看到我在频道内分别发送了一条普通消息,一条@指定用户的小,一条@所有人的消息,接下来我们就从请求返回值里来分析这3条消息的区别,首先先介绍下我们接下来需要用到的几个字段的含义

这是一条普通消息,它没有@所有人所以它的mention_everyone是false,它也没@某个用户,所以mentions是一个空数组,接着我们再看看@指定用户的消息返回体和@所有人的消息返回体

这条@指定用户的消息大家可以发现,mentions数组里有一个用户对象,这个就是我们@的那个用户的信息,同时消息的内容content里我们@的用户那部分的文字转换成了<@!用户id>这样一个格式

最后这条消息我们可以看到字段mention_everyone的值变成了true,这就代表这条消息是一个@所有人的消息

经过上面的分析,现在大家应该对区分消息类型有了一定了解,接下来我们就可以来实现我们监控脚本

const axios = require("axios");

const proxyHost = '127.0.0.1' // 代理ip
const proxyPort = '7890' // 代理端口号
const authorization = '' // 账号的authorization
const channel_id = '' //频道id
let monitorTime = new Date().getTime() // 监控时间,用于避免重新识别老消息
const monitor = () => {
    let header = {
        "Authorization": authorization,
        "Content-Type": "application/json",
        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/94.0.4606.61 Safari/537.36"
    }
    axios({
        method: 'GET',
        url: `https://discord.com/api/v9/channels/${channel_id}/messages?limit=50`,
        headers: header,
        proxy: (proxyHost && proxyPort)?{
            host: proxyHost,
            port: proxyPort
        }: null,
    }).then(res => {
        // 对聊天消息进行分析
        messageParse(res.data)
        startTime = new Date().getTime()
    }).catch(e => {
        console.log(e.message)
    })
}

setInterval(function () {// 监听器,每60s执行一次
    monitor()
},60*1000);

首先还是使用axios对messages接口进行调用,通过构建一个定时器来进行监听,当我们拿到聊天的数据也就是上面的res.data,我们把数据传给我们的分析函数messageParse

我这里对消息进行了下面几个识别

• 识别@全员和@自己

• 识别管理发言+发言内容包含关键字

• 仅识别发言内容包含关键字

• 仅识别管理发言

// 管理员用户的id
const mods = [
    '933625356789887006'
]
// 关键字
const keywords = [
    '停止说话','禁止发言','123木头人'
]

/**
 * 判断消息是否含关键字
 */
const isIncludeKeywords = (message) => {
    let flag = false
    keywords.forEach(keyword => {
        if(message.includes(keyword)){// 含关键字的消息
            flag = true
        }
    })
    return flag
}

// 消息信息解析
const messageParse = (data) => {
    // 优先级 @全员 > @自己 > mod发言+含关键字 > 含关键字 > mod发言
    data.forEach(item => {
        if(new Date(item.timestamp).getTime() < monitortTime){// 时间筛选,避免重新识别老消息
            return
        }
        if(item.mention_everyone){// @全体成员的消息
            console.log(`监听到一条@全员的消息:`)
            console.log('-------------------')
            console.log(`消息: ${item.content}`)
            console.log('-------------------')
            // 执行你自己的应对策略
        }else if(item.content.includes(account_id)){// @自己的消息
            console.log(`监听到一条@你的消息:`)
            console.log('-------------------')
            console.log(`消息: ${item.content}`)
            console.log('-------------------')
            // 执行你自己的应对策略
        }else if(mods.includes(item.author.id) && isIncludeKeywords(item.content)){// mod发言+含关键字
            console.log(`监听到一条mod发言+含关键字的消息:`)
            console.log('-------------------')
            console.log(`消息: ${item.content}`)
            console.log('-------------------')
            // 执行你自己的应对策略
        }else if(isIncludeKeywords(item.content)){
            console.log(`监听到含关键字的消息:`)
            console.log('-------------------')
            console.log(`消息: ${item.content}`)
            console.log('-------------------')
            // 执行你自己的应对策略
        }else if(mods.includes(item.author.id)){
            console.log(`监听到一条mod发言的消息:`)
            console.log('-------------------')
            console.log(`消息: ${item.content}`)
            console.log('-------------------')
            // 执行你自己的应对策略
        }
    })

}

可以看到我的消息处理中,首先对消息时间进行了筛选,我们只处理指定时间后的消息,monitortTime的值会随着每次请求结束而更新

然后我按照我的优先级进行消息的判断,如果符合判断条件就会执行你自己设置的应对策略,如:

• 停止运行你的水群脚本

• 对接你的话术库进行自动回复又或者接入ai回复进行自动回复

• 接入你的消息推送,把消息推送到微信或者邮件,让你第一时间知道,然后亲自来进行处理

你也可以针对不同情况的紧急程度进行分级应对,这些将由你自己来决定了,这篇教程就到这了,完整代码稍后会上传到github,将按照class1 class2分支来区分

课程2代码地址

来自DFarm Club

-----------------------------------------分割线-----------------------------------------

答应大家的GUI版本已经上传github了,代码在main分支,打包好的exe放在Releases

功能基本上就是前两篇课程内介绍过的内容,不会使用可以参考课程内的代码实现

前言

本篇文章主要是实现一个discord自动水群机器人

计划功能大概就是 话术抓取、双号互聊、关键词检测、mod发言检测等一些市面上discord bot比较常见的一些功能，最后会提供一个可以开箱即用的带GUI的成品程序(大概)，教程的代码会同步更新在Github上

教程有些许技术门槛，主要涉及node.js和一些依赖库的使用，基本上有入门的基础就可以看懂了，不会的小伙伴可以自学下node.js或者等后续成品exe

教程开始

第一篇主要是实现话术抓取以及双号互聊这两个功能,先来实现话术抓取

首先准备好node环境，在终端内输入以下命令

mkdir discord-bot

cd discord-bot

npm init-y

npm install axios

新建一个getChatRecord.js，话术抓取需要使用http请求获取频道内的聊天记录然后将内容保存到本地，所以我们需要在js内引入http模块 axios 和 文件系统模块fs

const axios = require("axios");
const fs = require('fs');

要使用http获取聊天记录我们需要知道具体请求的url

在浏览器内按F12打开控制台，找到network栏，然后点击clear图标清除历史请求记录

接着我们在discord进入想要抓取聊天记录的频道，然后在控制台找到一条name为message的请求，点击请求后可以查看Preview可以看到请求返回的内容就是频道内的聊天记录

ok，那么这条请求就是获取聊天记录的请求，我们点击Headers可以看到这个请求是一个get请求，参数也在请求url内，这一串数字就是频道id，后面limit就是这次查询获取的数量，Request Headers中的authorization就是你的用户token，知道url，参数，鉴权我们就可以自己构建请求了

具体实现

const axios = require("axios");
const fs = require('fs');
const authorization = ‘你的authorization’

const proxyHost = '127.0.0.1' // 代理ip
const proxyPort = '7890' // 代理端口号

/**
 * 爬取指定频道聊天记录（爬取话术）
 * @param {*} channel_id 频道id
 * @param {*} amount 抓取数量（50的倍数）
 */
 const getChatRecord = async (channel_id,amount=50,) => {
    return new Promise(async (resolve, reject) => {
        let recordList = []
        let beforeId = ''
        const getChatRecordLimit = () => {
            let beforeQuery = beforeId?`before=${beforeId}&`:''
            let header = {
                "Authorization": authorization,
                "Content-Type": "application/json",
                "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/94.0.4606.61 Safari/537.36"
            }
            axios({
                method: 'GET',
                url: `https://discord.com/api/v9/channels/${channel_id}/messages?${beforeQuery}limit=50`,
                headers: header,
                proxy: (proxyHost && proxyPort)?{
                    host: proxyHost,
                    port: proxyPort
                }: null,
            }).then(res => {
                let data = res.data
                data.forEach(v => {
                    recordList.push(v.content)
                })
                if(recordList.length<amount){
                    beforeId = data[data.length-1].id
                    getChatRecordLimit()
                }else{
                    recordList.forEach(v => {
                        writeOutput(`${v}\n`);
                    })
                    console.log('话术抓取成功')
                    resolve()
                }
            }).catch(e => {
                reject(e)
                console.log(e.message)
            })
        }
        getChatRecordLimit()
    })
}

function writeOutput(data) {
    fs.appendFile('话术.txt', data, function (err) {
        if (err) throw err;
    });
}

getChatRecord('频道id',数量)

因为discord默认请求查询数量是50，所以需要大量的聊天记录的话我就不篡改他的请求数量了，而是通过循环调用来实现查询指定数量的聊天记录

writeOutput函数是利用fs模块将获取到的聊天内容保存到当前目录的话术.txt内，这样我们的话术抓取功能就实现好了，我们再终端输入node getChatRecord.js就可以运行了

话术抓取完毕后我们继续看看互聊的实现

既然是互聊那肯定需要发送普通消息和发送回复消息，我们打开F12控制台，在频道内输入文字后还是找到一条name为messages的请求

这次我们可以看到是一个post请求，url内只包含了频道id，那么我们切换到Payload看下传参

可以看到参数有3个，content就是你发送的内容，nonce是一个随机数，tts默认都是false我们可以不用管它

接着我们在频道内回复一条消息，然后继续查找控制台内的messages请求

这次请求参数多了一个message_reference的对象，这个对象内有三个参数，分别是频道id，群id，回复的那条消息的id，知道这些参数后我们就可以构建我们的聊天函数

首先准备两个discord账号，获取好账号的authorization，以及需要聊天的群id和频道id，新建一个txt_list.txt的文本文件，把之前抓取到的话术整理好放入其中，一行就是一条消息，比如第一行由账号1发送，第二天就是由账号2发送，第三条是账号1发送这样循环

我们新建一个chat.js 下面是具体代码实现

const fs = require('fs');
const axios = require("axios");

const proxyHost = '127.0.0.1' // 代理ip
const proxyPort = '7890' // 代理端口号

const guild_id = '' // 群id
const channel_id = '' // 频道id
let message_id = '' // 回复的消息id
const account1 = '' // 账号1的authorization
const account2 = '' // 账号2的authorization

const time = 10 // 聊天间隔 单位:秒
const responeAt = 0.5 // 1 开启对话@ 0关闭对话@ 0.1-0.9 概率@
let counter = 0 // 计数器

// 从txt读取话术
const text_list = fs.readFileSync('text_list.txt').toString().split('\n');


/**
 * 开聊
 */
const chat_star = () => {
    // 用计数器判断当前使用账号1还是账号2发送消息
    let authorization = counter % 2 === 0 ? account1 : account2
    
    let header = {
        "Authorization": authorization,
        "Content-Type": "application/json",
        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/94.0.4606.61 Safari/537.36"
    }
    let msg = {
        "content": text_list[counter],
        "nonce": `94158662701${Math.ceil(Math.random()*1000)}213056`,
        "tts": false
    }
    if(isResponeAt() && !!message_id){
        msg.message_reference = {
            channel_id: channel_id,
            guild_id: guild_id,
            message_id: message_id
        }
    }
    axios({
        method: 'POST',
        url: `https://discord.com/api/v9/channels/${channel_id}/messages`,
        headers: header,
        proxy: (proxyHost && proxyPort)?{
            host: proxyHost,
            port: proxyPort
        }: null,
        data: msg
    }).then(res => {
        let data = res.data
        message_id = data.id
        console.log(`[${data.author.username}]发送成功: ${data.content}`)
        counter++
    })
}

/**
 * 是否为回复消息
 */
const isResponeAt = () => {
    if(responeAt === 1){
        return true
    }else if(responeAt === 0){
        return false
    }else{
        return Math.round(Math.random()*10) < responeAt*10
    }
}

const sleep = (ms) => {
    return new Promise((resolve) => setTimeout(resolve, ms));
};

const main = async () => {
    while (counter<text_list.length) {
        chat_star()
        await sleep(time*1000)
    }
}
main()

为了避免全程相互回复聊天别人发现异常，封装了一个判断当前是否为回复消息的函数 isResponseAt，通过配置参数responseAt来控制(1: 全程回复聊天 0：全程普通聊天 0.1-0.9：概率是回复消息，比如0.5就是每次发送消息都是二分之一的可能是回复消息)

其他就没啥了，功能其实还是挺简单的，我们在终端输入node chat.js就可以运行了，目前代码是判断text_list内的话术聊完就停止了，如果需要无限循环聊下去或者聊够指定条就停可以自己稍微改改就行,下面是设置0.5概率的运行效果

第一篇就先写到这,项目代码稍后会打包到github

课程1地址

github上的代码 运行所需配置项统一放到.env文件里了,下载后把项目内的.env.example改为.env,在其中配置即可

来自DFarm Club