JS Snippets Thread

// get a random color
function ranHexColors() { return ('0x' + Math.floor(Math.random() * 16777215).toString(16) || 0xffffff) };

    // Build Rectangles // x, y, w:width, h:height, c:color, a:alpha, r:radius, l_c_a:[lineWidth,colorLine,alphaLine]
    function drawRec(x, y, w, h, c, a, r, l_c_a) {
        const rec = new PIXI.Graphics();
            rec.beginFill(c||0xffffff, a||1);
            l_c_a && rec.lineStyle((l_c_a[0]||0), (l_c_a[1]||c||0x000000), l_c_a[2]||1);
            r && rec.drawRoundedRect(x, y, w, h, r) || rec.drawRect(x, y, w, h);
        return rec;
    };

    // Get a sprite ratio for scaling
    function getRatio(obj, w, h, set) {
        let r = Math.min(w / obj.width, h / obj.height);
        set && obj.scale.set(r,r);
        return r>1 && 1 || r;
    };

 var picture = new Sprite();
        picture.width = 99999; // pixel
        picture.height = 7589; // pixel
    var ratio = getRatio(picture,80,120); // get ratio for fit inside a [80,120] box
        picture.scale.set(ratio);

function multiDice(nDice, nSides) {
      var totalRolled = 0;
      for (var i=0; i < nDice; i++) {
         totalRolled += Math.randomInt(nSides) + 1;
      return totalRolled;
   };

//weapon is passed-in notetag which is stripped of boundary text using
// $.Regex = /<weapon[-_ ]damage>([\s\S]*?)<\/weapon[-_ ]damage>/im
//defined in plugin code above this
    if (weapon.damageFormula === undefined) {
      weapon.damageFormula = "0";
      var res = $.Regex.exec(weapon.note);
      if (res) {
        var diceRegex = /\s*(\d+)[dD](\d+)/m;
        var diceRes = diceRegex.exec(res[1]);
        var numDice, numSides, diceCall;
        while (diceRes) {
          numDice = diceRes[1];
          numSides = diceRes[2];
          diceCall = "multiDice("+numDice.toString()+","+numSides.toString()+")";
          res[1] = res[1].replace(diceRegex, diceCall);
          diceRes = diceRegex.exec(res[1]);
        }
        weapon.damageFormula = res[1];
      }
    }

var script = '';
while(this.nextEventCode() === 355 || this.nextEventCode() === 655) {
    this._index++;
    script += this.currentCommand().parameters[0] + '\n';
}
eval(script);

var script = '', current = this.currentCommand();
if(!current._reloader) {
    current._reloader = {index: 0};
    while(this.nextEventCode() === 355 || this.nextEventCode() === 655) {
        this._index++; current._reloader.index++;
        script += this.currentCommand().parameters[0] + '\n';
    }
    current._reloader.func = new Function(script);
} else { this._index+= current._reloader.index; }
current._reloader.func.call(this);

// global for control zoom memory
const memCoord = new PIXI.Point();
const memCoord2 = new PIXI.Point();
const TileMap = SceneManager._scene._spriteset._tilemap; // game map
const Zoom = TileMap.scale;

// zoom camera
    function wheel_Editor(event) {
        const pos = new PIXI.Point(mX,mY);
        TileMap.toLocal(pos, null, memCoord); // update before scale memory
        if(event.wheelDeltaY>0){
            Zoom.x+=0.1,Zoom.y+=0.1
        }else{
           if(Zoom._x>0.3){ Zoom.x-=0.1, Zoom.y-=0.1 };
        };
        TileMap.toLocal(pos, null, memCoord2);  // update after scale memory
        TileMap.pivot.x -= (memCoord2.x - memCoord.x);
        TileMap.pivot.y -= (memCoord2.y - memCoord.y);
        ScrollX -= (memCoord2.x - memCoord.x); // only if you use custom display system
        ScrollY -= (memCoord2.y - memCoord.y);
    };
document.addEventListener('wheel', wheel_Editor);

//=============================================================================
// Array_util
//=============================================================================

(function() {
    
//=============================================================================

Array.prototype.includes = function(value)
{
    return (this.indexOf(value) >= 0);
};

Array.prototype.remove = function(value)
{
    this.splice(this.indexOf(value), 1);
};

Array.prototype.tryRemove = function(value)
{
    var index = this.indexOf(value);
    if (index >= 0)
    {
        this.splice(index, 1);
        return true;
    }
    return false;
};

//=============================================================================

})();

/**
 * @author Dax|Kvothe
 * @contact http://dax-soft.weebly.com/
 * @license MIT
 * @description This handles with the mathematical calculus to detect collisions
 * on a circle form. This is experimental.
 * @param {Body?} [a] will be the 'invasor'.
 * @param {Body?} [b] will be the reference for detect the collision
 * @param {Number} [radius] radius of the circle (general size)
 * @param {Number} [outline] by default is Math.E | See the list:
 *  [Math.E|Math.LN10] => inside of circle.
 *  [Math.PI] => increase a outline on circle by a "large" margin.
 *  [Math.LN2|SQRT1_2] => inside of circle but need to pass over a 'large' margin.
 *  [Math.LOG10E] => same as Math.LN2 but with a margin "more" 'big'.
 *  [Math.LOG2E|Math.SQRT2] => Inside of circle but need to pass over a 'tiny' margin.
 * @returns {Boolean}
 */

const dcircle = function (a, b, radius, outline) {
    return (
        ~~(Math.pow((a.x - (b.x - (1)) ), 2) +
        Math.pow((a.y - (b.y - (1)) ), 2)) <=Math.abs(((radius * ((a.width+a.height)/2)) * (outline || Math.E)))
    );
}

$gameSystem.onBeforeSave();
if(DataManager.saveGame(X)) {
   StorageManager.cleanBackup(X);
}

if(DataManager.loadGame(X)) {
   SoundManager.playLoad();
   SceneManager._scene.fadeOutAll();
   $gamePlayer.reserveTransfer($gameMap.mapId(), $gamePlayer.x, $gamePlayer.y);
   $gamePlayer.requestMapReload();
   SceneManager.goto(Scene_Map);
   $gameSystem.onAfterLoad();
}

     var walkSync = function(dir, list) {
        var path = path || require('path');
        var fs = fs || require('fs'), files = fs.readdirSync(dir), list = list || [];
        files.forEach(function(file) { // create instance for eatch folder
            if (fs.statSync(path.join(dir, file)).isDirectory()) {
                list = walkSync(path.join(dir, file), list);
            }
            else { list.push(path.join(dir, file)) };
        });
        return list;
    };

     var walkSync = function(dir, list) {
        var path = path || require('path');
        var fs = fs || require('fs'), files = fs.readdirSync(dir), list = list || [];
        files.forEach(function(file) { // create instance for eatch folder
            if (fs.statSync(path.join(dir, file)).isDirectory()) {
                list = walkSync(path.join(dir, file), list);
            }
            else { list.push(path.join(dir, file)) };
        });
        return list;
    };
    const result = walkSync("SSA"); // scan folder named "SSA"

    function hitCheck(a, b){
        var ab = a.getBounds();
        var bb = b.getBounds();
        return ab.x + ab.width > bb.x && ab.x < bb.x + bb.width && ab.y + ab.height > bb.y && ab.y < bb.y + bb.height;
    }

var f = EventTarget.prototype.addEventListener;
EventTarget.prototype.addEventListener = function(type, fn, capture) {
    this.f = f;
    this.f(type, fn, capture);
    alert('Added Event Listener: on' + type);
}

function addListener() {
    var button = document.getElementById('button');
    button.addEventListener('click', function() { alert('clicked') }, false);
}

// --  Fix Name Input Font Display -- //
Window_NameEdit.prototype.drawChar = function(index) {
    var rect = this.itemRect(index);
    this.resetTextColor();
    this.drawText(this._name[index] || '', rect.x, rect.y, rect.width, 'center');
};

    function snapScreenMap(STAGE,w,h) {
        // create a snap to import in rmmv sofware or photoshop
        const renderer = PIXI.autoDetectRenderer(w, h);
        const renderTexture = PIXI.RenderTexture.create(w, h);
            renderer.render(STAGE, renderTexture);
        const canvas = renderer.extract.canvas(renderTexture);
        const urlData = canvas.toDataURL();
        const base64Data = urlData.replace(/^data:image\/png;base64,/, "");
        const _fs = require('fs');
        const crypto = window.crypto.getRandomValues(new Uint32Array(1));
        _fs.writeFile(`testSnapStage_${crypto}.png`, base64Data, 'base64', function(error){
            if (error !== undefined && error !== null) {  console.error('An error occured while saving the screenshot', error); }
        });
   };