bedrock-portal 0.4.0 → 0.5.0

package/README.md

@@ -2,7 +2,7 @@
 [![NPM version](https://img.shields.io/npm/v/bedrock-portal.svg)](http://npmjs.com/package/bedrock-portal)
 [![Discord](https://img.shields.io/badge/chat-on%20discord-brightgreen.svg)](https://discord.gg/KTyd9HWuBD)
 
-Handles and creates a Minecraft Bedrock game session which will redirect players to the specified server
+Handles and creates a Minecraft Bedrock game session which will redirect players to the specified server. Join our [Discord](https://discord.com/invite/KTyd9HWuBD) for support.
 
 ## Installation
 ```shell
@@ -57,6 +57,43 @@ main();
 
 Modules are used to extend the functionality of the BedrockPortal class.
 
+### redirectFromRealm
+
+> Requires [bedrock-protocol](https://github.com/PrismarineJS/bedrock-protocol) to be installed. `npm install bedrock-protocol`
+
+Invites players when they join a Realm to the specified server or if they use the chat command. `#.use(Modules.redirectFromRealm, options);`
+
+Options:
+- **clientOptions**: ClientOptions - The client options to use when connecting to the Realm. These are passed directly to a [bedrock-protocol createClient](https://github.com/PrismarineJS/bedrock-protocol/blob/master/docs/API.md#becreateclientoptions--client) function. See the documentation for more information. 
+- **chatCommand**: object - Options for the chat command
+  - **enabled**: boolean - Whether sending the command in chat should trigger an invite (default: true)
+  - **message**: string - The message to send in chat to run the command (default: 'invite')
+  - **cooldown**: number - The cooldown between being able to send the command in chat (default: 60000ms)
+
+```js
+const { BedrockPortal, Modules } = require('bedrock-portal');
+
+const portal = new BedrockPortal(auth, { ... })
+
+portal.use(Modules.redirectFromRealm, {
+  // The client options to use when connecting to the Realm.
+  clientOptions: {
+    realms: {
+      realmInvite: ''
+    }
+  }
+  // Options for the chat command
+  chatCommand: {
+    // Whether sending the command in chat should trigger an invite (optional - defaults to true)
+    enabled: true,
+    // The message to send in chat to run the command (optional - defaults to 'invite')
+    message: 'invite',
+    // The cooldown between being able to send the command in chat (optional - defaults to 60000ms)
+    cooldown: 60000,
+  }
+}
+```
+
 ### autoFriendAdd
 
 Automatically adds the account's followers as friends and invites them to the game. `#.use(Modules.autoFriendAdd);`
@@ -97,7 +134,7 @@ Automatically invites players to the game when they send a message in the chat.
 
 Options:
 - **command**: string - The command to use to invite players (default: 'invite')
-- **checkInterval**: number - How often to check for messages (default: 1000ms)
+- **checkInterval**: number - How often to check for messages (default: 30000ms)
 
 ```js
 const { BedrockPortal, Modules } = require('bedrock-portal');
@@ -111,7 +148,7 @@ portal.use(Modules.inviteOnMessage);
 portal.use(Modules.inviteOnMessage, {
   // The command to use to invite players (optional - defaults to 'invite')
   command: 'invite',
-  // How often to check for messages (optional - defaults to 1000ms)
+  // How often to check for messages (optional - defaults to 30000ms)
   checkInterval: 30000,
 });
 ```

package/examples/realm.js

@@ -0,0 +1,58 @@
+/* eslint-disable no-multi-spaces */
+
+const { BedrockPortal, Modules, Joinability } = require('bedrock-portal');
+const { Authflow, Titles } = require('prismarine-auth');
+
+const main = async () => {
+  const auth = new Authflow('example', './', { authTitle: Titles.MinecraftNintendoSwitch, deviceType: 'Nintendo', flow: 'live' });
+
+  const portal = new BedrockPortal(auth, {
+    ip: 'geyserconnect.net',
+    port: 19132,                               // The port of the server (optional - defaults to 19132)
+    joinability: Joinability.FriendsOfFriends, // The joinability of the session (optional - defaults to Joinability.FriendsOfFriends)
+    disableAltCheck: false,                    // Disables the alt check (optional - defaults to false)
+  });
+
+  portal.use(Modules.redirectFromRealm, {      // Automatically invite players to the server when they join a Realm
+    clientOptions: {                           // Options for the bedrock-protocol client, see https://github.com/PrismarineJS/bedrock-protocol for options
+      realms: {
+        realmId: '',                           // The realm ID of the realm to invite players from
+        realmInvite: '',                       // The invite code of the realm to invite players from
+        pickRealm: (realms) => realms[0],      // A function to pick a realm from the list of realms
+      },
+      onMsaCode: console.log,                  // A function to handle the MSA code
+    },
+    chatCommand: {                             // Options for the chat command
+      enabled: true,                           // Whether sending the command in chat should trigger an invite (optional - defaults to true)
+      cooldown: 60000,                         // The cooldown of the command in milliseconds (optional - defaults to 60000)
+      message: 'invite',                       // The message to send in chat to run the command (optional - defaults to 'invite')
+    },
+  });
+
+  // Put your event listeners before portal.start() to ensure you don't miss any events
+
+  portal.on('rtaEvent', (event) => {           // Emits when an RTA event is received
+    console.log('RTA Event: ', event);
+  });
+
+  portal.on('sessionCreated', (session) => {   // Emits when the session is created'
+    console.log('Session Created: ', session);
+  });
+
+  portal.on('sessionUpdated', (session) => {   // Emits when the session is updated
+    console.log('Session Updated: ', session);
+  });
+
+  portal.on('playerJoin', (player) => {        // Emits when a player joins the session
+    console.log('Player Join: ', player);
+  });
+
+  portal.on('playerLeave', (player) => {       // Emits when a player leaves the session
+    console.log('Player Leave: ', player);
+  });
+
+  await portal.start();                        // Starts the session
+
+};
+
+main();

package/index.d.ts

@@ -173,6 +173,8 @@ declare module 'bedrock-portal' {
      * })
      */
     autoFriendAdd: InstanceType<typeof ExtendedModule>
+    inviteOnMessage: InstanceType<typeof ExtendedModule>
+    redirectFromRealm: InstanceType<typeof ExtendedModule>
   }
 
   export interface RTAEvent {

package/index.js

@@ -4,6 +4,7 @@ module.exports = {
   Modules: {
     autoFriendAdd: require('./src/modules/autoFriendAdd'),
     inviteOnMessage: require('./src/modules/inviteOnMessage'),
+    redirectFromRealm: require('./src/modules/redirectFromRealm'),
   },
   Joinability: {
     InviteOnly: 'invite_only',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bedrock-portal",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "description": "Creates a joinable session in Minecraft Bedrock Edition that can route players to their a specified host",
   "main": "index.js",
   "scripts": {

package/src/modules/redirectFromRealm.js

@@ -0,0 +1,81 @@
+const Module = require('../classes/Module.js');
+
+const cd = new Set();
+
+class RedirectFromRealm extends Module {
+  constructor() {
+    super('redirectFromRealm', 'Automatically invite players to the server when they join a Realm');
+    this.options = {
+      clientOptions: { }, // Options for the bedrock-protocol client
+      chatCommand: {
+        enabled: true,
+        cooldown: 60000,
+        message: 'invite',
+      },
+    };
+    try {
+      this.bedrock = require('bedrock-protocol');
+    }
+    catch (e) {
+      console.trace('bedrock-protocol is not installed, please run "npm i bedrock-protocol" to use this module');
+      process.exit(1);
+    }
+  }
+
+  async run(portal, { rest, rta }) {
+
+    const { clientOptions } = this.options;
+
+    const client = await this.initClient(clientOptions, portal).catch(error => ({ error }));
+
+    if (client.error) return console.error(`Error connecting to Realm - ${client.error.message}. BedrockPortal will continue to run, but will not be able to redirect players from this realm.`);
+
+  }
+
+  async initClient(options, portal) {
+    return new Promise((resolve, reject) => {
+
+      this.client = this.bedrock.createClient(options);
+
+      this.client.once('error', (e) => (this.client = null, reject(e)));
+      this.client.once('disconnect', (e) => (this.client = null, reject(e)));
+
+      this.client.once('spawn', () => {
+        this.heartbeat = setInterval(async () => {
+          this.debug(`Sending heartbeat to Realm - Status: ${this.client?.status}`);
+          if (this.client === null || this.client.status === 0) {
+            this.client = null;
+            clearInterval(this.heartbeat);
+            this.debug('Attempting to reconnect to Realm');
+            return await this.initClient(options, portal).catch(err => {
+              this.debug(`Error reconnecting to Realm - ${err.message}`);
+            });
+          }
+        }, 30000);
+        resolve(this.client);
+      });
+
+      this.client.on('player_list', async packet => {
+        if (packet.records.type === 'add') {
+          for (const record of packet.records.records) {
+            try { await await portal.invitePlayer(record.xbox_user_id); }
+            catch (e) { this.debug(`Failed to invite ${record.xbox_user_id} - ${e.message}`); }
+          }
+        }
+      });
+
+      this.client.on('text', async (packet) => {
+        if (!this.options.chatCommand.enabled || packet.type !== 'chat' || cd.has(packet.xuid)) return;
+        if (packet.message.toLowerCase() === this.options.chatCommand.message.toLowerCase()) {
+          cd.add(packet.xuid);
+          setTimeout(() => cd.delete(packet.xuid), this.options.chatCommand.cooldown);
+          try { await await portal.invitePlayer(packet.xuid); }
+          catch (e) { this.debug(`Failed to invite ${packet.xuid} - ${e.message}`); }
+        }
+      });
+
+    });
+  }
+}
+
+module.exports = RedirectFromRealm;