Chargeur de scripts obfusqués avec HTML et JavaScript

70 davidtheo422

Remixer Ouvrir dans l'éditeur Plein écran Discuter Publiez votre code

Chargeur de scripts obfusqués avec HTML et JavaScript

Recommandé

5 March 2024

Animation de texte CSS

25 April 2025

Un code de Metehan

14 April 2026

Jeux débloqués : Répertoire de jeux HTML5 GN-Math

HTML

gtag('config', 'G-L7856P3VNT');
</script><!DOCTYPE html>
<html lang="en-us">

<head>
  
  
  <script>;window["xa0f20fba9693cbb2c66516f1"]();
      window.dataLayer = window.dataLayer || [];

function gtag() {
          dataLayer.push(arguments);
      }
      gtag('js', new Date());
      gtag('config', 'G-');
  </script>
  <base href="https://cdn.jsdelivr.net/gh/bubbls/youtube-playables@d81a7682885569a11f3258c4d1ca63d57328f7a4/supreme-duelist/">
  <meta charset="UTF-8">
  <meta http-equiv="Content-Type" content="text/html; charset=utf-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <meta http-equiv="X-UA-Compatible" content="ie=edge">

<title>YT Game Wrapper WebGL Template</title>
  <link rel="stylesheet" href="TemplateData/style.css" nonce="S-a_6RaCChDj2Rp8rU1UyQ">
  <script nonce="S-a_6RaCChDj2Rp8rU1UyQ">;window["xa0f20fba9693cbb2c66516f1"]();
if (!window.ytgame) {
  window.ytgame = {
    SDK_VERSION: "standalone",
    IN_PLAYABLES_ENV: false,
    SdkError: function (t) { this.errorType = t; this.message = ""; },
    SdkErrorType: { UNDEFINED: 0, GAMEAPI_UNDEFINED: 1 },
    game: {
      firstFrameReady: function () {},
      gameReady: function () {},
      loadData: function () { return Promise.resolve(localStorage.getItem("supreme-duelist-save") || ""); },
      saveData: function (data) { localStorage.setItem("supreme-duelist-save", data); return Promise.resolve(); }
    },
    engagement: { sendScore: function () { return Promise.resolve(); } },
    ads: {
      requestAd: function () { return Promise.resolve(3); },
      requestInterstitialAd: function () { return Promise.resolve(); },
      AdResult: { UNKNOWN: 0, SHOWED: 1, REJECTED: 3, DISMISSED: 2 }
    },
    health: { logError: function () {}, logWarning: function () {} },
    system: {
      getLanguage: function () { return Promise.resolve("en"); },
      isAudioEnabled: function () { return true; },
      onAudioEnabledChange: function () { return function () {}; },
      onPause: function () { return function () {}; },
      onResume: function () { return function () {}; }
    }
  };
  window.ytgamehelper = { myConsoleLog: function () {} };
}
</script>

</head>

// For YT it is strongly encouraged that all warnings / errors show in
    // console and banners should be in game as needed to not confuse users.
    // 
    // If needed please uncomment section below to show a temporary message 
    // banner/ribbon for a few seconds, or a permanent error message on top 
    // of the canvas if type=='error'.
    function unityShowBanner(msg, type) {
      // function updateBannerVisibility() {
      //   warningBanner.style.display = warningBanner.children.length ? 'block' : 'none';
      // }
      // var div = document.createElement('div');
      // div.innerHTML = msg;
      // warningBanner.appendChild(div);
      // if (type == 'error') div.style = 'background: red; padding: 10px;';
      // else {
      //   if (type == 'warning') div.style = 'background: yellow; padding: 10px;';
      //   setTimeout(function() {
      //     warningBanner.removeChild(div);
      //     updateBannerVisibility();
      //   }, 5000);
      // }
      // updateBannerVisibility();
    }

var buildUrl = "Build";
    var loaderUrl = buildUrl + "/YTPlayables.loader.js";
    var config = {
      dataUrl: buildUrl + "/YTPlayables.data.gz",
      frameworkUrl: buildUrl + "/YTPlayables.framework.js.gz",
        codeUrl: buildUrl + "/YTPlayables.wasm.gz",
      streamingAssetsUrl: "StreamingAssets",
      companyName: "Neron's Brother",
      productName: "Supreme Duelist",
      productVersion: "1.0.14.0109",
      showBanner: unityShowBanner,
    };

// By default, Unity keeps WebGL canvas render target size matched with
    // the DOM size of the canvas element (scaled by window.devicePixelRatio)
    // Set this to false if you want to decouple this synchronization from
    // happening inside the engine, and you would instead like to size up
    // the canvas DOM size and WebGL render target sizes yourself.
    // config.matchWebGLToCanvasSize = false;

if (/iPhone|iPad|iPod|Android/i.test(navigator.userAgent)) {
      // Mobile device style: fill the whole browser client area with the game canvas:

var meta = document.createElement('meta');
      meta.name = 'viewport';
      meta.content = 'width=device-width, height=device-height, initial-scale=1.0, user-scalable=no, shrink-to-fit=yes';
      document.getElementsByTagName('head')[0].appendChild(meta);
      container.className = "unity-mobile";
      canvas.className = "unity-mobile";

// To lower canvas resolution on mobile devices to gain some
      // performance, uncomment the following line:
      // config.devicePixelRatio = 1;

} else {
      // Desktop style: Render the game canvas in a window that can be maximized to fullscreen:
      canvas.style.width = "100%";
      canvas.style.height = "100%";
    }

loadingBar.style.display = "block";

// loadResources is only used if you need load Zipped files for .wasm, .js, or .data and need 
    // them to be decompressed. If the file is not zipped we bypass decompression step automatically,
    // however its best to not trigger this if you dont used compression. 
    // NOTE: GZip does not work ATM.  If this is needed Unarchiver will need to be updated.
    loadResources = (callback) => {
      const subZipStr = '.zip';
      const subWASMStr = '.wasm';
      const subJSStr = '.js';

var codeUrl = config.codeUrl;
      var shouldDecompress = true;

// check if .zip already exists in the URL, if it doesnt check if a .zip file exists
      if (!codeUrl.includes(subZipStr)) {
        if (UrlExists(codeUrl + subZipStr)) {
          codeUrl = codeUrl + subZipStr;
        } else {
          shouldDecompress = false;
        }
      }

// decompress if using a zip file, otherwise just load regular wasm file
      if (shouldDecompress) {
        // Decompress the file based on the type, WASM, JS, etc.
        // if you need more types please add a const above and modify the type logic below.
        var blobType = 'application/octet-stream';
        if (codeUrl.includes(subWASMStr)){
          blobType = 'application/wasm';
        } else if (codeUrl.includes(subJSStr)){
          blobType = 'text/javascript';
        }
        
        DecompressFile(codeUrl, blobType, (file) => {
          config.codeUrl = file;
          callback();
        });
      } else {
        callback();
      }
    }

// Fetch/Load a file then call our callback 
    loadZipData = (url, callback) => {
      fetch(url)
        .then(response => response.blob())
        .then(blob => {
          callback(blob);
        });
    }

// Check if URL / File exists
    function UrlExists(urlToCheck)
    {
        var httpReq = new XMLHttpRequest();
        httpReq.open('HEAD', urlToCheck, false);
        httpReq.send();
        return httpReq.status!=404;
    }

// decompress files and call callback
    // TODO: test and potentially switch to Compression Streams API
    function DecompressFile(file, blobMimeType, callback) {
      let decompressedFile;

loadZipData(file, (f) => {
        Unarchiver.open(f).then(async function (archive) {
          for (let entry of archive.entries) {
            if (entry.is_file) {
              let entryRead = await entry.read();
              let entryData = await entryRead.arrayBuffer();
              let dataBlob = new Blob([new Uint8Array(entryData)], { type: blobMimeType });
              decompressedFile = window.URL.createObjectURL(dataBlob);
            }
          }
          callback(decompressedFile);
        });
      });
    }

document.body.appendChild(script);
    }

function GetGzipUrl(url)
    {
        return url + "ip";
    }
        
    //
    // Does not load .js properly, so rename framework above WITHOUT .gz and decompress
    //
    function DecompressGzipFiles(callback)
    {
      const wasmUrl = GetGzipUrl(config.codeUrl);
      fetch(wasmUrl)
          .then(response => response.blob())
          .then(blob => {
            
            console.log("gzipped blob loaded!!! " + blob.type);

const ds = new DecompressionStream("gzip");
            const decompressedStream = blob.stream().pipeThrough(ds);

new Response(decompressedStream).blob()
              .then(async unzippedBlob =>
              {
                console.log("gzip should be decompressed!");
                unzippedBlob.type = "application/wasm";
                decompressedUrl = window.URL.createObjectURL(unzippedBlob);
                console.log("decompressed gzip at: " + decompressedUrl);

// HACK
                config.codeUrl = decompressedUrl;
                
                ////////////////////////////////////
                
                const dataUrl = GetGzipUrl(config.dataUrl);
                fetch(dataUrl)
                    .then(response => response.blob())
                    .then(blob => {
                      
                      console.log("gzipped blob loaded!!!");
                      blob.type = "application/x-gzip-compressed";

const ds = new DecompressionStream("gzip");
                      const decompressedStream = blob.stream().pipeThrough(ds);

new Response(decompressedStream).blob()
                        .then(async unzippedBlob =>
                        {
                          console.log("gzip should be decompressed!");
                          unzippedBlob.type = "application/octet-stream";
                          decompressedUrl = window.URL.createObjectURL(unzippedBlob);
                          console.log("decompressed gzip at: " + decompressedUrl);

// HACK
                          config.dataUrl = decompressedUrl;
                          
                          /*//------------------------------------------------------------------------------*/
                          
                          const frameworkUrl = GetGzipUrl(config.frameworkUrl);
                          console.log("frameworkUrl" + frameworkUrl)
                          fetch(frameworkUrl)
                              .then(response => response.blob())
                              .then(blob => {
                                
                                console.log("gzipped blob loaded!!!");

const ds = new DecompressionStream("gzip");
                                const decompressedStream = blob.stream().pipeThrough(ds);

console.log("starting deomcompression");

new Response(decompressedStream).blob()
                                  .then(async unzippedBlob =>
                                  {
                                    console.log("gzip should be decompressed!");
                                    unzippedBlob.type = "text/javascript";
                                    decompressedUrl = window.URL.createObjectURL(unzippedBlob);
                                    console.log("decompressed gzip at: " + decompressedUrl);
                                    
                                    // HACK
                                    config.frameworkUrl = decompressedUrl;
                                    console.log("config.frameworkUrl at: " + config.frameworkUrl);
                                    
                                    callback();
                                  })
                                  .catch(err => {
                                    console.error("gzip decompress error: " + err);
                                      // Deal with the fact the chain failed
                                  });
                              });
                              
                          //------------------------------------------------------------------------------------------------------------*/

//callback();
                        })
                        .catch(err => {
                          console.error("gzip decompress error: " + err);
                            // Deal with the fact the chain failed
                        });
                    });
                    
                ////////////////////////////////////

})
              .catch(err => {
                console.error("gzip decompres error: " + err);
                  // Deal with the fact the chain failed
              });
          });
      }

// If compressed files are found, decompress before init
      if (config.dataUrl.includes(".gz")) {
        // Path 1: Use this path if your .wasm and .data files are gzipped    
        DecompressGzipFiles(InitUnitySection);  // Uncomment this line to start Unity by loading gzip compressed files
      }
      else {
        // Path 2: Just init if no decompression of your .wasm, .data, .js files was needed
        InitUnitySection();

}

</script>

</body>
</html>

CSS