RS_WaveFilter.js

//================================================================
// RS_WaveFilter.js
// ---------------------------------------------------------------
// The MIT License
// Copyright (c) 2016 biud436
// ---------------------------------------------------------------
// Free for commercial and non commercial use.
//================================================================
/*:
 * @target mv
 * @plugindesc This plugin applies the wave effect to the all objects by using the Fragment Shader.
 * @author biud436
 * @url http://biud436.tistory.com
 *
 * @help
 *
 * =============================================================================
 * Sprite
 * =============================================================================
 * The following properties applies the wave effect to Sprite.
 * For Information, Refer to http://biud436.tistory.com/17
 *
 *    - wave : The default value is false.
 *    - wave_amp : The default value is to 0.05
 *    - wave_length : The default value is to a maxHeight (deprecated)
 *    - wave_speed : The default value is to 0.25
 *    - wave_phase : The default value is to 360
 *
 * =============================================================================
 * Picture
 * =============================================================================
 * This plugin command would activate the wave effect to your picture:
 *
 *    PictureWave Start picture_id wave_speed wave_amp
 *      - picture_id : Specify the id of the game picture.
 *      - wave_speed : The available value is the number between 0 and 1.
 *                    (The default value is to 0.25)
 *      - wave_amp : The available value is the number between 0 and 1.
 *                   (The default value is to 0.05)
 *
 * This plugin command would deactivate the wave effect of your picture:
 *
 *    PictureWave Stop picture_id
 *      - picture_id : Specify the id of the game picture.
 *
 * =============================================================================
 * Tilemap
 * =============================================================================
 *
 * The following plugin commands applies the wave effect to Tilemap.
 * This plugin contains these six types the plugin commands.
 *
 * These plugin commands allow you to enable or disable the wave effect
 *
 *    TilemapWave Enable
 *    TilemapWave Disable
 *
 * This plugin command allows you to set the speed of the wave effect.
 * the x is a floating-point number between 0 and 2.
 * Default value is to 2.0. But the fragment shader does not use this value.
 *
 *    TilemapWave waveSpeed x
 *
 * This plugin command allows you to set the amplitude of the wave effect.
 * the x is a floating-point number between 0 and 1.
 * Default value is to 0.02
 *
 *    TilemapWave waveFrequency x
 *
 * This plugin command allows you to set the UV speed of the wave effect.
 * the x is a floating-point number between 0 and 1.
 * Default value is to 0.25
 *
 *    TilemapWave UVSpeed x
 *
 * =============================================================================
 * Event Notetags
 * =============================================================================
 *
 * Notetags :
 *
 * These note tags allow you to enable or disable the wave effect.
 *    <WAVE true>
 *    <WAVE false>
 *
 * This note tag allows you to set the amplitude of the wave effect.
 * the x is a floating-point number between 0 and 1.
 * the default value is to 0.02
 *
 *    <WAVE_AMP x>
 *
 * This note tag allows you to set the speed of the wave effect.
 * the x is a floating-point number between 0 and 1.
 * the default value is to 0.25
 *
 *    <WAVE_SPEED x>
 *
 * =============================================================================
 * Battle Notetags
 * =============================================================================
 *
 * These note tags allow you to set the wave effect.
 * You have to put the note tags in the note area of the map properties.
 *
 *    <BATTLEBACK_WAVE : x y>
 *
 *    These values must replace by a real value such as 0.02
 *    - x : the x value is the same as a waveFrequency.
 *    - y : the y value is the same as a waveSpeed.
 *
 *    For Example :
 *    <BATTLEBACK_WAVE : 0.02 0.25>
 *
 * When using Yanfly's Action Sequence Pack 1, you can enable its filter too.
 * This function has the pointer of the Spriteset_Battle and easy to use.
 *
 *    eval: $gameTemp.setBattleBackWaveEffect(cond, waveAmp, waveSpeed);
 *      - cond : Specify true or false whether the wave effect is used.
 *      - waveAmp : the default value is to 0.02
 *      - waveSpeed : the default value is to 0.25
 *
 * =============================================================================
 * Timing
 * =============================================================================
 * if you want to fade-out or fade-in the properties of the wave effect applied to the picture,
 * Let's call the following function.
 *
 * waveUtils.quadraticBezier(start, median, end, dt);
 *
 * dt stands for delta time, The delta time parameter is the elapsed time since the last frame.
 * if you omit it, The wave filter will measure the elapsed time automatically
 * and fill it (In fact, It will be filled with the current time value)
 *
 * To get started with implementing this, add this code just using the script command.
 *
 * var _s, _p, _e, _r;
 * _s = new Point(0.0, 0.0);
 * _p = new Point(0.07, 0.25);
 * _e = new Point(0.0, 0.0);
 * _r = waveUtils.quadraticBezier(_s, _p, _e);
 * $gameScreen.startWave(1, _r.x, _r.y);
 *
 * The value of the wave speed is started with 0.0 and then increased until 0.07 and then decreased to 0.0.
 * The value of the wave amplitude is also started with 0.0 and then increased until 0.25 and then decreased to 0.0.
 *
 * =============================================================================
 * Change Log
 * =============================================================================
 * 2016.01.14 (v1.0.0) - First Release.
 * 2016.01.16 (v1.0.1) - Added the function to remove the filter.
 * 2016.01.18 (v1.1.0) - Added the plugin command.
 * 2016.01.22 (v1.2.0) - Fixed the Save and Load bug
 * 2016.02.16 (v1.3.0) - Fixed Bug (After the player came back to Menu, you had to set the wave effect again)
 * 2016.02.26 (v1.3.1) - Fixed the default padding value of the sprite. (default value is to 512)
 * 2016.03.03 (v1.3.2) - Added new Sprite Properties (wave_amp, wave_speed, wave_length, wave_phase)
 * 2016.08.17 (v1.4.0) - Fixed the issue that is not working in RMMV 1.3.0 (This filter does not support for the time being in Tile-map)
 * 2016.08.18 (v1.5.0) - Supports a wave filter in ShaderTilemap.
 * 2016.10.20 (v1.5.1) - Fixed the issue that is not working in RMMV 1.3.2
 * 2016.11.10 (v1.5.2) - Fixed the issue that is not working in Orange Overlay plugin.
 * 2016.11.18 (v1.5.3) - Fixed an issue where the original tilemap is rendered when using Orange Overlay plugin.
 * 2016.11.26 (v1.5.4) - Added certain code to remove the texture from memory.
 * 2016.11.30 (v1.5.5) - Fixed the issue that has the black border in a filter area.
 * 2017.12.10 (v1.5.6) - Added the plugin command called 'PictureWave' (it is tested on 1.6.0 beta version)
 * 2018.04.12 (v1.5.7) - Fixed a cutting issue.
 * 2018.04.13 (v1.5.7c) - Added the event note tags that can have the wave effect directly for an event graphic.
 * 2018.04.15 (v1.5.7e) - Added a new feature that can apply the wave filter in the battle background images
 * 2018.04.25 (v1.5.7f) - Fixed the note tag error in Battle Test.
 * 2018.05.09 (v1.5.8) - Fixed the bug that is not working the wave filter for the battleback image.
 * 2018.11.01 (v1.5.9) :
 * - Fixed the issue that the wave filter is not working in the game picture.
 * - Fixed the issue that the wave effect do a horizontal looping likes as Tiling Sprite.
 * 2018.11.29 (v1.5.10) :
 * - Fixed the bug that causes an error when calling Erase Event event command.
 * 2019.02.24 (v1.5.11) :
 * - Fixed an issue that is not loaded a save file that you saved before using this script.
 * 2020.08.03 (v1.6.0) :
 * - Performance optimization.
 * 2021.10.27 (v1.6.1) :
 * - added the warning message when the certain game picture is not displayed.
 * =============================================================================
 * Terms of Use
 * =============================================================================
 * Free for commercial and non-commercial use
 *
 */
var Imported = Imported || {};
Imported.RS_WaveFilter = true;

var RS = RS || {};
RS.WaveConfig = RS.WaveConfig || {};

(function () {
    "use strict";

    const isFilterPIXI4 =
        PIXI.VERSION >= "4.0.0" && Utils.RPGMAKER_VERSION >= "1.3.0";
    if (!isFilterPIXI4) {
        console.error("This version does not work on your project");
        console.error(
            "Please download the compatible version from the following link : "
        );
        console.error("https://github.com/biud436/MV/raw/MV/RS_WaveFilter.js");
        return;
    }
    const isWebGL = PIXI.utils.isWebGLSupported();
    const isUseCanvas = Utils.isOptionValid("canvas");
    if (isUseCanvas || !isWebGL) {
        console.error("This plugin does not support in your project");
        return;
    }

    if (PIXI.VERSION >= "5.2.4") {
        PIXI.filters.VoidFilter = PIXI.filters.AlphaFilter;
    }

    //----------------------------------------------------------------------------
    // PIXI.WaveFilter
    //
    //

    PIXI.WaveFilter = function () {
        const vertexSrc = [
            "attribute vec2 aVertexPosition;",
            "attribute vec2 aTextureCoord;",

            "uniform mat3 projectionMatrix;",

            "varying vec2 vTextureCoord;",

            "void main(void){",
            "    gl_Position = vec4((projectionMatrix * vec3(aVertexPosition, 1.0)).xy, 0.0, 1.0);",
            "    vTextureCoord = aTextureCoord;",
            "}",
        ].join("\n");

        const fragmentSrc = [
            "precision mediump float;",

            "varying vec2 vTextureCoord;",

            "uniform float waveHeight;",
            "uniform float waveFrequency;",
            "uniform float waveTime;",
            "uniform float wavePhase;",
            "uniform float UVSpeed;",

            "uniform vec4 filterArea;",
            "uniform vec4 filterClamp;",
            "uniform vec2 origin;",

            "uniform sampler2D uSampler;",

            "void main(void) {",
            "   float time = waveFrequency * sin( wavePhase * (waveTime - vTextureCoord.y / (waveHeight / filterArea.y)) );",
            "   vec2 vCoord = vec2(vTextureCoord.x + time * UVSpeed, vTextureCoord.y);",
            "   gl_FragColor = texture2D(uSampler, clamp(vCoord, filterClamp.xy, filterClamp.zw));",
            "}",
        ].join("\n");

        PIXI.Filter.call(this, vertexSrc, fragmentSrc);

        this.padding = 0;

        this.uniforms.waveHeight = 0.5;
        this.uniforms.waveFrequency = 0.02;
        this.uniforms.waveTime = 0.0;
        this.uniforms.UVSpeed = 0.25;
        this.uniforms.origin = new PIXI.Point(0, 0);
        this.uniforms.wavePhase = 3.141592653589793 * 2;

        this.enabled = true;
        this.resolution = 1;
    };

    PIXI.WaveFilter.prototype = Object.create(PIXI.Filter.prototype);
    PIXI.WaveFilter.prototype.constructor = PIXI.WaveFilter;

    PIXI.WaveFilter.prototype.apply = function (
        filterManager,
        input,
        output,
        clear
    ) {
        this.uniforms.waveHeight = input.sourceFrame.height / 4;

        filterManager.applyFilter(this, input, output, clear);
    };

    Object.defineProperties(PIXI.WaveFilter.prototype, {
        waveHeight: {
            get: function () {
                return this.uniforms.waveHeight;
            },
            set: function (value) {
                this.uniforms.waveHeight = value;
            },
        },
        waveSpeed: {
            get: function () {
                return this.uniforms.UVSpeed;
            },
            set: function (value) {
                this.uniforms.UVSpeed = value;
            },
        },
        waveFrequency: {
            get: function () {
                return this.uniforms.waveFrequency;
            },
            set: function (value) {
                this.uniforms.waveFrequency = value;
            },
        },
        UVSpeed: {
            get: function () {
                return this.uniforms.UVSpeed;
            },
            set: function (value) {
                this.uniforms.UVSpeed = value;
            },
        },
        waveTime: {
            get: function () {
                return this.uniforms.waveTime;
            },
            set: function (value) {
                this.uniforms.waveTime = value;
            },
        },
        wavePhase: {
            get: function () {
                return this.uniforms.wavePhase;
            },
            set: function (value) {
                this.uniforms.wavePhase = (Math.PI / 180) * Number(value);
            },
        },
        origin: {
            get: function () {
                return this.uniforms.origin;
            },
            set: function (value) {
                this.uniforms.origin = value;
            },
        },
    });

    //============================================================================
    // Sprite
    //============================================================================

    const alias_Sprite_initialize = Sprite.prototype.initialize;
    Sprite.prototype.initialize = function (bitmap) {
        alias_Sprite_initialize.call(this, bitmap);
        this.initWithWaveFeatures();
    };

    Sprite.prototype.initWithWaveFeatures = function () {
        this._waveTime = 0;
        this._waveHeight = 0.5;
        this._waveSpeed = 0.25;
        this._waveFrequency = 0.02;
        this._wavePhase = 360;
        this._waveFilter = null;
        this._wave = false;
        this._isWaveDirty = false;
    };

    const alias_Sprite_update = Sprite.prototype.update;
    Sprite.prototype.update = function () {
        alias_Sprite_update.call(this);
        this.waveUpdate();
    };

    Sprite.prototype.getWaveFrameTime = function () {
        this._waveTime = (Date.now() % 10000) / 10000;
        return this._waveTime;
    };

    Sprite.prototype.setWaveHeight = function (n) {
        this._waveHeight = this.height;
    };

    Sprite.prototype.getWaveHeight = function () {
        return this._waveHeight;
    };

    Sprite.prototype.waveUpdate = function () {
        if (this._wave) {
            this._waveFilter.waveTime = this.getWaveFrameTime();
            this._waveFilter.waveHeight = this.getWaveHeight();
            this._waveFilter.waveSpeed = this._waveSpeed;
            this._waveFilter.waveFrequency = this._waveFrequency;
            this._waveFilter.wavePhase = this._wavePhase;
            this._waveFilter.origin.x = $gameMap.canvasToMapX(this.x);
            this._waveFilter.origin.y = $gameMap.canvasToMapY(this.y);
        }
    };

    Object.defineProperty(Sprite.prototype, "waveSpeed", {
        get: function () {
            return this._waveSpeed;
        },
        set: function (value) {
            this._waveSpeed = value;
        },
    });

    Object.defineProperty(Sprite.prototype, "waveFrequency", {
        get: function () {
            return this._waveFrequency;
        },
        set: function (value) {
            this._waveFrequency = value;
        },
    });

    Object.defineProperty(Sprite.prototype, "wave_amp", {
        get: function () {
            return this._waveFrequency;
        },
        set: function (value) {
            this._waveFrequency = value;
        },
    });

    Object.defineProperty(Sprite.prototype, "wave_length", {
        get: function () {
            return this._waveHeight;
        },
        set: function (value) {
            this.setWaveHeight(value);
        },
    });

    Object.defineProperty(Sprite.prototype, "wave_speed", {
        get: function () {
            return this._waveSpeed;
        },
        set: function (value) {
            this._waveSpeed = value;
        },
    });

    Object.defineProperty(Sprite.prototype, "wave_phase", {
        get: function () {
            return this._wavePhase;
        },
        set: function (value) {
            this._wavePhase = value;
        },
    });

    Object.defineProperty(Sprite.prototype, "wave", {
        get: function () {
            return this._wave;
        },
        set: function (value) {
            this._wave = value;
            this._isWaveDirty = true;

            if (this._wave) {
                if (!this._waveFilter) {
                    this._waveFilter = new PIXI.WaveFilter();
                }
                this.filterArea = new PIXI.Rectangle(
                    0,
                    0,
                    Graphics.boxWidth,
                    Graphics.boxHeight
                );
                this.filters = [this._waveFilter];
            } else {
                this.filters = [Sprite.voidFilter];
            }
        },
        configurable: true,
    });

    //============================================================================
    // TilingSprite
    //============================================================================

    const alias_TilingSprite_initialize = TilingSprite.prototype.initialize;
    TilingSprite.prototype.initialize = function (bitmap) {
        alias_TilingSprite_initialize.call(this, bitmap);
        this.initWithWaveFeatures();
    };

    TilingSprite.prototype.initWithWaveFeatures = function () {
        this._waveTime = 0;
        this._waveHeight = 0.5;
        this._waveSpeed = 0.25;
        this._waveFrequency = 0.02;
        this._wavePhase = 360;
        this._waveFilter = null;
        this._wave = false;
    };

    const alias_TilingSprite_update = TilingSprite.prototype.update;
    TilingSprite.prototype.update = function () {
        alias_TilingSprite_update.call(this);
        this.waveUpdate();
    };

    TilingSprite.prototype.getWaveFrameTime = function () {
        this._waveTime = (Date.now() % 10000) / 10000;
        return this._waveTime;
    };

    TilingSprite.prototype.setWaveHeight = function (n) {
        this._waveHeight = this.height;
    };

    TilingSprite.prototype.getWaveHeight = function () {
        return this._waveHeight;
    };

    TilingSprite.prototype.waveUpdate = function () {
        if (this._wave) {
            this._waveFilter.waveTime = this.getWaveFrameTime();
            this._waveFilter.waveHeight = this.getWaveHeight();
            this._waveFilter.waveSpeed = this._waveSpeed;
            this._waveFilter.waveFrequency = this._waveFrequency;
            this._waveFilter.wavePhase = this._wavePhase;
        }
    };

    Object.defineProperty(TilingSprite.prototype, "waveSpeed", {
        get: function () {
            return this._waveSpeed;
        },
        set: function (value) {
            this._waveSpeed = value;
        },
    });

    Object.defineProperty(TilingSprite.prototype, "waveFrequency", {
        get: function () {
            return this._waveFrequency;
        },
        set: function (value) {
            this._waveFrequency = value;
        },
    });

    Object.defineProperty(TilingSprite.prototype, "wave_amp", {
        get: function () {
            return this._waveFrequency;
        },
        set: function (value) {
            this._waveFrequency = value;
        },
    });

    Object.defineProperty(TilingSprite.prototype, "wave_length", {
        get: function () {
            return this._waveHeight;
        },
        set: function (value) {
            this.setWaveHeight(value);
        },
    });

    Object.defineProperty(TilingSprite.prototype, "wave_speed", {
        get: function () {
            return this._waveSpeed;
        },
        set: function (value) {
            this._waveSpeed = value;
        },
    });

    Object.defineProperty(TilingSprite.prototype, "wave_phase", {
        get: function () {
            return this._wavePhase;
        },
        set: function (value) {
            this._wavePhase = value;
        },
    });

    Object.defineProperty(TilingSprite.prototype, "wave", {
        get: function () {
            return this._wave;
        },
        set: function (value) {
            this._wave = value;

            if (this._wave) {
                if (!this._waveFilter) {
                    this._waveFilter = new PIXI.WaveFilter();
                }
                this.filterArea = new PIXI.Rectangle(
                    0,
                    0,
                    Graphics.boxWidth,
                    Graphics.boxHeight
                );
                this.filters = [this._waveFilter];
            } else {
                this.filters = [new PIXI.filters.VoidFilter()];
            }
        },
        configurable: true,
    });

    //============================================================================
    // Sprite_Picture
    //============================================================================

    Sprite_Picture.prototype.updateWave = function () {
        const picture = this.picture();
        const isValidWave = picture.wave();
        if (isValidWave !== this.wave) {
            this.wave = isValidWave;
        }
        this.wave_speed = picture.waveSpeed();
        this.wave_amp = picture.waveAmp();
    };

    const alias_Sprite_Picture_update = Sprite_Picture.prototype.update;
    Sprite_Picture.prototype.update = function () {
        alias_Sprite_Picture_update.call(this);
        if (this.visible) {
            this.updateWave();
        }
    };

    //============================================================================
    // Spriteset_Map
    //============================================================================

    var alias_Spriteset_Map_createLowerLayer =
        Spriteset_Map.prototype.createLowerLayer;
    Spriteset_Map.prototype.createLowerLayer = function () {
        alias_Spriteset_Map_createLowerLayer.call(this);
        this.overwriteWaveProperty();
    };

    Spriteset_Map.prototype.overwriteWaveProperty = function () {
        if (!this._baseSprite) return false;
        const self = this;

        Object.defineProperty(this._baseSprite, "wave", {
            get: function () {
                return this._wave;
            },
            set: function (value) {
                this._wave = value;
                if (this._wave) {
                    if (!this._waveFilter)
                        this._waveFilter = new PIXI.WaveFilter();
                    this.filters = [this._waveFilter, self._toneFilter];
                } else {
                    this.filters = [self._toneFilter];
                }
            },
        });
    };

    const alias_Spriteset_Map_update = Spriteset_Map.prototype.update;
    Spriteset_Map.prototype.update = function () {
        alias_Spriteset_Map_update.call(this);
        this.updateWaveFilter();
    };

    Spriteset_Map.prototype.updateWaveFilter = function () {
        if ($gameSystem && $gameSystem.getWaveEnabled) {
            this._baseSprite.wave = $gameSystem.getWaveEnabled() || false;
            this._baseSprite.wave_amp = $gameSystem.getWaveFrequency() || 0.02;
            this._baseSprite.wave_phase = $gameSystem.getWavePhase() || 360;
            this._baseSprite.wave_speed = $gameSystem.getUVSpeed() || 0.25;
        }
    };

    //============================================================================
    // Spriteset_Battle
    //============================================================================

    var alias_Spriteset_Battle_createBattleback =
        Spriteset_Battle.prototype.createBattleback;
    Spriteset_Battle.prototype.createBattleback = function () {
        alias_Spriteset_Battle_createBattleback.call(this);
        this.initWithWaveEffect();
    };

    Spriteset_Battle.prototype.initWithWaveEffect = function () {
        if (!$dataMap) return;

        const note = $dataMap.note.split(/[\r\n]+/);

        note.forEach((mapNote) => {
            if ($dataMap.note.match(/<BATTLEBACK_WAVE[ ]:[ ]*(.*)[ ](.*)>/i)) {
                this._initWaveFilter = true;
                this.changeWaveEffect(true, RegExp.$1, RegExp.$2);
            }
        });
    };

    Spriteset_Battle.prototype.changeWaveEffect = function (cond, fre, spd) {
        if (!this._initWaveFilter) return;
        const backs = [this._back1Sprite, this._back2Sprite];
        backs.forEach((back) => {
            back.wave = cond;
            back.waveFrequency = parseFloat(fre) || 0.02;
            back.waveSpeed = parseFloat(spd) || 0.25;
        }, this);
    };

    //============================================================================
    // Game_Picture
    //============================================================================

    const alias_Game_Picture_initBasic = Game_Picture.prototype.initBasic;
    Game_Picture.prototype.initBasic = function () {
        alias_Game_Picture_initBasic.call(this);
        this._wave = false;
        this._waveSpeed = 0.25;
        this._waveAmp = 0.02;
    };

    Game_Picture.prototype.wave = function () {
        return this._wave;
    };

    Game_Picture.prototype.waveSpeed = function () {
        return this._waveSpeed;
    };

    Game_Picture.prototype.waveAmp = function () {
        return this._waveAmp;
    };

    Game_Picture.prototype.startWave = function (waveSpeed, waveAmp) {
        this._wave = true;
        this._waveSpeed = waveSpeed;
        this._waveAmp = waveAmp;
    };

    Game_Picture.prototype.stopWave = function () {
        this._wave = false;
    };

    //============================================================================
    // Game_Screen
    //============================================================================

    Game_Screen.prototype.startWave = function (pictureId, waveSpeed, waveAmp) {
        const picture = this.picture(pictureId);
        if (!picture) {
            console.info(
                `Cannot find the game picture ${pictureId}. Note that you can set the picture before starting the wave effect`
            );
            return;
        }
        picture.startWave(waveSpeed, waveAmp);
    };

    Game_Screen.prototype.stopWave = function (pictureId) {
        const picture = this.picture(pictureId);
        if (picture) {
            picture.stopWave();
        }
    };

    //============================================================================
    // Game_Temp
    //============================================================================

    /**
     * In Action Sequence Pack 1, you can use this function.
     * eval: $gameTemp.setBattleBackWaveEffect(cond, waveAmp, waveSpeed);
     */
    Game_Temp.prototype.setBattleBackWaveEffect = function (cond, fre, spd) {
        if (!$gameParty.inBattle()) return;
        const container = SceneManager._scene._spriteset;
        if (container) {
            container.changeWaveEffect(cond, fre, spd);
        }
    };

    //============================================================================
    // Game_System
    //============================================================================

    const alias_Game_System_initialize = Game_System.prototype.initialize;
    Game_System.prototype.initialize = function () {
        alias_Game_System_initialize.call(this);
        this.initWaveProperty();
    };

    Game_System.prototype.initWaveProperty = function () {
        this._waveProp = {
            wave: false,
            waveHeight: Graphics.boxHeight,
            waveFrequency: 0.02,
            waveTime: 0.0,
            UVSpeed: 0.25,
            wavePhase: 360,
        };
    };

    Game_System.prototype.setWaveProperty = function (name, value) {
        if (this._waveProp) {
            this._waveProp[name] = value;
            return this._waveProp[name];
        }
        return 0.0;
    };

    Game_System.prototype.getWaveEnabled = function () {
        if (!this._waveProp) this.initWaveProperty();
        return this._waveProp.wave;
    };

    Game_System.prototype.getWaveHeight = function () {
        if (!this._waveProp) this.initWaveProperty();
        return this._waveProp.waveHeight;
    };

    Game_System.prototype.getWaveFrequency = function () {
        if (!this._waveProp) this.initWaveProperty();
        return this._waveProp.waveFrequency;
    };

    Game_System.prototype.getWaveTime = function () {
        if (!this._waveProp) this.initWaveProperty();
        return this._waveProp.waveTime;
    };

    Game_System.prototype.getUVSpeed = function () {
        if (!this._waveProp) this.initWaveProperty();
        return this._waveProp.UVSpeed;
    };

    Game_System.prototype.getWavePhase = function () {
        if (!this._waveProp) this.initWaveProperty();
        return this._waveProp.wavePhase;
    };

    //============================================================================
    // Game_CharacterBase
    //============================================================================

    const alias_Game_CharacterBase_initMembers =
        Game_CharacterBase.prototype.initMembers;
    Game_CharacterBase.prototype.initMembers = function () {
        alias_Game_CharacterBase_initMembers.call(this);
        this._wave = false;
        this._waveFrequency = 0.02;
        this._waveSpeed = 0.25;
    };

    Game_CharacterBase.prototype.setWave = function (toggle) {
        this._wave = toggle;
    };

    Game_CharacterBase.prototype.setWaveFrequency = function (value) {
        this._waveFrequency = value;
    };

    Game_CharacterBase.prototype.setWaveSpeed = function (value) {
        this._waveSpeed = value;
    };

    Game_CharacterBase.prototype.wave = function () {
        return this._wave;
    };

    Game_CharacterBase.prototype.waveFrequency = function () {
        return this._waveFrequency || 0.02;
    };

    Game_CharacterBase.prototype.waveSpeed = function () {
        return this._waveSpeed || 0.25;
    };

    //============================================================================
    // Sprite_Character
    //============================================================================

    const alias_Sprite_Character_updatePosition =
        Sprite_Character.prototype.updatePosition;
    Sprite_Character.prototype.updatePosition = function () {
        alias_Sprite_Character_updatePosition.call(this);
        if (!this._character) return;
        if (!(this._character instanceof Game_Event)) return;
        const isValidWave = this._character.wave();
        if (this.wave !== isValidWave) this.wave = isValidWave;
        if (this.wave) {
            this.waveFrequency = this._character.waveFrequency();
            this.waveSpeed = this._character.waveSpeed();
        }
    };

    //============================================================================
    // Game_Map
    //============================================================================

    const alias_Game_Event_initMembers = Game_Event.prototype.initMembers;
    Game_Event.prototype.initMembers = function () {
        alias_Game_Event_initMembers.call(this);
        this._lastPageIndex = -2;
    };

    Game_Event.prototype.updateWaveEffect = function () {
        if (this._pageIndex === this._lastPageIndex) return;
        if (!this.page()) return false;
        if (this.findProperPageIndex() < 0) return false;
        if (this._trigger > 3) return false;

        this.list().forEach((list) => {
            const code = list.code;
            const parameters = list.parameters;

            if ([108, 408].includes(code)) {
                if (parameters[0].match(/<(?:WAVE)[ ](.*)>/i)) {
                    this.setWave(Boolean(RegExp.$1 == "true"));
                }
                if (parameters[0].match(/<(?:WAVE_AMP)[ ](.*)>/i)) {
                    this.setWaveFrequency(parseFloat(RegExp.$1) || 0.02);
                }
                if (parameters[0].match(/<(?:WAVE_SPEED)[ ](.*)>/i)) {
                    this.setWaveSpeed(parseFloat(RegExp.$1) || 0.25);
                }
            }
        });

        this._lastPageIndex = this._pageIndex;
    };

    const alias_Game_Event_refresh = Game_Event.prototype.refresh;
    Game_Event.prototype.refresh = function () {
        alias_Game_Event_refresh.call(this);
        this.updateWaveEffect();
    };

    //============================================================================
    // Wave Utils
    //============================================================================

    window.waveUtils = {};

    /**
   * @example
    var _s, _e, _r;
    _s = new Point(0.0, 0.0);
    _e = new Point(0.07, 0.25);
    _r = waveUtils.mix(_s, _e);
    $gameScreen.startWave(1, _r.x, _r.y);
   */
    waveUtils.mix = function (vec1, vec2, t) {
        let vec = new Point(0, 0);
        if (!t) t = (Date.now() % 10000) / 10000;
        vec.x = vec1.x + t * (vec2.x - vec1.x);
        vec.y = vec1.x + t * (vec2.y - vec1.y);
        return vec;
    };

    /**
   * @example
    var _s, _p, _e, _r;
    _s = new Point(0.0, 0.0);
    _p = new Point(0.07, 0.25);
    _e = new Point(0.0, 0.0);
    _r = waveUtils.quadraticBezier(_s, _p, _e);
    $gameScreen.startWave(1, _r.x, _r.y);
   */
    waveUtils.quadraticBezier = function (vec1, vec2, vec3, t) {
        let d, e, p;
        if (!t) t = (Date.now() % 10000) / 10000;
        d = waveUtils.mix(vec1, vec2, t);
        e = waveUtils.mix(vec2, vec3, t);
        p = waveUtils.mix(d, e, t);
        return p;
    };

    //============================================================================
    // Game_Interpreter
    //============================================================================

    const alias_Game_Interpreter_pluginCommand =
        Game_Interpreter.prototype.pluginCommand;
    Game_Interpreter.prototype.pluginCommand = function (command, args) {
        alias_Game_Interpreter_pluginCommand.call(this, command, args);
        if (command === "Tilemap_Wave" || command === "TilemapWave") {
            switch (args[0]) {
                case "Enable":
                    $gameSystem.setWaveProperty("wave", true);
                    break;
                case "Disable":
                    $gameSystem.setWaveProperty("wave", false);
                    break;
                case "waveSpeed":
                    $gameSystem.setWaveProperty("waveSpeed", Number(args[1]));
                    break;
                case "waveFrequency":
                    $gameSystem.setWaveProperty(
                        "waveFrequency",
                        Number(args[1])
                    );
                    break;
                case "UVSpeed":
                    $gameSystem.setWaveProperty("UVSpeed", Number(args[1]));
                    break;
            }
        }
        if (command === "Picture_Wave" || command === "PictureWave") {
            switch (args[0].toLowerCase()) {
                case "start":
                    $gameScreen.startWave(
                        Number(args[1]),
                        Number(args[2]),
                        Number(args[3])
                    );
                    break;
                case "stop":
                    $gameScreen.stopWave(Number(args[1]));
            }
        }
    };
})();