@miner-org/mineflayer-bot-war 0.0.2

package/index.d.ts

@@ -0,0 +1,19 @@
+import { BotWarClient } from "./src/types/BotWarClient";
+import { WarClientOptions } from "./src/types/WarClientOptions";
+
+interface BotWarPlugin {
+  client: BotWarClient;
+  connect(options: WarClientOptions): void;
+}
+
+declare module "@miner-org/mineflayer-bot-war" {
+  import { Bot } from "mineflayer";
+
+  export function loader(bot: Bot): void;
+}
+
+declare module "mineflayer" {
+  interface Bot {
+    botwar: BotWarPlugin;
+  }
+}

package/index.js

@@ -0,0 +1,7 @@
+const BotWarPlugin = require("./src/BotWarPlugin");
+
+function loader(bot) {
+  bot.botwar = new BotWarPlugin(bot);
+}
+
+module.exports = loader;

package/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "@miner-org/mineflayer-bot-war",
+  "version": "0.0.2",
+  "main": "index.js",
+  "scripts": {
+    "git-update": "git add . && git commit -m \"my butt hurts\" && git push",
+    "npm-publish-patch": "npm version patch && npm publish --access public && git push origin main --tags",
+    "npm-publish-minor": "npm version minor && npm publish --access public && git push origin main --tags",
+    "npm-publish-major": "npm version major && npm publish --access public && git push origin main --tags",
+    "update-all-patch": "npm run git-update && npm run npm-publish-patch",
+    "update-all-minor": "npm run git-update && npm run npm-publish-minor",
+    "update-all-major": "npm run git-update && npm run npm-publish-major"
+  },
+  "keywords": [],
+  "author": "Ash",
+  "license": "ISC",
+  "description": "A mineflayer plugin for the java plugin bot-war",
+  "dependencies": {
+    "ws": "^8.19.0"
+  },
+  "devDependencies": {
+    "mineflayer": "^4.25.0"
+  }
+}

package/src/BotWarClient.js

@@ -0,0 +1,82 @@
+const EventEmitter = require("events");
+const { WebSocket } = require("ws");
+const { v4: uuid } = require("uuid");
+
+class BotWarClient extends EventEmitter {
+  constructor(options = {}) {
+    super();
+    /**
+     * @type {import ("./types/WarClientOptions").WarClientOptions}
+     */
+    this.options = options;
+    this.ws = new WebSocket(options.url);
+    this.ready = false;
+    this.pending = new Map();
+
+    this.ws.on("open", () => this._authenticate());
+    this.ws.on("message", (data) => this._handleMessage(data.toString()));
+    this.ws.on("close", () => (this.ready = false));
+  }
+
+  _authenticate() {
+    this.ws.send(
+      JSON.stringify({
+        type: "auth",
+        token: this.options.token,
+      }),
+    );
+  }
+
+  _handleMessage(msg) {
+    const packet = JSON.parse(msg);
+    if (packet.type === "auth_ok") {
+      this.ready = true;
+      this.emit("ready");
+      return;
+    }
+
+    if (packet.type === "response" && packet.id) {
+      const cb = this.pending.get(packet.id);
+      if (cb) {
+        this.pending.delete(packet.id);
+        cb(packet.data);
+      }
+      return;
+    }
+
+    if (packet.type === "event") {
+      this.emit(packet.event, packet.data);
+    }
+  }
+
+  request(action, payload = {}) {
+    if (!this.ready) return Promise.reject("BotWar not authenticated");
+
+    return new Promise((resolve) => {
+      const id = uuid();
+      this.pending.set(id, resolve);
+      this.ws.send(JSON.stringify({ type: "request", id, action, payload }));
+    });
+  }
+
+  getTeams() {
+    return this.request("getTeams");
+  }
+
+  getControlPoints() {
+    return this.request("getControlPoints");
+  }
+
+  getTeamScore(teamId) {
+    return this.request("getTeamScore", { teamId });
+  }
+
+  getTeamPlayers(teamId) {
+    return this.request("getTeamPlayers", { teamId });
+  }
+
+  getPlayerTeam(playerName) {
+    return this.request("getPlayerTeam", { playerName });
+  }
+}
+module.exports = BotWarClient;

package/src/BotWarPlugin.js

@@ -0,0 +1,19 @@
+const BotWarClient = require("./BotWarClient.js");
+
+class BotWarPlugin {
+  #bot;
+  constructor(bot) {
+    this.#bot = bot;
+    this.client = null;
+  }
+
+  /**
+   *
+   * @param {import("./types/WarClientOptions.js").WarClientOptions} options
+   */
+  connect(options) {
+    this.client = new BotWarClient(options);
+  }
+}
+
+module.exports = BotWarPlugin;

package/src/types/BotWarClient.ts

@@ -0,0 +1,45 @@
+import TypedEmitter from "typed-emitter";
+
+interface SimpleVec3 {
+  x: number;
+  y: number;
+  z: number;
+}
+
+export interface BotWarClientEvents {
+  ready(): void | Promise<void>;
+  /**
+   *
+   * @param killer The kilelr
+   * @param dead The one that died
+   * @param team The killer's team
+   */
+  playerKilled(
+    killer: string,
+    dead: string,
+    team: string,
+  ): void | Promise<void>;
+  gameStarted(): void | Promise<void>;
+  gameEnd(): void | Promise<void>;
+
+  teamWin(team: string): void | Promise<void>;
+
+  startCapture(position: SimpleVec3, captureTeam: string): void | Promise<void>;
+  /**
+   * @description Fires when a control point is captured
+   * @param position Position of the control point
+   * @param captureTeam The team that captured the point
+   */
+  controlCapture(
+    position: SimpleVec3,
+    captureTeam: string,
+  ): void | Promise<void>;
+}
+
+export interface BotWarClient extends TypedEmitter<BotWarClientEvents> {
+  authenticate(): void;
+
+  request(action: string, data: object): Promise<any>;
+
+  getTeams(): Promise<string[]>;
+}

package/src/types/WarClientOptions.ts

@@ -0,0 +1,4 @@
+export interface WarClientOptions {
+  url: string,
+  token: string,
+}

package/test.js

@@ -0,0 +1,41 @@
+const mineflayer = require("mineflayer");
+const botWarPlugin = require("./index.js");
+
+const bot = mineflayer.createBot({
+  host: "localhost",
+  username: "Frisk",
+  port: 25565,
+  viewDistance: "tiny",
+});
+
+bot.loadPlugin(botWarPlugin);
+
+bot.once("spawn", async () => {
+  await bot.waitForChunksToLoad();
+  bot.botwar.connect({
+    url: "ws://localhost:8765",
+    token: "92389d0ffe1547f1b41939abcc9f0b59",
+  });
+
+  bot.botwar.client.on("ready", async () => {
+    console.log("uwu");
+    const teams = await bot.botwar.client.getTeams();
+
+    console.log(teams);
+  });
+
+  bot.botwar.client.on("gameStarted", async () => {
+    console.log("A game has started");
+    bot.botwar.client.on("startCapture", (pos, team) => {
+      console.log(pos, team);
+    });
+
+    bot.botwar.client.on("controlCapture", (pos, team) => {
+      console.log("Captured", pos, team);
+    });
+  });
+
+  bot.botwar.client.on("gameEnd", () => {
+    console.log("A game has ended");
+  });
+});