sophie/see_leaderboard_bot
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

use rconts

Browse source
This commit is contained in:
Your Name 2025-02-28 23:12:22 +02:00
parent 4be1833d9f
commit 3fce21922c
5 changed files with 64 additions and 304 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

110
advancementAPI.ts
View file

@ -1,86 +1,66 @@
import {Rcon, PacketType} from "./rcon";
import { Rcon } from "rconts";
import { EventEmitter } from "tseep"
import config from "./config.json" assert { type: "json" };
export const apiEvents = new EventEmitter<{
state: (currentUser: string, amount: number, done: number) => void
}>();
const advancements = new Map<string, number>();
let advancementsRequired = 0;
let lastUpdated = 0;
let authenicated = false;
const advancements = new Map<string, number>();
const advancementRegex = /^([^ ]*) has (\d*) \[Advancements\]$/gm;
const playerRegex = /There are \d* whitelisted player\(s\): /gm;
const noAdvancements =
/^Can't get value of bac_advancements for ([^;]*); none is set$/gm;
const client = new Rcon(
config.rcon.host,
config.rcon.port,
config.rcon.password
const client = new Rcon({
host: config.rcon.host,
port: config.rcon.port,
password: config.rcon.password
}
);
let rconReconnectTimeout: Timer | null | undefined;
client.on("connect", () => {
client.on("connected", () => {
console.log("RCON connected.");
});
client.on("auth", () => {
console.log("RCON authenicated.");
client.on("authenicated", () => {
authenicated = true;
});
client.on("end", () => {
console.log("RCON ended. Reconnecting in 2000ms.")
if(rconReconnectTimeout) {
clearTimeout(rconReconnectTimeout);
}
rconReconnectTimeout = setTimeout(() => {
client.connect()
}, 2000)
})
client.on("response", (a: string) => {
if (playerRegex.test(a)) {
const whitelistedPlayers = a.replace(playerRegex, "").split(", ");
advancementsRequired = whitelistedPlayers.length;
for (let i = 0; i < whitelistedPlayers.length; i++) {
setTimeout(() => {
const name = whitelistedPlayers[i];
client.send(`scoreboard players get ${name} bac_advancements`, PacketType.COMMAND);
}, i * 20);
}
}
if (advancementRegex.test(a)) {
advancements.set(
a.replace(advancementRegex, "$1"),
+a.replace(advancementRegex, "$2")
);
}
if (noAdvancements.test(a)) {
advancements.set(a.replace(noAdvancements, "$1"), 0);
}
if (advancements.size == advancementsRequired) {
client.emit("done");
}
});
export function getAdvancements(): Promise<Map<string, number>> {
if (Date.now() - lastUpdated < 60000) {
return Promise.resolve(advancements);
}
lastUpdated = Date.now();
advancements.clear();
return new Promise(async (res, rej) => {
if (!authenicated) {
await new Promise((res2, rej2) => {
client.once("auth", () => {
res2("");
});
client.once("error", () => {
rej2();
});
});
rej("Not authenicated.");
return;
}
const list = await client.exec("whitelist list");
const whitelistedPlayers = list.replace(/There are \d* whitelisted player\(s\): /gm, "").split(", ");
let amount = 0;
apiEvents.emit("state", "-", whitelistedPlayers.length, amount)
for await(const name of whitelistedPlayers) {
const data = await client.exec(`scoreboard players get ${name} bac_advancements`);
const advancementRegex = /^([^ ]*) has (\d*) \[Advancements\]$/gm;
const noAdvancements =
/^Can't get value of bac_advancements for ([^;]*); none is set$/gm;
if (advancementRegex.test(data)) {
advancements.set(
data.replace(advancementRegex, "$1"),
+data.replace(advancementRegex, "$2")
);
} else if (noAdvancements.test(data)) {
advancements.set(data.replace(noAdvancements, "$1"), 0);
}
amount++;
apiEvents.emit("state", name, whitelistedPlayers.length, amount)
}
advancementsRequired = 0;
advancements.clear();
client.send("whitelist list", PacketType.COMMAND);
client.once("done", () => {
res(advancements);
});
});
}
client.connect();

BIN
bun.lockb
View file

Binary file not shown.

19
index.ts
View file

@ -1,10 +1,13 @@
import { getAdvancements } from "./advancementAPI";
import { Client, Events, GatewayIntentBits } from "discord.js";
import { apiEvents, getAdvancements } from "./advancementAPI";
import { Client, Events, GatewayIntentBits, Message } from "discord.js";
import { createCanvas, GlobalFonts } from "@napi-rs/canvas";
import config from "./config.json" assert { type: "json" };
GlobalFonts.registerFromPath("minecraft.otf", "Minecraft");
let lastUpdate = Date.now();
let waiting: Message|undefined;
const client = new Client({
intents: [
GatewayIntentBits.Guilds,
@ -47,15 +50,25 @@ async function makeCanvas(): Promise<Buffer> {
return canvas.toBuffer("image/png");
}
apiEvents.on("state", (currentUser, amount, done) => {
if (Date.now() - lastUpdate > 500) {
lastUpdate = Date.now();
waiting?.edit(`Please wait.. (D/A: ${done}/${amount}, ${currentUser})`)
}
})
client.once(Events.ClientReady, async (readyClient) => {
console.log(`DISCORD connected. ${readyClient.user.tag}`);
});
client.on("messageCreate", async (message) => {
if (message.content == ".lb") {
message.channel.send({
waiting = await message.channel.send("Please wait...")
waiting.edit({
content: "",
files: [await makeCanvas()],
});
}
});

2
package.json
View file

@ -13,6 +13,8 @@
"@napi-rs/canvas": "^0.1.53",
"bufferutil": "^4.0.8",
"discord.js": "^14.15.3",
"node-gyp": "^11.1.0",
"rconts": "git+https://git.sad.ovh/sophie/rconts.git#8f6d5a48330a35f7e4e288b5a3f0104e249aa575",
"ts-rcon": "^1.2.1",
"utf-8-validate": "^6.0.4",
"zlib-sync": "^0.1.9"

235
rcon.ts
View file

@ -1,235 +0,0 @@
import EventEmitter from "events";
import * as net from "net";
import * as dgram from "dgram";
import { Buffer } from "buffer";
import type TypedEmitter from "typed-emitter";
type Events = {
error: (error: Error) => void;
auth: () => void;
response: (response: string) => void;
connect: () => void;
end: () => void;
done: () => void;
};
export const PacketType = {
COMMAND: 0x02,
AUTH: 0x03,
RESPONSE_VALUE: 0x00,
RESPONSE_AUTH: 0x02,
};
interface Options {
tcp?: boolean;
challenge?: boolean;
id?: number;
}
export class Rcon extends (EventEmitter as new () => TypedEmitter<Events>) {
private host: string;
private port: number;
private password: string;
private rconId: number;
private hasAuthed: boolean;
private outstandingData: Uint8Array | null;
private tcp: boolean;
private challenge: boolean;
private _challengeToken: string;
private _tcpSocket!: net.Socket;
private _udpSocket!: dgram.Socket;
constructor(host: string, port: number, password: string, options?: Options) {
super();
options = options || {};
this.host = host;
this.port = port;
this.password = password;
this.rconId = options.id || 0x0012d4a6; // This is arbitrary in most cases
this.hasAuthed = false;
this.outstandingData = null;
this.tcp = options.tcp ? options.tcp : true;
this.challenge = options.challenge ? options.challenge : true;
this._challengeToken = "";
}
public send = (data: string, cmd?: number, id?: number): void => {
let sendBuf: Buffer;
if (this.tcp) {
cmd = cmd || PacketType.COMMAND;
id = id || this.rconId;
const length = Buffer.byteLength(data);
sendBuf = Buffer.alloc(length + 14);
sendBuf.writeInt32LE(length + 10, 0);
sendBuf.writeInt32LE(id, 4);
sendBuf.writeInt32LE(cmd, 8);
sendBuf.write(data, 12);
sendBuf.writeInt16LE(0, length + 12);
} else {
if (this.challenge && !this._challengeToken) {
this.emit("error", new Error("Not authenticated"));
return;
}
let str = "rcon ";
if (this._challengeToken) str += this._challengeToken + " ";
if (this.password) str += this.password + " ";
str += data + "\n";
sendBuf = Buffer.alloc(4 + Buffer.byteLength(str));
sendBuf.writeInt32LE(-1, 0);
sendBuf.write(str, 4);
}
this._sendSocket(sendBuf);
};
private _sendSocket = (buf: Buffer) => {
if (this._tcpSocket) {
this._tcpSocket.write(buf.toString("binary"), "binary");
} else if (this._udpSocket) {
this._udpSocket.send(buf, 0, buf.length, this.port, this.host);
}
};
public connect = (): void => {
if (this.tcp) {
this._tcpSocket = net.createConnection(this.port, this.host);
this._tcpSocket.on("data", (data) => {
this._tcpSocketOnData(data);
});
this._tcpSocket.on("connect", () => {
this.socketOnConnect();
});
this._tcpSocket.on("error", (err) => {
//this.emit("error", err);
this.socketOnEnd()
});
this._tcpSocket.on("end", () => {
this.socketOnEnd();
});
} else {
this._udpSocket = dgram.createSocket("udp4");
this._udpSocket
.on("message", (data) => {
this._udpSocketOnData(data);
})
.on("listening", () => {
this.socketOnConnect();
})
.on("error", (err) => {
this.emit("error", err);
})
.on("close", () => {
this.socketOnEnd();
});
this._udpSocket.bind(0);
}
};
public disconnect = (): void => {
if (this._tcpSocket) this._tcpSocket.end();
if (this._udpSocket) this._udpSocket.close();
};
public setTimeout = (timeout: number, callback: () => void): void => {
if (!this._tcpSocket) return;
this._tcpSocket.setTimeout(timeout, () => {
this._tcpSocket.end();
if (callback) callback();
});
};
private _udpSocketOnData = (data: Buffer) => {
const a = data.readUInt32LE(0);
if (a === 0xffffffff) {
const str = data.toString("utf-8", 4);
const tokens = str.split(" ");
if (
tokens.length === 3 &&
tokens[0] === "challenge" &&
tokens[1] === "rcon"
) {
this._challengeToken = tokens[2]
.substring(0, tokens[2].length - 1)
.trim();
this.hasAuthed = true;
this.emit("auth");
} else {
this.emit("response", str.substring(1, str.length - 2));
}
} else {
this.emit("error", new Error("Received malformed packet"));
}
};
private _tcpSocketOnData = (data: Buffer) => {
if (this.outstandingData != null) {
data = Buffer.concat(
[this.outstandingData, data],
this.outstandingData.length + data.length
);
this.outstandingData = null;
}
while (data.length) {
const len = data.readInt32LE(0);
if (!len) return;
const id = data.readInt32LE(4);
const type = data.readInt32LE(8);
if (len >= 10 && data.length >= len + 4) {
if (id === this.rconId) {
if (!this.hasAuthed && type === PacketType.RESPONSE_AUTH) {
this.hasAuthed = true;
this.emit("auth");
} else if (type === PacketType.RESPONSE_VALUE) {
// Read just the body of the packet (truncate the last null byte)
// See https://developer.valvesoftware.com/wiki/Source_RCON_Protocol for details
let str = data.toString("utf8", 12, 12 + len - 10);
if (str.charAt(str.length - 1) === "\n") {
// Emit the response without the newline.
str = str.substring(0, str.length - 1);
}
this.emit("response", str);
}
} else {
this.emit("error", new Error("Authentication failed"));
}
data = data.slice(12 + len - 8);
} else {
// Keep a reference to the chunk if it doesn't represent a full packet
this.outstandingData = data;
break;
}
}
};
public socketOnConnect = (): void => {
this.emit("connect");
if (this.tcp) {
this.send(this.password, PacketType.AUTH);
} else if (this.challenge) {
const str = "challenge rcon\n";
const sendBuf = Buffer.alloc(str.length + 4);
sendBuf.writeInt32LE(-1, 0);
sendBuf.write(str, 4);
this._sendSocket(sendBuf);
} else {
const sendBuf = Buffer.alloc(5);
sendBuf.writeInt32LE(-1, 0);
sendBuf.writeUInt8(0, 4);
this._sendSocket(sendBuf);
this.hasAuthed = true;
this.emit("auth");
}
};
public socketOnEnd = (): void => {
this.emit("end");
this.hasAuthed = false;
};
}