☰

Minimap Rescaler with Position and Size UI (Memory-Based)

Change the position and size of the minimap in Diep.io by manipulating memory

  1. // ==UserScript==
  2. // @name         Minimap Rescaler with Position and Size UI (Memory-Based)
  3. // @namespace    http://tampermonkey.net/
  4. // @version      2024-12-11
  5. // @description  Change the position and size of the minimap in Diep.io by manipulating memory
  6. // @author       You
  7. // @match        https://diep.io/
  8. // @icon         https://www.google.com/s2/favicons?sz=64&domain=diep.io
  9. // @grant        none
  10. // ==/UserScript==
  11.  
  12. (function() {
  13.     'use strict';
  14.  
  15.     const handler = {apply(r,o,args){Error.stackTraceLimit=0;return r.apply(o,args)}};Object.freeze = new Proxy(Object.freeze, handler)
  16.  
  17.     window.HEAPF32 = undefined;
  18.  
  19.     const win = typeof unsafeWindow != "undefined" ? unsafeWindow : window;
  20.     win.Object.defineProperty(win.Object.prototype, "HEAPF32", {
  21.         get: function() {
  22.             return undefined;
  23.         },
  24.         set: function(to) {
  25.             if(!to || !this.HEAPU32) return;
  26.             delete win.Object.prototype.HEAPF32;
  27.             window.Module = this;
  28.             window.Module.HEAPF32 = to;
  29.             window.HEAPF32 = to;
  30.  
  31.             console.log("HEAPF32 found");
  32.         },
  33.         configurable: true,
  34.         enumerable: true
  35.     });
  36.  
  37.     // Fonction d'ajout de l'interface utilisateur pour déplacer et redimensionner la minimap
  38.     function createMinimapUI() {
  39.         // Créer un panneau d'interface utilisateur
  40.         const uiPanel = document.createElement('div');
  41.         uiPanel.style.position = 'absolute'; // Positionnement absolu
  42.         uiPanel.style.right = '150px';
  43.         uiPanel.style.backgroundColor = 'rgba(0, 0, 0, 0.7)';
  44.         uiPanel.style.color = 'white';
  45.         uiPanel.style.padding = '15px';
  46.         uiPanel.style.borderRadius = '5px';
  47.         uiPanel.style.zIndex = 10000;
  48.         uiPanel.style.width = '250px'; // Taille fixe pour l'interface
  49.  
  50.         uiPanel.innerHTML = '<strong>Reposition and resize the Minimap</strong><br><br>';
  51.  
  52.         // Ajouter les sliders pour Position X et Y
  53.         uiPanel.innerHTML += 'Position X: <input type="range" id="minimapX" min="0" max="1600" value="0" style="width: 100%;"><br>';
  54.         uiPanel.innerHTML += 'Position Y: <input type="range" id="minimapY" min="0" max="1600" value="0" style="width: 100%;"><br><br>';
  55.  
  56.         // Ajouter un seul slider pour la taille de la minimap
  57.         uiPanel.innerHTML += 'Taille: <input type="range" id="minimapSize" min="0" max="1600" value="0" style="width: 100%;"><br><br>';
  58.  
  59.         // Ajouter le panneau à l'élément 'game-over-screen'
  60.         const gameOverScreen = document.getElementById('game-over-screen');
  61.         if (gameOverScreen) {
  62.             gameOverScreen.appendChild(uiPanel);
  63.         } else {
  64.             console.error('Élément "game-over-screen" non trouvé.');
  65.         }
  66.  
  67.         // Charger les paramètres depuis le localStorage
  68.         loadSettings();
  69.  
  70.         // Lier les événements aux sliders pour appliquer les modifications immédiatement
  71.         document.getElementById('minimapX').addEventListener('input', updateMinimap);
  72.         document.getElementById('minimapY').addEventListener('input', updateMinimap);
  73.         document.getElementById('minimapSize').addEventListener('input', updateMinimap);
  74.     }
  75.  
  76.     // Fonction pour mettre à jour la minimap en temps réel
  77.     function updateMinimap() {
  78.         const x = parseInt(document.getElementById('minimapX').value, 10);
  79.         const y = parseInt(document.getElementById('minimapY').value, 10);
  80.         const size = parseInt(document.getElementById('minimapSize').value, 10);
  81.  
  82.         // Limiter la taille de la minimap en fonction de la taille de l'écran
  83.         const screenWidth = window.innerWidth;
  84.         const screenHeight = window.innerHeight;
  85.  
  86.         const maxSize = Math.min(screenWidth, screenHeight); // La taille max de la minimap ne doit pas dépasser la taille de l'écran
  87.         const minSize = 0; // Taille minimale
  88.  
  89.         // Redimensionner la minimap pour ne pas dépasser les bords de l'écran
  90.         const clampedSize = Math.min(Math.max(size, minSize), maxSize);
  91.  
  92.         // Calculer la nouvelle position pour centrer la minimap par rapport à son nouveau taille
  93.         const newX = Math.max(0, Math.min(x - clampedSize / 2, screenWidth - clampedSize));
  94.         const newY = Math.max(0, Math.min(y - clampedSize / 2, screenHeight - clampedSize));
  95.  
  96.         // Appliquer les nouvelles valeurs à la minimap
  97.         moveAndResizeMinimap(newX, newY, clampedSize, clampedSize);  // La taille est identique en largeur et hauteur
  98.  
  99.         // Sauvegarder les paramètres dans le localStorage
  100.         saveSettings(newX, newY, clampedSize);
  101.     }
  102.  
  103.     // Fonction pour déplacer et redimensionner la minimap dans la mémoire
  104.     function moveAndResizeMinimap(x, y, width, height) {
  105.         if (window.HEAPF32) {
  106.             // Appliquer les nouvelles valeurs aux indices correspondants dans la mémoire WebAssembly
  107.             window.HEAPF32[60903] = x; // Position X
  108.             window.HEAPF32[60904] = y; // Position Y
  109.             window.HEAPF32[60905] = width;  // Taille X
  110.             window.HEAPF32[60906] = height; // Taille Y
  111.  
  112.             console.log(`Minimap déplacée à X: ${x}, Y: ${y} et redimensionnée à ${width}x${height}`);
  113.         } else {
  114.             console.error('HEAPF32 non trouvé. Impossible de manipuler la mémoire.');
  115.         }
  116.     }
  117.  
  118.     // Fonction pour sauvegarder les paramètres dans le localStorage
  119.     function saveSettings(x, y, size) {
  120.         localStorage.setItem('minimapX', x);
  121.         localStorage.setItem('minimapY', y);
  122.         localStorage.setItem('minimapSize', size);
  123.     }
  124.  
  125.     // Fonction pour charger les paramètres depuis le localStorage
  126.     function loadSettings() {
  127.         const savedX = localStorage.getItem('minimapX');
  128.         const savedY = localStorage.getItem('minimapY');
  129.         const savedSize = localStorage.getItem('minimapSize');
  130.  
  131.         if (savedX !== null && savedY !== null && savedSize !== null) {
  132.             document.getElementById('minimapX').value = savedX;
  133.             document.getElementById('minimapY').value = savedY;
  134.             document.getElementById('minimapSize').value = savedSize;
  135.             // Appliquer les valeurs sauvegardées
  136.             updateMinimap();
  137.         }
  138.     }
  139.  
  140.     // Créer l'interface une fois que la page est chargée
  141.     window.addEventListener('load', () => {
  142.         // Vérifier si HEAPF32 est accessible
  143.         const waitForHeapF32 = setInterval(() => {
  144.             if (window.HEAPF32) {
  145.                 clearInterval(waitForHeapF32);
  146.                 createMinimapUI();
  147.                 console.log("HEAPF32 trouvé, interface prête.");
  148.             }
  149.         }, 100);
  150.     });
  151.  
  152. })();