☰

Time Control

Script allowing you to control time.

当前为 2024-03-31 提交的版本，查看 最新版本。

  1. // ==UserScript==
  2. // @name         Time Control
  3. // @description  Script allowing you to control time.
  4. // @icon         https://parsefiles.back4app.com/JPaQcFfEEQ1ePBxbf6wvzkPMEqKYHhPYv8boI1Rc/ce262758ff44d053136358dcd892979d_low_res_Time_Machine.png
  5. // @namespace    mailto:lucaszheng2011@outlook.com
  6. // @version      1.2.2.5
  7. // @author       lucaszheng
  8. // @license      MIT
  9. //
  10. // @match        *://*/*
  11. // @grant        unsafeWindow
  12. // @grant        GM_getValue
  13. // @grant        GM_setValue
  14. // @grant        GM_deleteValue
  15.  
  16. // @inject-into  page
  17. // @run-at       document-start
  18. // ==/UserScript==
  19.  
  20. (window => {
  21.   "use strict";
  22.   let scale = 1, pristine = true;
  23.   /** @type {null | number} */
  24.   let timeJump = null;
  25.  
  26.   let timeSync = false;
  27.   let debug = false;
  28.  
  29.   const {
  30.     Reflect: {
  31.       apply, construct,
  32.       setPrototypeOf
  33.     },
  34.     Object: {
  35.       defineProperty,
  36.       freeze
  37.     },
  38.     Number: {
  39.       isFinite
  40.     },
  41.     console: {
  42.       trace: log
  43.     }
  44.   } = window;
  45.  
  46.   function update() {
  47.     for (let idx = 0; idx < updaters.length; idx++) {
  48.       updaters[idx]();
  49.     }
  50.   }
  51.  
  52.   const time = {
  53.     /**
  54.      * @param {number} newTime
  55.      */
  56.     jump(newTime) {
  57.       if (newTime == null) return;
  58.       pristine = false;
  59.       timeJump = +newTime;
  60.       update();
  61.       timeJump = null;
  62.     },
  63.  
  64.     sync(resetTime = true, resetScale = true) {
  65.       if (pristine) return;
  66.       if (resetScale) scale = 1;
  67.       if (!resetTime) return;
  68.       timeSync = true;
  69.       update();
  70.       timeSync = false;
  71.       pristine = scale === 1;
  72.     },
  73.  
  74.     save(saveTime = true, saveScale = true) {
  75.       if (saveTime) {
  76.         if (pristine) {
  77.           GM_deleteValue('baseTime');
  78.           GM_deleteValue('contTime');
  79.         } else {
  80.           GM_setValue('baseTime', time.real);
  81.           GM_setValue('contTime', time.now);
  82.         }
  83.       }
  84.       if (saveScale) {
  85.         if (scale === 1) GM_deleteValue('scale');
  86.         else GM_setValue('scale', time.scale);
  87.       }
  88.     },
  89.  
  90.     load(loadTime = true, loadScale = true) {
  91.       if (loadTime) {
  92.         let baseTime = GM_getValue('baseTime', null);
  93.         let contTime = GM_getValue('contTime', null);
  94.         if (baseTime != null && contTime != null)
  95.           time.jump((time.now - baseTime) + contTime);
  96.       }
  97.       if (loadScale) {
  98.         let newScale = GM_getValue('scale', null);
  99.         if (newScale != null) time.scale = newScale;
  100.       }
  101.     },
  102.     
  103.     reset(resetTime = true, resetScale = true) {
  104.       time.sync(resetTime, resetScale);
  105.       time.save(resetTime, resetScale);
  106.     },
  107.  
  108.     get debug() { return debug; },
  109.     set debug(value) { debug = !!value; },
  110.  
  111.     get now() { return apply(date.now, DateConstructor, []); },
  112.     set now(value) { time.jump(value); },
  113.  
  114.     get pristine() { return pristine; },
  115.     set pristine(value) { if (value) time.sync(); },
  116.  
  117.     get real() { return apply(date.realTime, DateConstructor, []); },
  118.  
  119.     get scale() { return scale; },
  120.     set scale(value) {
  121.       value = +value;
  122.       if (value === scale) return;
  123.       pristine = false; update(); scale = value;
  124.     }
  125.   };
  126.  
  127.   defineProperty(window, 'time', {
  128.     value: freeze(time),
  129.     writable: true,
  130.     enumerable: false,
  131.     configurable: true
  132.   });
  133.  
  134.   /** @type {(() => void)[]} */
  135.   const updaters = [];
  136.  
  137.   /**
  138.    * @param {() => number} func
  139.    * @param {any} self
  140.    */
  141.   function wrap_now(func, self, offset = 0) {
  142.     let baseTime = 0;
  143.     let contTime = baseTime;
  144.  
  145.     /** @type {ProxyHandler<typeof func>} */
  146.     const handler = {
  147.       apply(target, self, args) {
  148.         if (debug) log('apply(%o, %o, %o)', target, self, args);
  149.         let time = apply(target, self, args);
  150.         if (pristine || !isFinite(time)) return time;
  151.         return ((time - baseTime) * scale) + contTime;
  152.       }
  153.     };
  154.     setPrototypeOf(handler, null);
  155.  
  156.     updaters[updaters.length] =
  157.       function update() {
  158.         contTime = timeJump == null ? handler.apply?.(func, self, []) : timeJump + offset;
  159.         baseTime = apply(func, self, []);
  160.         if (timeSync) contTime = baseTime;
  161.       };
  162.  
  163.     return new Proxy(func, handler);
  164.   }
  165.  
  166.   window.Performance.prototype.now = wrap_now(
  167.     window.Performance.prototype.now,
  168.     window.performance,
  169.     window.performance.now() - window.Date.now()
  170.   );
  171.  
  172.   const DateConstructor = window.Date;
  173.   /** @type {{ realTime: typeof Date.now, now: typeof Date.now, toString: typeof Date.prototype.toString, handler: ProxyHandler<DateConstructor> }} */
  174.   const date = {
  175.     realTime: window.Date.now,
  176.     now: wrap_now(window.Date.now, window.Date),
  177.     toString: DateConstructor.prototype.toString,
  178.     handler: {
  179.       apply(target, self, args) {
  180.         if (debug) log('apply(%o, %o, %o)', target, self, args);
  181.         if (!pristine) {
  182.           args.length = 1;
  183.           args[0] = apply(date.now, DateConstructor, []);
  184.         } else return DateConstructor();
  185.         return apply(date.toString, construct(DateConstructor, args), []);
  186.       },
  187.       construct(target, args, newTarget) {
  188.         if (debug) log('construct(%o, %o, %o)', target, args, newTarget);
  189.         if (!pristine && args.length < 1) {
  190.           args[0] = apply(date.now, DateConstructor, []);
  191.         }
  192.         return construct(DateConstructor, args, newTarget);
  193.       }
  194.     }
  195.   };
  196.   setPrototypeOf(date, null);
  197.   setPrototypeOf(date.handler, null);
  198.   DateConstructor.now = date.now;
  199.  
  200.   window.Date = new Proxy(DateConstructor, date.handler);
  201.   window.Date.prototype.constructor = window.Date;
  202.  
  203.   function noop() { }
  204.  
  205.   /**
  206.    * @param {(handler: TimerHandler, timeout?: number | undefined, ...args: any[]) => number} func
  207.    */
  208.   function wrap_timer(func) {
  209.     /** @type {ProxyHandler<typeof func>} */
  210.     const handler = {
  211.       apply(target, self, args) {
  212.         if (debug) log('apply(%o, %o, %o)', target, self, args);
  213.         if (!pristine && args.length > 1) {
  214.           args[1] = +args[1];
  215.           if (args[1] && scale === 0)
  216.             args[0] = noop;
  217.           else if (args[1] && isFinite(args[1]))
  218.             args[1] /= scale;
  219.         }
  220.         return apply(target, self, args);
  221.       }
  222.     };
  223.     setPrototypeOf(handler, null);
  224.     return new Proxy(func, handler);
  225.   }
  226.  
  227.   window.setTimeout = wrap_timer(window.setTimeout);
  228.   window.setInterval = wrap_timer(window.setInterval);
  229.  
  230.   time.load();
  231. })(
  232.   /** @type {typeof window} */
  233.   (typeof unsafeWindow === 'object' ? unsafeWindow : window)
  234. );