yolkbot 0.1.0-alpha.50 → 0.1.0-alpha.52

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "yolkbot",
     "description": "create a shell shockers (self) bot in under 10 lines.",
-    "version": "0.1.0-alpha.50",
+    "version": "0.1.0-alpha.52",
     "keywords": [
         "shell shockers",
         "shellshock.io",

package/src/api.js

@@ -125,6 +125,58 @@ async function loginWithCredentials(email, password, prox = '', instance = 'shel
     return response;
 }
 
+async function loginWithRefreshToken(refreshToken, prox = '', instance = 'shellshock.io') {
+    if (!refreshToken) return 'firebase_no_credentials';
+
+    const formData = new URLSearchParams();
+    formData.append('grant_type', 'refresh_token');
+    formData.append('refresh_token', refreshToken);
+
+    let SUCCESS = false;
+    let request, body, token;
+    let k = 0;
+
+    while (!SUCCESS) {
+        try {
+            request = await axios.post(`https://securetoken.googleapis.com/v1/token?key=${FirebaseKey}`, formData, {
+                headers: {
+                    'user-agent': UserAgent,
+                    'x-client-version': 'Chrome/JsCore/9.17.2/FirebaseCore-web'
+                },
+                httpsAgent: (!IsBrowser && prox) ? new SocksProxyAgent(prox) : false
+            })
+            body = request.data
+            token = body.id_token;
+            SUCCESS = true;
+        } catch (error) {
+            ++k;
+            if (error.code == 'auth/network-request-failed') {
+                console.error('loginWithRefreshToken: Network req failed (auth/network-request-failed), retrying, k =', k);
+            } else if (error.code == 'auth/missing-email') {
+                return 'firebase_no_credentials';
+            } else {
+                console.error('loginWithRefreshToken: Error:', refreshToken);
+                console.error('loginWithRefreshToken: Error:', error, 'k =', k);
+            }
+
+            if (k > 5) return 'firebase_too_many_retries';
+            else await new Promise((resolve) => setTimeout(resolve, 100));
+        }
+    }
+
+    if (!token) {
+        console.error('loginWithRefreshToken: the game sent no idToken', body);
+        return 'firebase_no_token';
+    }
+
+    const response = await queryServices({
+        cmd: 'auth',
+        firebaseToken: token
+    }, prox, instance);
+
+    return response;
+}
+
 async function loginAnonymously(prox = '', instance = 'shellshock.io') {
     const { data: body } = await axios.post('https://identitytoolkit.googleapis.com/v1/accounts:signUp?key=' + FirebaseKey, {
         returnSecureToken: true
@@ -155,5 +207,6 @@ export {
     createAccount,
     loginAnonymously,
     loginWithCredentials,
+    loginWithRefreshToken,
     queryServices
 }

package/src/bot.js

@@ -1,4 +1,4 @@
-import { createAccount, loginAnonymously, loginWithCredentials, queryServices } from '#api';
+import { createAccount, loginAnonymously, loginWithCredentials, loginWithRefreshToken, queryServices } from '#api';
 
 import CommIn from './comm/CommIn.js';
 import CommOut from './comm/CommOut.js';
@@ -40,7 +40,8 @@ const intents = {
     PATHFINDING: 3,
     BUFFERS: 4,
     PING: 5,
-    COSMETIC_DATA: 6
+    COSMETIC_DATA: 6,
+    PLAYER_HEALTH: 7
 }
 
 export class Bot {
@@ -256,6 +257,11 @@ export class Bot {
         return this.#processLoginData(loginData);
     }
 
+    async loginWithRefreshToken(refreshToken) {
+        const loginData = await loginWithRefreshToken(refreshToken, this.proxy, this.instance);
+        return this.#processLoginData(loginData);
+    }
+
     async loginAnonymously() {
         delete this.account.email;
         delete this.account.password;
@@ -659,23 +665,25 @@ export class Bot {
         if (!IsBrowser) {
             const { existsSync, mkdirSync, readFileSync, writeFileSync } = await import('node:fs');
             const { join } = await import('node:path');
+            const { homedir } = await import('node:os');
 
-            if (existsSync(join(import.meta.dirname, '..', 'data', 'cache', 'maps', `${name}-${hash}.json`))) {
-                return JSON.parse(readFileSync(join(import.meta.dirname, '..', 'data', 'cache', 'maps', `${name}-${hash}.json`), 'utf-8'));
-            }
+            const yolkbotCache = join(homedir(), '.yolkbot');
+            const mapCache = join(yolkbotCache, 'maps');
+
+            if (!existsSync(yolkbotCache)) mkdirSync(yolkbotCache);
+            if (!existsSync(mapCache)) mkdirSync(mapCache);
 
-            console.warn(`Map "${name}" not found in cache, fetching...`);
+            const mapFile = join(mapCache, `${name}-${hash}.json`);
+
+            if (existsSync(mapFile))
+                return JSON.parse(readFileSync(mapFile, 'utf-8'));
+
+            console.log('map not in cache, IMPORT!!', name, hash);
 
             const data = await (await fetch(`https://${this.instance}/maps/${name}.json?${hash}`)).json();
 
-            const dir = join(import.meta.dirname, '..', 'data', 'cache', 'maps');
-            if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+            writeFileSync(mapFile, JSON.stringify(data, null, 4), { flag: 'w+' });
 
-            writeFileSync(
-                join(dir, `${name}-${hash}.json`),
-                JSON.stringify(data, null, 4),
-                { flag: 'w+' }
-            );
             return data;
         } else {
             const data = await (await fetch(`https://${this.instance}/maps/${name}.json?${hash}`)).json();
@@ -811,7 +819,7 @@ export class Bot {
 
             const player = this.players[playerData.id_];
 
-            if (player.playing) {
+            if (player.playing && this.intents.includes(this.Intents.PLAYER_HEALTH)) {
                 player.healthInterval = setInterval(() => {
                     if (player.hp < 1) return;
 
@@ -859,21 +867,22 @@ export class Bot {
             // console.log(`Player ${player.name} respawned at ${x}, ${y}, ${z}`);
             this.#emit('playerRespawn', player);
 
-            if (player.healthInterval) {
-                clearInterval(player.healthInterval);
-            }
+            if (this.intents.includes(this.Intents.PLAYER_HEALTH)) {
+                if (player.healthInterval)
+                    clearInterval(player.healthInterval);
 
-            player.healthInterval = setInterval(() => {
-                if (player.hp < 1) return;
+                player.healthInterval = setInterval(() => {
+                    if (player.hp < 1) return;
 
-                const regenSpeed = 0.1 * (this.game.isPrivate ? this.game.options[GameOptionFlags.healthRegen] : 1);
+                    const regenSpeed = 0.1 * (this.game.isPrivate ? this.game.options[GameOptionFlags.healthRegen] : 1);
 
-                if (player.streakRewards.includes(ShellStreaks.OverHeal)) {
-                    player.hp = Math.max(100, player.hp - regenSpeed);
-                } else {
-                    player.hp = Math.min(100, player.hp + regenSpeed);
-                }
-            }, 33);
+                    if (player.streakRewards.includes(ShellStreaks.OverHeal)) {
+                        player.hp = Math.max(100, player.hp - regenSpeed);
+                    } else {
+                        player.hp = Math.min(100, player.hp + regenSpeed);
+                    }
+                }, 33);
+            }
         } else {
             // console.log(`Player ${id} not found. (me: ${this.me.id}) (respawn)`);
         }

package/src/types/api.d.ts

@@ -17,4 +17,5 @@ export interface QueryResponse {
 
 export function queryServices(request: QueryRequest, proxy?: string, instance?: string): Promise<QueryResponse | string>;
 export function loginWithCredentials(email: string, password: string, prox?: string, instance?: string): Promise<QueryResponse | string>;
+export function loginWithRefreshToken(refreshToken: string, prox?: string, instance?: string): Promise<QueryResponse | string>;
 export function loginAnonymously(prox?: string, instance?: string): Promise<QueryResponse | string>;

package/src/types/bot.d.ts

@@ -174,6 +174,7 @@ export class Bot {
     constructor(params?: BotParams);
 
     loginAnonymously(): Promise<Account | false>;
+    loginWithRefreshToken(refreshToken: string): Promise<Account | false>;
     login(email: string, pass: string): Promise<Account | false>;
     createAccount(email: string, pass: string): Promise<Account | false>;