visual_logic.js

/* eslint-disable */

/**
 * Generated by Verge3D Puzzles v.4.2.0
 * Fri, 08 Mar 2024 16:48:34 GMT
 * Prefer not editing this file as your changes may get overridden once Puzzles are saved.
 * Check out https://www.soft8soft.com/docs/manual/en/introduction/Using-JavaScript.html
 * for the information on how to add your own JavaScript to Verge3D apps.
 */
function createPL(v3d = window.v3d) {

// global variables/constants used by puzzles' functions

var LIST_NONE = '<none>';

var _pGlob = {};

_pGlob.objCache = {};
_pGlob.fadeAnnotations = true;
_pGlob.pickedObject = '';
_pGlob.hoveredObject = '';
_pGlob.mediaElements = {};
_pGlob.loadedFile = '';
_pGlob.states = [];
_pGlob.percentage = 0;
_pGlob.openedFile = '';
_pGlob.openedFileMeta = {};
_pGlob.xrSessionAcquired = false;
_pGlob.xrSessionCallbacks = [];
_pGlob.screenCoords = new v3d.Vector2();
_pGlob.intervalTimers = {};
_pGlob.customEvents = new v3d.EventDispatcher();
_pGlob.eventListeners = [];

_pGlob.AXIS_X = new v3d.Vector3(1, 0, 0);
_pGlob.AXIS_Y = new v3d.Vector3(0, 1, 0);
_pGlob.AXIS_Z = new v3d.Vector3(0, 0, 1);
_pGlob.MIN_DRAG_SCALE = 10e-4;
_pGlob.SET_OBJ_ROT_EPS = 1e-8;

_pGlob.vec2Tmp = new v3d.Vector2();
_pGlob.vec2Tmp2 = new v3d.Vector2();
_pGlob.vec3Tmp = new v3d.Vector3();
_pGlob.vec3Tmp2 = new v3d.Vector3();
_pGlob.vec3Tmp3 = new v3d.Vector3();
_pGlob.vec3Tmp4 = new v3d.Vector3();
_pGlob.eulerTmp = new v3d.Euler();
_pGlob.eulerTmp2 = new v3d.Euler();
_pGlob.quatTmp = new v3d.Quaternion();
_pGlob.quatTmp2 = new v3d.Quaternion();
_pGlob.colorTmp = new v3d.Color();
_pGlob.mat4Tmp = new v3d.Matrix4();
_pGlob.planeTmp = new v3d.Plane();
_pGlob.raycasterTmp = new v3d.Raycaster(); // always check visibility

var PL = {};
// backward compatibility
if (v3d[Symbol.toStringTag] !== 'Module') {
    v3d.PL = v3d.puzzles = PL;
}

PL.procedures = PL.procedures || {};




PL.execInitPuzzles = function(options) {
    // always null, should not be available in "init" puzzles
    var appInstance = null;
    // app is more conventional than appInstance (used in exec script and app templates)
    var app = null;

    var _initGlob = {};
    _initGlob.percentage = 0;
    _initGlob.output = {
        initOptions: {
            fadeAnnotations: true,
            useBkgTransp: false,
            preserveDrawBuf: false,
            useCompAssets: false,
            useFullscreen: true,
            useCustomPreloader: false,
            preloaderStartCb: function() {},
            preloaderProgressCb: function() {},
            preloaderEndCb: function() {},
        }
    }

    // provide the container's id to puzzles that need access to the container
    _initGlob.container = options !== undefined && 'container' in options
            ? options.container : "";

    

    // initSettings puzzle
_initGlob.output.initOptions.fadeAnnotations = true;
_initGlob.output.initOptions.useBkgTransp = true;
_initGlob.output.initOptions.preserveDrawBuf = false;
_initGlob.output.initOptions.useCompAssets = false;
_initGlob.output.initOptions.useFullscreen = true;

    return _initGlob.output;
}

PL.init = function(appInstance, initOptions) {

// app is more conventional than appInstance (used in exec script and app templates)
var app = appInstance;

initOptions = initOptions || {};

if ('fadeAnnotations' in initOptions) {
    _pGlob.fadeAnnotations = initOptions.fadeAnnotations;
}

this.procedures["initialize"] = initialize;
this.procedures["animate_move_invader"] = animate_move_invader;
this.procedures["invader_fire"] = invader_fire;
this.procedures["inv_exp_reset"] = inv_exp_reset;
this.procedures["turret_explosion_anim"] = turret_explosion_anim;

var game_over, button_left_pressed, button_right_pressed, button_fire_pressed, cam_type, debug_mode, invader_blast_pause, invader_been_hit, score, turret_exploding, turret_been_hit, lives, turret_check_x, fire_pressed, invader_fired, shot_check_y, turret_fired, shot_x, inv_shot_x, inv_dir, shot_y, inv_shot_y, increasing__score, pew_sound, explosion_sound, boom_sound, inv_x, inv_y;

// utility function envoked by almost all V3D-specific puzzles
// filter off some non-mesh types
function notIgnoredObj(obj) {
    return obj.type !== 'AmbientLight' &&
           obj.name !== '' &&
           !(obj.isMesh && obj.isMaterialGeneratedMesh) &&
           !obj.isAuxClippingMesh;
}


// utility function envoked by almost all V3D-specific puzzles
// find first occurence of the object by its name
function getObjectByName(objName) {
    var objFound;
    var runTime = _pGlob !== undefined;
    objFound = runTime ? _pGlob.objCache[objName] : null;

    if (objFound && objFound.name === objName)
        return objFound;

    if (appInstance.scene) {
        appInstance.scene.traverse(function(obj) {
            if (!objFound && notIgnoredObj(obj) && (obj.name == objName)) {
                objFound = obj;
                if (runTime) {
                    _pGlob.objCache[objName] = objFound;
                }
            }
        });
    }
    return objFound;
}


// utility function envoked by almost all V3D-specific puzzles
// retrieve all objects on the scene
function getAllObjectNames() {
    var objNameList = [];
    appInstance.scene.traverse(function(obj) {
        if (notIgnoredObj(obj))
            objNameList.push(obj.name)
    });
    return objNameList;
}


// utility function envoked by almost all V3D-specific puzzles
// retrieve all objects which belong to the group
function getObjectNamesByGroupName(targetGroupName) {
    var objNameList = [];
    appInstance.scene.traverse(function(obj){
        if (notIgnoredObj(obj)) {
            var groupNames = obj.groupNames;
            if (!groupNames)
                return;
            for (var i = 0; i < groupNames.length; i++) {
                var groupName = groupNames[i];
                if (groupName == targetGroupName) {
                    objNameList.push(obj.name);
                }
            }
        }
    });
    return objNameList;
}


// utility function envoked by almost all V3D-specific puzzles
// process object input, which can be either single obj or array of objects, or a group
function retrieveObjectNames(objNames) {
    var acc = [];
    retrieveObjectNamesAcc(objNames, acc);
    return acc.filter(function(name) {
        return name;
    });
}

function retrieveObjectNamesAcc(currObjNames, acc) {
    if (typeof currObjNames == "string") {
        acc.push(currObjNames);
    } else if (Array.isArray(currObjNames) && currObjNames[0] == "GROUP") {
        var newObj = getObjectNamesByGroupName(currObjNames[1]);
        for (var i = 0; i < newObj.length; i++)
            acc.push(newObj[i]);
    } else if (Array.isArray(currObjNames) && currObjNames[0] == "ALL_OBJECTS") {
        var newObj = getAllObjectNames();
        for (var i = 0; i < newObj.length; i++)
            acc.push(newObj[i]);
    } else if (Array.isArray(currObjNames)) {
        for (var i = 0; i < currObjNames.length; i++)
            retrieveObjectNamesAcc(currObjNames[i], acc);
    }
}

// updateTextObject puzzle
function updateTextObj(objSelector, text) {
    var objNames = retrieveObjectNames(objSelector);

    for (var i = 0; i < objNames.length; i++) {
        var objName = objNames[i];
        if (!objName) continue;
        var obj = getObjectByName(objName);
        if (!obj || !obj.geometry || !obj.geometry.cloneWithText)
            continue;
        obj.geometry = obj.geometry.cloneWithText(String(text));
    }
}

/**
 * Retrieve coordinate system from the loaded scene
 */
function getCoordSystem() {
    var scene = appInstance.scene;

    if (scene && 'coordSystem' in scene.userData) {
        return scene.userData.coordSystem;
    }

    return 'Y_UP_RIGHT';
}


/**
 * Transform coordinates from one space to another
 * Can be used with Vector3 or Euler.
 */
function coordsTransform(coords, from, to, noSignChange) {

    if (from == to)
        return coords;

    var y = coords.y, z = coords.z;

    if (from == 'Z_UP_RIGHT' && to == 'Y_UP_RIGHT') {
        coords.y = z;
        coords.z = noSignChange ? y : -y;
    } else if (from == 'Y_UP_RIGHT' && to == 'Z_UP_RIGHT') {
        coords.y = noSignChange ? z : -z;
        coords.z = y;
    } else {
        console.error('coordsTransform: Unsupported coordinate space');
    }

    return coords;
}


/**
 * Verge3D euler rotation to Blender/Max shortest.
 * 1) Convert from intrinsic rotation (v3d) to extrinsic XYZ (Blender/Max default
 *    order) via reversion: XYZ -> ZYX
 * 2) swizzle ZYX->YZX
 * 3) choose the shortest rotation to resemble Blender's behavior
 */
const eulerV3DToBlenderShortest = function() {

    const eulerTmp = new v3d.Euler();
    const eulerTmp2 = new v3d.Euler();
    const vec3Tmp = new v3d.Vector3();

    return function(euler, dest) {

        const eulerBlender = eulerTmp.copy(euler).reorder('YZX');
        const eulerBlenderAlt = eulerTmp2.copy(eulerBlender).makeAlternative();

        const len = vec3Tmp.setFromEuler(eulerBlender).lengthSq();
        const lenAlt = vec3Tmp.setFromEuler(eulerBlenderAlt).lengthSq();

        dest.copy(len < lenAlt ? eulerBlender : eulerBlenderAlt);
        return coordsTransform(dest, 'Y_UP_RIGHT', 'Z_UP_RIGHT');
    }

}();

function RotationInterface() {
    /**
     * For user manipulations use XYZ extrinsic rotations (which
     * are the same as ZYX intrinsic rotations)
     *     - Blender/Max/Maya use extrinsic rotations in the UI
     *     - XYZ is the default option, but could be set from
     *       some order hint if exported
     */
    this._userRotation = new v3d.Euler(0, 0, 0, 'ZYX');
    this._actualRotation = new v3d.Euler();
}

Object.assign(RotationInterface, {
    initObject: function(obj) {
        if (obj.userData.puzzles === undefined) {
            obj.userData.puzzles = {}
        }
        if (obj.userData.puzzles.rotationInterface === undefined) {
            obj.userData.puzzles.rotationInterface = new RotationInterface();
        }

        var rotUI = obj.userData.puzzles.rotationInterface;
        rotUI.updateFromObject(obj);
        return rotUI;
    }
});

Object.assign(RotationInterface.prototype, {

    updateFromObject: function(obj) {
        var SYNC_ROT_EPS = 1e-8;

        if (!this._actualRotation.equalsEps(obj.rotation, SYNC_ROT_EPS)) {
            this._actualRotation.copy(obj.rotation);
            this._updateUserRotFromActualRot();
        }
    },

    getActualRotation: function(euler) {
        return euler.copy(this._actualRotation);
    },

    setUserRotation: function(euler) {
        // don't copy the order, since it's fixed to ZYX for now
        this._userRotation.set(euler.x, euler.y, euler.z);
        this._updateActualRotFromUserRot();
    },

    getUserRotation: function(euler) {
        return euler.copy(this._userRotation);
    },

    _updateUserRotFromActualRot: function() {
        var order = this._userRotation.order;
        this._userRotation.copy(this._actualRotation).reorder(order);
    },

    _updateActualRotFromUserRot: function() {
        var order = this._actualRotation.order;
        this._actualRotation.copy(this._userRotation).reorder(order);
    }

});

// getObjTransform puzzle
function getObjTransform(objName, isWorldSpace, mode, coord) {
    if (!objName)
        return;
    var obj = getObjectByName(objName);
    if (!obj)
        return;

    var coordSystem = getCoordSystem();

    var transformVal;

    if (isWorldSpace && obj.parent) {
        if (mode === 'position') {
            transformVal = coordsTransform(obj.getWorldPosition(_pGlob.vec3Tmp), 'Y_UP_RIGHT',
                coordSystem, mode === 'scale');
        } else if (mode === 'rotation') {
            transformVal = coordsTransform(obj.getWorldEuler(_pGlob.eulerTmp, 'XYZ'), 'Y_UP_RIGHT',
                coordSystem, mode === 'scale');
        } else if (mode === 'scale') {
            transformVal = coordsTransform(obj.getWorldScale(_pGlob.vec3Tmp), 'Y_UP_RIGHT',
                coordSystem, mode === 'scale');
        }

    } else if (mode === 'rotation' && coordSystem == 'Z_UP_RIGHT') {
        transformVal = eulerV3DToBlenderShortest(obj.rotation,
                _pGlob.eulerTmp);

    } else if (mode === 'rotation' && coordSystem == 'Y_UP_RIGHT') {
        // Maya coordinates
        // Use separate rotation interface to fix ambiguous rotations for Maya,
        // might as well do the same for Blender/Max.

        var rotUI = RotationInterface.initObject(obj);
        transformVal = rotUI.getUserRotation(_pGlob.eulerTmp);

    } else {
        transformVal = coordsTransform(obj[mode].clone(), 'Y_UP_RIGHT',
                coordSystem, mode === 'scale');
    }

    if (mode === 'rotation') {
        transformVal.x = v3d.MathUtils.radToDeg(transformVal.x);
        transformVal.y = v3d.MathUtils.radToDeg(transformVal.y);
        transformVal.z = v3d.MathUtils.radToDeg(transformVal.z);
    }

    if (coord == 'xyz') {
        // remove order component for Euler vectors
        return transformVal.toArray().slice(0, 3);
    } else {
        return transformVal[coord];
    }
}

function AudioWebAudio() {
    this.audio = new v3d.Audio(new v3d.AudioListener());

    this._muted = false;
    this._volume = 1;
}

Object.assign(AudioWebAudio.prototype, {

    load: function(url) {
        var scope = this;

        var xhr = new XMLHttpRequest()
        xhr.open('GET', url);
        xhr.responseType = 'arraybuffer';

        xhr.onload = function(e) {
            if (this.status === 200) {
                // new promise-based syntax is not currently supported in Safari
                scope.audio.context.decodeAudioData(this.response, function(decodedData) {
                    scope.audio.setBuffer(decodedData);
                });
            }
        }

        xhr.send();
        return this;
    },

    play: function() {
        if (this.audio.buffer === null) return;
        this.audio.play();
    },

    pause: function() {
        this.audio.pause();
    },

    stop: function() {
        if (this.audio.buffer === null || this.audio.source === null) return;
        this.audio.stop();
    },

    rewind: function() {
        if (this.audio.buffer === null || this.audio.source === null) return;

        var isPlaying = this.audio.isPlaying;
        this.audio.stop();
        if (isPlaying) {
            this.audio.play();
        }
    },

    setPlaybackTime: function(time) {
        // TODO: not easy with WebAudio
    },

    getPlaybackTime: function() {
        // TODO: not easy with WebAudio
        return 0;
    },

    getDuration: function() {
        return (this.audio.buffer === null) ? 0 : this.audio.buffer.duration;
    },

    setPlaybackRate: function(rate) {
        this.audio.setPlaybackRate(rate);
    },

    isPlaying: function() {
        return this.audio.isPlaying;
    },

    setLoop: function(looped) {
        this.audio.setLoop(looped);
    },

    setVolume: function(volume) {
        this._volume = volume;
        if (!this._muted) {
            this.audio.setVolume(volume);
        }
    },

    setMuted: function(muted) {
        this._muted = muted;
        this.audio.setVolume(muted ? 0 : this._volume);
    },

});

// loadMedia puzzle
function loadMedia_WebAudio(url) {
    if (!v3d.Detector.checkWebAudio()) {
        if (!_pGlob.noWebAudioReported) {
            _pGlob.noWebAudioReported = true;
            console.warn('puzzles: Web Audio API not supported');
        }
        return null;
    }

    var elems = _pGlob.mediaElements;
    if (!(url in elems)) {
        elems[url] = new AudioWebAudio().load(url);
    }
    return elems[url];
}

// volume puzzle
function volume(mediaElem, volume) {
    const mediaElems = (Array.isArray(mediaElem) ? mediaElem : [mediaElem]).filter(elem => elem);

    volume = Number(volume);
    if (Number.isNaN(volume)) {
        return;
    }

    mediaElems.forEach(mediaElem => {
        mediaElem.setVolume(v3d.MathUtils.clamp(volume, 0.0, 1.0));
    });
}

// show and hide puzzles
function changeVis(objSelector, bool) {
    var objNames = retrieveObjectNames(objSelector);

    for (var i = 0; i < objNames.length; i++) {
        var objName = objNames[i]
        if (!objName)
            continue;
        var obj = getObjectByName(objName);
        if (!obj)
            continue;
        obj.visible = bool;
        obj.resolveMultiMaterial().forEach(function(objR) {
            objR.visible = bool;
        });
    }
}

// setObjTransform puzzle
function setObjTransform(objSelector, isWorldSpace, mode, vector, offset){
    var x = vector[0];
      var y = vector[1];
      var z = vector[2];

    var objNames = retrieveObjectNames(objSelector);

    function setObjProp(obj, prop, val) {
        if (!offset) {
            obj[mode][prop] = val;
        } else {
            if (mode != "scale")
                obj[mode][prop] += val;
            else
                obj[mode][prop] *= val;
        }
    }

    var inputsUsed = _pGlob.vec3Tmp.set(Number(x !== ''), Number(y !== ''),
            Number(z !== ''));
    var coords = _pGlob.vec3Tmp2.set(x || 0, y || 0, z || 0);

    if (mode === 'rotation') {
        // rotations are specified in degrees
        coords.multiplyScalar(v3d.MathUtils.DEG2RAD);
    }

    var coordSystem = getCoordSystem();

    coordsTransform(inputsUsed, coordSystem, 'Y_UP_RIGHT', true);
    coordsTransform(coords, coordSystem, 'Y_UP_RIGHT', mode === 'scale');

    for (var i = 0; i < objNames.length; i++) {

        var objName = objNames[i];
        if (!objName) continue;

        var obj = getObjectByName(objName);
        if (!obj) continue;

        if (isWorldSpace && obj.parent) {
            obj.matrixWorld.decomposeE(obj.position, obj.rotation, obj.scale);

            if (inputsUsed.x) setObjProp(obj, "x", coords.x);
            if (inputsUsed.y) setObjProp(obj, "y", coords.y);
            if (inputsUsed.z) setObjProp(obj, "z", coords.z);

            obj.matrixWorld.composeE(obj.position, obj.rotation, obj.scale);
            obj.matrix.multiplyMatrices(_pGlob.mat4Tmp.copy(obj.parent.matrixWorld).invert(), obj.matrixWorld);
            obj.matrix.decompose(obj.position, obj.quaternion, obj.scale);

        } else if (mode === 'rotation' && coordSystem == 'Z_UP_RIGHT') {
            // Blender/Max coordinates

            // need all the rotations for order conversions, especially if some
            // inputs are not specified
            var euler = eulerV3DToBlenderShortest(obj.rotation, _pGlob.eulerTmp);
            coordsTransform(euler, coordSystem, 'Y_UP_RIGHT');

            if (inputsUsed.x) euler.x = offset ? euler.x + coords.x : coords.x;
            if (inputsUsed.y) euler.y = offset ? euler.y + coords.y : coords.y;
            if (inputsUsed.z) euler.z = offset ? euler.z + coords.z : coords.z;

            /**
             * convert from Blender/Max default XYZ extrinsic order to v3d XYZ
             * intrinsic with reversion (XYZ -> ZYX) and axes swizzling (ZYX -> YZX)
             */
            euler.order = "YZX";
            euler.reorder(obj.rotation.order);
            obj.rotation.copy(euler);

        } else if (mode === 'rotation' && coordSystem == 'Y_UP_RIGHT') {
            // Maya coordinates

            // Use separate rotation interface to fix ambiguous rotations for Maya,
            // might as well do the same for Blender/Max.

            var rotUI = RotationInterface.initObject(obj);
            var euler = rotUI.getUserRotation(_pGlob.eulerTmp);
            // TODO(ivan): this probably needs some reasonable wrapping
            if (inputsUsed.x) euler.x = offset ? euler.x + coords.x : coords.x;
            if (inputsUsed.y) euler.y = offset ? euler.y + coords.y : coords.y;
            if (inputsUsed.z) euler.z = offset ? euler.z + coords.z : coords.z;

            rotUI.setUserRotation(euler);
            rotUI.getActualRotation(obj.rotation);
        } else {
            if (inputsUsed.x) setObjProp(obj, "x", coords.x);
            if (inputsUsed.y) setObjProp(obj, "y", coords.y);
            if (inputsUsed.z) setObjProp(obj, "z", coords.z);

        }

        obj.updateMatrixWorld(true);
    }

}

// featureAvailable puzzle
function featureAvailable(feature) {

    var userAgent = window.navigator.userAgent;
    var platform = window.navigator.platform;

    switch (feature) {
    case 'LINUX':
        return /Linux/.test(platform);
    case 'WINDOWS':
        return ['Win32', 'Win64', 'Windows', 'WinCE'].indexOf(platform) !== -1;
    case 'MACOS':
        return (['Macintosh', 'MacIntel', 'MacPPC', 'Mac68K'].indexOf(platform) !== -1 && !v3d.Detector.checkIOS());
    case 'IOS':
        return v3d.Detector.checkIOS();
    case 'ANDROID':
        return /Android/i.test(userAgent);
    case 'MOBILE':
        return (/Android|webOS|BlackBerry/i.test(userAgent) || v3d.Detector.checkIOS());

    case 'CHROME':
        // Chromium based
        return (!!window.chrome && !/Edge/.test(navigator.userAgent));
    case 'FIREFOX':
        return /Firefox/.test(navigator.userAgent);
    case 'IE':
        return /Trident/.test(navigator.userAgent);
    case 'EDGE':
        return /Edge/.test(navigator.userAgent);
    case 'SAFARI':
        return (/Safari/.test(navigator.userAgent) && !/Chrome/.test(navigator.userAgent));

    case 'TOUCH':
        return !!(('ontouchstart' in window) || window.DocumentTouch && document instanceof DocumentTouch);
    case 'RETINA':
        return window.devicePixelRatio >= 2;
    case 'HDR':
        return appInstance.useHDR;
    case 'WEBAUDIO':
        return v3d.Detector.checkWebAudio();
    case 'WEBGL':
        var canvas = document.createElement('canvas');
        var gl = canvas.getContext('webgl')
        return !!gl;
    case 'WEBGL2':
        var canvas = document.createElement('canvas');
        var gl = canvas.getContext('webgl2')
        return !!gl;
    case 'WOOCOMMERCE':
        var woo_fun = window.parent.v3d_woo_get_product_info || window.parent.parent.v3d_woo_get_product_info;
        return !!woo_fun;
    case 'DO_NOT_TRACK':
        if (navigator.doNotTrack == '1' || window.doNotTrack == '1')
            return true;
        else
            return false;
    default:
        return false;
    }

}

// Describe this function...
function initialize() {
  game_over = false;
  cam_type = 'still';
  debug_mode = 'off';
  turret_fired = false;
  turret_been_hit = false;
  turret_exploding = false;
  inv_dir = 0.1;
  invader_fired = false;
  increasing__score = false;
  invader_been_hit = false;
  invader_blast_pause = false;
  score = 0;
  updateTextObj('score', score);
  lives = 3;
  updateTextObj('lives', lives);
  fire_pressed = false;
  animate_move_invader();
  invader_fire();
  inv_x = getObjTransform('invader_root', false, 'position', 'x');
  inv_y = getObjTransform('invader_root', false, 'position', 'y');
  pew_sound = loadMedia_WebAudio('./pew.wav');
  boom_sound = loadMedia_WebAudio('./boom.wav');
  explosion_sound = loadMedia_WebAudio('./explosion.wav');
  volume(explosion_sound, 0.35);
  changeVis('button_fire', false);
  changeVis('button_left', false);
  changeVis('button_right', false);
  changeVis('inv_shot', false);
  changeVis('shot', false);
  setObjTransform('invader_root', false, 'position', [0, 3.22, ''], false);
  setObjTransform('turret_root', false, 'position', [0.098, -2.96, ''], false);
  if (featureAvailable('MOBILE')) {
    changeVis('button_fire', true);
    changeVis('button_left', true);
    changeVis('button_right', true);
  }
}

// setActiveCamera puzzle
function setActiveCamera(camName) {
    var camera = getObjectByName(camName);
    if (!camera || !camera.isCamera || appInstance.getCamera() == camera)
        return;
    appInstance.setCamera(camera);
}

function _checkListenersSame(target0, type0, listener0, optionsOrUseCapture0,
        target1, type1, listener1, optionsOrUseCapture1) {
    const capture0 = Boolean(optionsOrUseCapture0 instanceof Object
            ? optionsOrUseCapture0.capture : optionsOrUseCapture0);
    const capture1 = Boolean(optionsOrUseCapture1 instanceof Object
            ? optionsOrUseCapture1.capture : optionsOrUseCapture1);
    return target0 === target1 && type0 === type1 && listener0 === listener1
            && capture0 === capture1;
}

/**
 * Add the specified event listener to the specified target. This function also
 * stores listener data for easier disposing.
 */
function bindListener(target, type, listener, optionsOrUseCapture) {
    const alreadyExists = _pGlob.eventListeners.some(elem => {
        return _checkListenersSame(elem.target, elem.type, elem.listener,
                elem.optionsOrUseCapture, target, type, listener,
                optionsOrUseCapture);
    });

    if (!alreadyExists) {
        target.addEventListener(type, listener, optionsOrUseCapture);
        _pGlob.eventListeners.push({ target, type, listener, optionsOrUseCapture });
    }
}

// utility function used by the whenClicked, whenHovered and whenDraggedOver puzzles
function initObjectPicking(callback, eventType, mouseDownUseTouchStart, mouseButtons) {

    var elem = appInstance.renderer.domElement;
    bindListener(elem, eventType, pickListener);

    if (eventType == 'mousedown') {

        var touchEventName = mouseDownUseTouchStart ? 'touchstart' : 'touchend';
        bindListener(elem, touchEventName, pickListener);

    } else if (eventType == 'dblclick') {

        var prevTapTime = 0;

        function doubleTapCallback(event) {

            var now = new Date().getTime();
            var timesince = now - prevTapTime;

            if (timesince < 600 && timesince > 0) {

                pickListener(event);
                prevTapTime = 0;
                return;

            }

            prevTapTime = new Date().getTime();
        }

        var touchEventName = mouseDownUseTouchStart ? 'touchstart' : 'touchend';
        bindListener(elem, touchEventName, doubleTapCallback);
    }

    var raycaster = new v3d.Raycaster();

    function pickListener(event) {

        // to handle unload in loadScene puzzle
        if (!appInstance.getCamera())
            return;

        event.preventDefault();

        var xNorm = 0, yNorm = 0;
        if (event instanceof MouseEvent) {
            if (mouseButtons && mouseButtons.indexOf(event.button) == -1)
                return;
            xNorm = event.offsetX / elem.clientWidth;
            yNorm = event.offsetY / elem.clientHeight;
        } else if (event instanceof TouchEvent) {
            var rect = elem.getBoundingClientRect();
            xNorm = (event.changedTouches[0].clientX - rect.left) / rect.width;
            yNorm = (event.changedTouches[0].clientY - rect.top) / rect.height;
        }

        _pGlob.screenCoords.x = xNorm * 2 - 1;
        _pGlob.screenCoords.y = -yNorm * 2 + 1;
        raycaster.setFromCamera(_pGlob.screenCoords, appInstance.getCamera(true));
        var objList = [];
        appInstance.scene.traverse(function(obj){objList.push(obj);});
        var intersects = raycaster.intersectObjects(objList, false);
        callback(intersects, event);
    }
}

function objectsIncludeObj(objNames, testedObjName) {
    if (!testedObjName) return false;

    for (var i = 0; i < objNames.length; i++) {
        if (testedObjName == objNames[i]) {
            return true;
        } else {
            // also check children which are auto-generated for multi-material objects
            var obj = getObjectByName(objNames[i]);
            if (obj && obj.type == "Group") {
                for (var j = 0; j < obj.children.length; j++) {
                    if (testedObjName == obj.children[j].name) {
                        return true;
                    }
                }
            }
        }
    }
    return false;
}

// utility function used by the whenClicked, whenHovered, whenDraggedOver, and raycast puzzles
function getPickedObjectName(obj) {
    // auto-generated from a multi-material object, use parent name instead
    if (obj.isMesh && obj.isMaterialGeneratedMesh && obj.parent) {
        return obj.parent.name;
    } else {
        return obj.name;
    }
}

// whenClicked puzzle
function registerOnClick(objSelector, xRay, doubleClick, mouseButtons, cbDo, cbIfMissedDo) {

    // for AR/VR
    _pGlob.objClickInfo = _pGlob.objClickInfo || [];

    _pGlob.objClickInfo.push({
        objSelector: objSelector,
        callbacks: [cbDo, cbIfMissedDo]
    });

    initObjectPicking(function(intersects, event) {

        var isPicked = false;

        var maxIntersects = xRay ? intersects.length : Math.min(1, intersects.length);

        for (var i = 0; i < maxIntersects; i++) {
            var obj = intersects[i].object;
            var objName = getPickedObjectName(obj);
            var objNames = retrieveObjectNames(objSelector);

            if (objectsIncludeObj(objNames, objName)) {
                // save the object for the pickedObject block
                _pGlob.pickedObject = objName;
                isPicked = true;
                cbDo(event);
            }
        }

        if (!isPicked) {
            _pGlob.pickedObject = '';
            cbIfMissedDo(event);
        }

    }, doubleClick ? 'dblclick' : 'mousedown', false, mouseButtons);
}

// assignMaterial puzzle
function assignMat(objSelector, matName) {
    var objNames = retrieveObjectNames(objSelector);
    if (!matName)
        return;
    var mat = v3d.SceneUtils.getMaterialByName(appInstance, matName);
    if (!mat)
        return;
    for (var i = 0; i < objNames.length; i++) {
        var objName = objNames[i];
        if (!objName)
            continue;
        var obj = getObjectByName(objName);
        if (obj) {
            var firstSubmesh = obj.resolveMultiMaterial()[0];
            firstSubmesh.material = mat;
        }
    }
}

// whenHovered puzzle
initObjectPicking(function(intersects, event) {

    var prevHovered = _pGlob.hoveredObject;
    var currHovered = '';

    // the event might happen before hover registration
    _pGlob.objHoverInfo = _pGlob.objHoverInfo || [];

    // search for closest hovered object

    var lastIntersectIndex = Infinity;
    _pGlob.objHoverInfo.forEach(function(el) {
        var maxIntersects = el.xRay ? intersects.length : Math.min(1, intersects.length);

        for (var i = 0; i < maxIntersects; i++) {
            var obj = intersects[i].object;
            var objName = getPickedObjectName(obj);

            if (objectsIncludeObj(retrieveObjectNames(el.objSelector), objName) && i <= lastIntersectIndex) {
                currHovered = objName;
                lastIntersectIndex = i;
            }
        }
    });

    if (prevHovered == currHovered) return;

    // first - all "out" callbacks, then - all "over"
    _pGlob.objHoverInfo.forEach(function(el) {
        if (objectsIncludeObj(retrieveObjectNames(el.objSelector), prevHovered)) {
            // ensure the correct value of the hoveredObject block
            _pGlob.hoveredObject = prevHovered;
            el.callbacks[1](event);
        }
    });

    _pGlob.objHoverInfo.forEach(function(el) {
        if (objectsIncludeObj(retrieveObjectNames(el.objSelector), currHovered)) {
            // ensure the correct value of the hoveredObject block
            _pGlob.hoveredObject = currHovered;
            el.callbacks[0](event);
        }
    });

    _pGlob.hoveredObject = currHovered;
}, 'mousemove', false);

// whenHovered puzzle
function registerOnHover(objSelector, xRay, cbOver, cbOut) {

    _pGlob.objHoverInfo = _pGlob.objHoverInfo || [];

    _pGlob.objHoverInfo.push({
        objSelector: objSelector,
        callbacks: [cbOver, cbOut],
        xRay: xRay
    });
}

// applyObjLocalTransform puzzle
function applyObjLocalTransform(objSelector, mode, vector) {

    var objNames = retrieveObjectNames(objSelector);
    var x = vector[0] || 0;
      var y = vector[1] || 0;
      var z = vector[2] || 0;

    var defValue = mode == "scale" ? 1 : 0;
    if (typeof x != "number") x = defValue;
    if (typeof y != "number") y = defValue;
    if (typeof z != "number") z = defValue;

    var coords = coordsTransform(_pGlob.vec3Tmp.set(x, y, z), getCoordSystem(), 'Y_UP_RIGHT', mode == 'scale');

    for (var i = 0; i < objNames.length; i++) {
        var objName = objNames[i];
        if (!objName) continue;

        var obj = getObjectByName(objName);
        if (!obj) continue;

        // don't transform values for cameras, their local space happens
        // to be the same as for Blender/Max cameras, bcz their different
        // rest orientation balances difference in coordinate systems
        var useTransformed = !obj.isCamera;
        var xVal = useTransformed ? coords.x : x;
        var yVal = useTransformed ? coords.y : y;
        var zVal = useTransformed ? coords.z : z;

        switch (mode) {
        case "position":
            if (_pGlob.xrSessionAcquired && obj.isCamera) {
                v3d.WebXRUtils.translateVRCamera(obj, _pGlob.AXIS_X, xVal);
                v3d.WebXRUtils.translateVRCamera(obj, _pGlob.AXIS_Y, yVal);
                v3d.WebXRUtils.translateVRCamera(obj, _pGlob.AXIS_Z, zVal);
            } else {
                obj.translateX(xVal);
                obj.translateY(yVal);
                obj.translateZ(zVal);
            }
            break;
        case "rotation":
            if (_pGlob.xrSessionAcquired && obj.isCamera) {
                v3d.WebXRUtils.rotateVRCamera(obj, _pGlob.AXIS_X, v3d.MathUtils.degToRad(xVal));
                v3d.WebXRUtils.rotateVRCamera(obj, _pGlob.AXIS_Y, v3d.MathUtils.degToRad(yVal));
                v3d.WebXRUtils.rotateVRCamera(obj, _pGlob.AXIS_Z, v3d.MathUtils.degToRad(zVal));
            } else {
                obj.rotateX(v3d.MathUtils.degToRad(xVal));
                obj.rotateY(v3d.MathUtils.degToRad(yVal));
                obj.rotateZ(v3d.MathUtils.degToRad(zVal));
            }
            break;
        case "scale":
            obj.scale.x *= xVal;
            obj.scale.y *= yVal;
            obj.scale.z *= zVal;
            break;
        }

        obj.updateMatrixWorld(true);
    }
}

// setTimeout puzzle
function registerSetTimeout(timeout, callback) {
    window.setTimeout(callback, 1000 * timeout);
}

// Describe this function...
function animate_move_invader() {
  if (!invader_blast_pause && !game_over) {
    registerSetTimeout(0.5, function() {
      changeVis('invader_proxy', true);
      changeVis('invader_a', false);
      changeVis('invader_b', true);
      if (!invader_blast_pause) {
        applyObjLocalTransform('invader_root', 'position', [inv_dir, '', '']);
      }
      registerSetTimeout(0.5, function() {
        changeVis('invader_proxy', true);
        changeVis('invader_b', false);
        changeVis('invader_a', true);
        if (!invader_blast_pause) {
          applyObjLocalTransform('invader_root', 'position', [inv_dir, '', '']);
        }
        if (getObjTransform('invader_root', false, 'position', 'x') > 3.8) {
          if (inv_dir == 0.1) {
            inv_dir = -0.1;
            applyObjLocalTransform('invader_root', 'position', ['', -0.28, '']);
          }
        }
        if (getObjTransform('invader_root', false, 'position', 'x') < -3.8) {
          if (inv_dir == -0.1) {
            inv_dir = 0.1;
            applyObjLocalTransform('invader_root', 'position', ['', -0.28, '']);
          }
        }
        animate_move_invader();
      });
    });
  }
}

// everyFrame puzzle
function registerEveryFrame(callback) {
    if (typeof callback == 'function') {
        appInstance.renderCallbacks.push(callback);
        if (PL.editorRenderCallbacks)
            PL.editorRenderCallbacks.push([appInstance, callback]);
    }
}

function _pGetInputSource(controller) {
    if (controller && controller.userData.inputSource) {
        return controller.userData.inputSource
    } else {
        return null;
    }
};

function _pTraverseNonControllers(obj, callback) {

    if (obj.name.startsWith('XR_CONTROLLER_'))
        return;

    callback(obj);

    var children = obj.children;

    for (var i = 0, l = children.length; i < l; i++) {

        _pTraverseNonControllers(children[i], callback);

    }

};

function _pXRGetIntersections(controller) {

    controller.updateMatrixWorld(true);

    _pGlob.mat4Tmp.identity().extractRotation(controller.matrixWorld);

    var objList = [];

    _pTraverseNonControllers(appInstance.scene, function(obj) {
        objList.push(obj);
    });

    var raycaster = new v3d.Raycaster();
    raycaster.ray.origin.setFromMatrixPosition(controller.matrixWorld);
    raycaster.ray.direction.set(0, 0, -1).applyMatrix4(_pGlob.mat4Tmp);

    return raycaster.intersectObjects(objList, false);

}

function _pXROnSelect(event) {

    if (!_pGlob.objClickInfo)
        return;

    var controller = event.target;

    var intersections = _pXRGetIntersections(controller);

    if (intersections.length > 0) {
        var intersection = intersections[0];
        var obj = intersection.object;

        // save the object for the pickedObject block
        _pGlob.pickedObject = getPickedObjectName(obj);

        _pGlob.objClickInfo.forEach(function(el) {
            var isPicked = obj && objectsIncludeObj(retrieveObjectNames(el.objSelector), getPickedObjectName(obj));
            el.callbacks[isPicked ? 0 : 1]();
        });
    } else {
        _pGlob.objClickInfo.forEach(function(el) {
            // missed
            el.callbacks[1]();
        });
    }

}

// getGamepadProp puzzle
function getGamepadProp(index, prop, controlIndex) {

    if (_pGlob.xrSessionAcquired) {
        var controller = appInstance.xrControllers[index];

        if (controller && controller.userData.inputSource &&
                controller.userData.inputSource.gamepad)
            var gamepad = controller.userData.inputSource.gamepad;
        else
            var gamepad = undefined;

    } else {
        var gamepad = navigator.getGamepads()[index];
    }

    switch (prop) {
    case 'AXIS':
        if (gamepad)
            return (gamepad.axes[controlIndex] || 0);
        else
            return 0;

    case 'BUTTON':
        if (gamepad) {
            var button = gamepad.buttons[controlIndex];

            if (button)
                return button.pressed;
            else
                return false;
        } else {
            return false;
        }

    case 'ANALOG_BUTTON':
        if (gamepad) {
            var button = gamepad.buttons[controlIndex];

            if (button)
                return button.value;
            else
                return 0.0;
        } else {
            return 0.0;
        }

    case 'ID':
        if (gamepad)
            return gamepad.id;
        else
            return '';

    case 'CONNECTION_STATUS':
        if (gamepad)
            return gamepad.connected;
        else
            return false;

    case 'TIMESTAMP':
        if (gamepad)
            return gamepad.timestamp;
        else
            return 0.0;

    case 'MAPPING':
        if (gamepad)
            return gamepad.mapping;
        else
            return '';

    case 'DEBUG_INFO':
        if (gamepad) {

            var axes = gamepad.axes;
            var axesValues = []

            for (var i = 0; i < axes.length; i++) {
                axesValues.push(Math.round(axes[i] * 1000) / 1000);
            }

            var buttons = gamepad.buttons;
            var btnsPressed = [];
            var btnsValues = [];

            for (var i = 0; i < buttons.length; i++) {
                btnsPressed.push(buttons[i].pressed ? '☑' : '☐');
                btnsValues.push(Math.round(buttons[i].value * 1000) / 1000);
            }

            return 'Index: ' + index + '\n' +
                   'Connected: ' + (gamepad.connected ? 'Yes' : 'No') + '\n' +
                   'ID: ' + (gamepad.id ? gamepad.id : 'N/A') + '\n' +
                   'Axes: ' + String(axesValues) + '\n' +
                   'Buttons: ' + String(btnsPressed) + '\n' +
                   'Analog Buttons: ' + String(btnsValues) + '\n' +
                   'Timestamp: ' + (gamepad.timestamp ? gamepad.timestamp.toFixed(3) : 0);
        } else {
            return 'Gamepad not available';
        }
    }

}

// playSound puzzle
function playSound(mediaElem, loop) {
    const mediaElems = (Array.isArray(mediaElem) ? mediaElem : [mediaElem]).filter(elem => elem);
    mediaElems.forEach(mediaElem => {
        mediaElem.setLoop(loop);
        mediaElem.play();
    });
}

// Describe this function...
function invader_fire() {
  if (!game_over) {
    registerSetTimeout(3, function() {
      if (!invader_been_hit) {
        if (!invader_fired) {
          invader_fired = true;
          inv_shot_x = getObjTransform('invader_root', false, 'position', 'x') + 0.09;
          inv_shot_y = getObjTransform('invader_root', false, 'position', 'y') - 0.7;
          setObjTransform('inv_shot', false, 'position', [inv_shot_x, inv_shot_y, ''], false);
          changeVis('inv_shot', true);
        }
      }
    });
  }
}

/**
 * Find physics body associated with the given object and remove it.
 */
function _pFindRemovePhysicsBody(obj) {

    for (var i = 0; i < _pGlob.syncList.length; i++) {
        var syncData = _pGlob.syncList[i];

        if (syncData.obj == obj) {

            if (syncData.type == 'SOFT_BODY')
                _pGlob.world.removeSoftBody(syncData.body);
            else
                _pGlob.world.removeRigidBody(syncData.body);

            Ammo.destroy(syncData.body);
            _pGlob.syncList.splice(i, 1);
            i--;
        }
    }
}

/**
 * Find physics constraint associated with the given objects and remove it.
 */
function _pFindRemovePhysicsConstraint(obj1, obj2) {

    for (var i = 0; i < _pGlob.consList.length; i++) {

        var consData = _pGlob.consList[i];

        if (consData.obj1 == obj1 && consData.obj2 == obj2) {

            _pGlob.world.removeConstraint(consData.cons);
            Ammo.destroy(consData.cons);
            _pGlob.consList.splice(i, 1);
            i--;

        }

    }

}

/**
 * Cleanup forces and velocities
 */
function _pResetBody(body) {
    body.clearForces();

    var zeroVec = new Ammo.btVector3(0, 0, 0);

    body.setLinearVelocity(zeroVec);
    body.setAngularVelocity(zeroVec);
}

function _pSetObjToBodyTransform (obj, body) {
    var pos = obj.getWorldPosition(_pGlob.vec3Tmp);
    var quat = obj.getWorldQuaternion(_pGlob.quatTmp);

    _pGlob.transTmp.setIdentity();
    _pGlob.transTmp.setOrigin(new Ammo.btVector3(pos.x, pos.y, pos.z));
    _pGlob.transTmp.setRotation(new Ammo.btQuaternion(quat.x, quat.y, quat.z, quat.w));

    body.setWorldTransform(_pGlob.transTmp);
    body.getMotionState().setWorldTransform(_pGlob.transTmp);
}

// createPhysicsBody puzzle
function createPhysicsBody(type, objSelector, shape, mass) {

    if (!window.Ammo || !_pGlob.world)
        return;

    var objNames = retrieveObjectNames(objSelector);

    objNames.forEach(function(objName) {
        if (!objName)
            return;

        var obj = getObjectByName(objName);
        if (!obj)
            return;

        _pFindRemovePhysicsBody(obj);

        switch (shape) {
        case 'BOX':
        case 'CAPSULE':
        case 'CONE':
        case 'CYLINDER':

            var box = new v3d.Box3();

            obj.resolveMultiMaterial().forEach(function(objR) {
                if (objR.geometry) {
                    if (objR.geometry.boundingBox == null)
                        objR.geometry.computeBoundingBox();

                    box.union(objR.geometry.boundingBox);
                }
            });

            var size = box.getSize(new v3d.Vector3());

            // do not allow empty-sized shapes
            size.x = size.x || 0.5;
            size.y = size.y || 0.5;
            size.z = size.z || 0.5;

            if (shape == 'BOX') {
                var geometry = new Ammo.btBoxShape(new Ammo.btVector3(
                        size.x * 0.5, size.y * 0.5, size.z * 0.5));
            } else if (shape == 'CAPSULE') {
                var radius = Math.max(size.x, size.z) * 0.5;
                var height = size.y - 2 * radius;
                var geometry = new Ammo.btCapsuleShape(radius, height);
            } else if (shape == 'CONE') {
                var radius = Math.max(size.x, size.z) * 0.5;
                var height = size.y;
                var geometry = new Ammo.btConeShape(radius, height);
            } else {
                var geometry = new Ammo.btCylinderShape(new Ammo.btVector3(
                        size.x * 0.5, size.y * 0.5, size.z * 0.5));
            }

            break;
        case 'SPHERE':

            var sphere = new v3d.Sphere();

            obj.resolveMultiMaterial().forEach(function(objR) {
                if (objR.geometry) {
                    // NOTE: by default spheres are based on boundings
                    // so always recalculate them here
                    objR.geometry.computeBoundingSphere();

                    if (sphere.isEmpty()) {
                        sphere.copy(objR.geometry.boundingSphere);
                    } else {
                        sphere.union(objR.geometry.boundingSphere);
                    }
                }
            });

            if (sphere.isEmpty()) {
                sphere.radius = 0.5;
            }

            var geometry = new Ammo.btSphereShape(sphere.isEmpty() ? 0.5 : sphere.radius);

            break;
        case 'MESH':

            var objsR = obj.resolveMultiMaterial();

            if (!objsR[0].geometry || !objsR[0].isMesh) {
                console.error('create rigid body: incorrect mesh object');
                var geometry = new Ammo.btEmptyShape();
                break;
            }

            // allow complex triangle shapes for KINEMATIC objects
            if (type == 'DYNAMIC' || type == 'GHOST') {

                var geometry = new Ammo.btConvexHullShape();

                objsR.forEach(function(objR) {
                    var positions = objR.geometry.attributes.position.array;

                    for (var i = 0; i < positions.length; i+=3) {
                        var x = positions[i];
                        var y = positions[i+1];
                        var z = positions[i+2];

                        var v = new Ammo.btVector3(x, y, z);

                        geometry.addPoint(v);

                        Ammo.destroy(v);
                    }
                });

            } else {

                var triIdxVertArray = new Ammo.btTriangleMesh();

                objsR.forEach(function(objR) {
                    var positions = objR.geometry.attributes.position.array;
                    var indices = objR.geometry.index.array;

                    for (var i = 0; i < indices.length; i+=3) {

                        var i1 = indices[i];
                        var i2 = indices[i+1];
                        var i3 = indices[i+2];

                        var v1 = new Ammo.btVector3(positions[3*i1], positions[3*i1+1], positions[3*i1+2]);
                        var v2 = new Ammo.btVector3(positions[3*i2], positions[3*i2+1], positions[3*i2+2]);
                        var v3 = new Ammo.btVector3(positions[3*i3], positions[3*i3+1], positions[3*i3+2]);

                        triIdxVertArray.addTriangle(v1, v2, v3, false);

                        Ammo.destroy(v1);
                        Ammo.destroy(v2);
                        Ammo.destroy(v3);
                    }
                });

                var geometry = new Ammo.btBvhTriangleMeshShape(triIdxVertArray, true);

            }

            break;
        case 'EMPTY':
            var geometry = new Ammo.btEmptyShape();
            break;
        }

        var pos = obj.getWorldPosition(_pGlob.vec3Tmp);
        var quat = obj.getWorldQuaternion(_pGlob.quatTmp);

        var transform = new Ammo.btTransform();
        transform.setIdentity();
        transform.setOrigin(new Ammo.btVector3(pos.x, pos.y, pos.z));
        transform.setRotation(new Ammo.btQuaternion(quat.x, quat.y, quat.z, quat.w));
        var motionState = new Ammo.btDefaultMotionState(transform);

        if (type == 'STATIC' || type == 'KINEMATIC' || type == 'GHOST')
            var bodyMass = 0;
        else
            var bodyMass = mass;

        var localInertia = new Ammo.btVector3(0, 0, 0);
        geometry.calculateLocalInertia(bodyMass, localInertia);

        var rbInfo = new Ammo.btRigidBodyConstructionInfo(bodyMass, motionState, geometry, localInertia);
        var body = new Ammo.btRigidBody(rbInfo);

        // CF_STATIC_OBJECT is set automatically

        if (type == 'KINEMATIC' || type == 'GHOST') {
            body.setCollisionFlags(body.getCollisionFlags() | CF_KINEMATIC_OBJECT);
            body.setActivationState(DISABLE_DEACTIVATION);
        }

        if (type == 'GHOST') {

            body.setCollisionFlags(body.getCollisionFlags() | CF_NO_CONTACT_RESPONSE);
            _pGlob.world.addRigidBody(body, SensorTrigger, AllFilter);

        } else {

            _pGlob.world.addRigidBody(body);

        }


        //body.setDamping(0.1, 0.1);

        _pGlob.syncList.push({
            obj: obj,
            body: body,
            type: type,
            simulated: true,
            mass: mass
        });

        // external physics interface
        if (PL) {
            PL.physics.bodies[objName] = body;
        }
    });


}

// detectCollision puzzle
function detectCollision(objSelectorA, objSelectorB, collideCb, noCollideCb) {
    if (!window.Ammo || !_pGlob.world)
        return;

    var objNamesA = retrieveObjectNames(objSelectorA);
    var objNamesB = retrieveObjectNames(objSelectorB);

    var objA = getObjectByName(objNamesA[0]);
    var execInstanceID = v3d.MathUtils.generateUUID();

    for (var i = 0; i < objNamesB.length; i++) {
        var objB = getObjectByName(objNamesB[i]);

        var bodyA = null;
        var bodyB = null;

        for (var j = 0; j < _pGlob.syncList.length; j++) {
            var syncData = _pGlob.syncList[j];

            if (syncData.obj == objA)
                bodyA = syncData.body;

            if (syncData.obj == objB)
                bodyB = syncData.body;
        }

        if (objA && objB && bodyA && bodyB) {
            _pGlob.collisionData.push({
                objA: objA,
                objB: objB,
                bodyA: bodyA,
                bodyB: bodyB,
                collideCb: collideCb,
                noCollideCb: noCollideCb,
                collideFlag: true,
                execInstanceID: execInstanceID
            });
        }
    }

}

function mathRandomInt(a, b) {
  if (a > b) {
    // Swap a and b to ensure a is smaller.
    var c = a;
    a = b;
    b = c;
  }
  return Math.floor(Math.random() * (b - a + 1) + a);
}

// Describe this function...
function inv_exp_reset() {
  if (invader_been_hit) {
    score = (typeof score === 'number' ? score : 0) + 10;
    updateTextObj('score', score);
    registerSetTimeout(1, function() {
      setObjTransform('invader_root', false, 'position', [mathRandomInt(-2.8, 2.8), 3.25, ''], false);
      invader_fired = false;
      invader_been_hit = false;
      invader_blast_pause = false;
      animate_move_invader();
      registerSetTimeout(3, function() {
        invader_fire();
      });
    });
  }
}

// Describe this function...
function turret_explosion_anim() {
  if (turret_been_hit) {
    lives = (typeof lives === 'number' ? lives : 0) + -1;
    updateTextObj('lives', lives);
    registerSetTimeout(0.25, function() {
      changeVis('tur_exp_a', false);
      changeVis('tur_exp_b', true);
      registerSetTimeout(0.25, function() {
        changeVis('tur_exp_b', false);
        changeVis('tur_exp_a', true);
        registerSetTimeout(0.25, function() {
          changeVis('tur_exp_a', false);
          changeVis('tur_exp_b', true);
          registerSetTimeout(0.25, function() {
            changeVis('tur_exp_b', false);
            changeVis('tur_exp_a', true);
            registerSetTimeout(0.25, function() {
              changeVis('tur_exp_a', false);
              changeVis('tur_exp_b', true);
              registerSetTimeout(0.25, function() {
                changeVis('tur_exp_b', false);
                changeVis('turret', true);
                turret_been_hit = false;
                turret_exploding = false;
                if (lives < 1) {
                  game_over = true;
                  changeVis('turret', false);
                  changeVis('tur_exp_b', true);
                }
              });
            });
          });
        });
      });
    });
  }
}


initialize();

'Invader by Brian Kumanchik started 7/9/2021';

registerOnClick('cam_button', false, false, [0,1,2], function() {
  if (cam_type == 'still') {
    setActiveCamera('Camera.001');
    cam_type = 'orbit';
  } else {
    if (cam_type == 'orbit') {
      setActiveCamera('Camera');
      cam_type = 'still';
    }
  }
}, function() {});

registerOnClick('debug_button', false, false, [0,1,2], function() {
  if (debug_mode == 'off') {
    debug_mode = 'on';
    assignMat('invader_proxy', 'proxy');
    assignMat('inv_shot_proxy', 'proxy');
    assignMat('turret_proxy', 'proxy');
    assignMat('shot_proxy', 'proxy');
  } else {
    if (debug_mode == 'on') {
      debug_mode = 'off';
      assignMat('invader_proxy', 'invader_a');
      assignMat('inv_shot_proxy', 'invader_a');
      assignMat('turret_proxy', 'invader_a');
      assignMat('shot_proxy', 'invader_a');
    }
  }
}, function() {});

registerOnHover('button_left', false, function() {
  button_left_pressed = true;
}, function() {
  button_left_pressed = false;
});

registerEveryFrame(function() {
  if (!turret_exploding && !game_over) {
    if (button_left_pressed) {
      turret_check_x = getObjTransform('turret_root', false, 'position', 'x');
      if (turret_check_x > -3.8) {
        applyObjLocalTransform('turret_root', 'position', [-0.1, '', '']);
      }
    }
  }
});

registerEveryFrame(function() {
  if (!turret_exploding && !game_over) {
    if (getGamepadProp(0, 'CONNECTION_STATUS', '0')) {
      if (getGamepadProp(0, 'BUTTON', '14')) {
        turret_check_x = getObjTransform('turret_root', false, 'position', 'x');
        if (turret_check_x > -3.8) {
          applyObjLocalTransform('turret_root', 'position', [-0.1, '', '']);
        }
      }
    }
  }
});
registerEveryFrame(function() {
  if (!turret_exploding && !game_over) {
    if (getGamepadProp(0, 'CONNECTION_STATUS', '0')) {
      if (getGamepadProp(0, 'BUTTON', '15')) {
        turret_check_x = getObjTransform('turret_root', false, 'position', 'x');
        if (turret_check_x < 3.8) {
          applyObjLocalTransform('turret_root', 'position', [0.1, '', '']);
        }
      }
    }
  }
});
registerEveryFrame(function() {
  if (!turret_exploding && !game_over) {
    if (getGamepadProp(0, 'CONNECTION_STATUS', '0')) {
      if (getGamepadProp(0, 'BUTTON', '0') && !fire_pressed) {
        fire_pressed = true;
        if (!turret_fired) {
          turret_fired = true;
          shot_x = getObjTransform('turret_root', false, 'position', 'x');
          shot_y = getObjTransform('turret_root', false, 'position', 'y');
          setObjTransform('shot', false, 'position', [shot_x, shot_y, ''], false);
          playSound(pew_sound, false);
        }
      }
    }
  }
});
registerEveryFrame(function() {
  if (turret_fired) {
    changeVis('shot', true);
    applyObjLocalTransform('shot', 'position', ['', 0.15, '']);
    shot_y = getObjTransform('shot', false, 'position', 'y');
    if (shot_y > 3) {
      changeVis('shot', false);
      shot_x = getObjTransform('turret_root', false, 'position', 'x');
      shot_y = getObjTransform('turret_root', false, 'position', 'y');
      setObjTransform('shot', false, 'position', [shot_x, shot_y, ''], false);
      turret_fired = false;
    }
  }
});
registerEveryFrame(function() {
  if (getGamepadProp(0, 'CONNECTION_STATUS', '0')) {
    if (!getGamepadProp(0, 'BUTTON', '0')) {
      fire_pressed = false;
    }
  }
});

registerOnHover('button_right', false, function() {
  button_right_pressed = true;
}, function() {
  button_right_pressed = false;
});

registerEveryFrame(function() {
  if (!turret_exploding && !game_over) {
    if (button_right_pressed) {
      turret_check_x = getObjTransform('turret_root', false, 'position', 'x');
      if (turret_check_x < 3.8) {
        applyObjLocalTransform('turret_root', 'position', [0.1, '', '']);
      }
    }
  }
});

registerOnClick('button_fire', false, false, [0,1,2], function() {
  button_fire_pressed = true;
  registerSetTimeout(1, function() {
    button_fire_pressed = false;
  });
}, function() {});

registerEveryFrame(function() {
  if (!turret_exploding && !game_over) {
    if (button_fire_pressed && !fire_pressed) {
      fire_pressed = true;
      if (!turret_fired) {
        turret_fired = true;
        shot_x = getObjTransform('turret_root', false, 'position', 'x');
        shot_y = getObjTransform('turret_root', false, 'position', 'y');
        setObjTransform('shot', false, 'position', [shot_x, shot_y, ''], false);
        playSound(pew_sound, false);
      }
    }
  }
});
registerEveryFrame(function() {
  if (!button_fire_pressed) {
    fire_pressed = false;
  }
});

registerEveryFrame(function() {
  if (invader_fired && !game_over) {
    applyObjLocalTransform('inv_shot', 'position', ['', -0.1, '']);
    shot_check_y = getObjTransform('inv_shot', false, 'position', 'y');
    if (shot_check_y < -3.3) {
      changeVis('inv_shot', false);
      setObjTransform('inv_shot', false, 'position', [0, 5, ''], false);
      invader_fired = false;
      invader_fire();
    }
  }
});


// createPhysicsWorld puzzle

if (window.Ammo) {

var CF_STATIC_OBJECT = 1;
var CF_KINEMATIC_OBJECT = 2;
var CF_NO_CONTACT_RESPONSE = 4;

var ACTIVE_TAG = 1;
var ISLAND_SLEEPING = 2;
var DISABLE_DEACTIVATION = 4;
var DISABLE_SIMULATION = 5;

var RO_XYZ = 0;

// collision filter groups
var DefaultFilter = 1;
var StaticFilter = 2;
var KinematicFilter = 4;
var DebrisFilter = 8;
var SensorTrigger = 16;
var CharacterFilter = 32;
var AllFilter = -1;

if (false) {

    _pGlob.collisionConfiguration = new Ammo.btSoftBodyRigidBodyCollisionConfiguration();
    _pGlob.dispatcher = new Ammo.btCollisionDispatcher(_pGlob.collisionConfiguration);
    _pGlob.broadphase = new Ammo.btDbvtBroadphase();
    _pGlob.solver = new Ammo.btSequentialImpulseConstraintSolver();
    _pGlob.softBodySolver = new Ammo.btDefaultSoftBodySolver();
    _pGlob.world = new Ammo.btSoftRigidDynamicsWorld(_pGlob.dispatcher, _pGlob.broadphase,
            _pGlob.solver, _pGlob.collisionConfiguration, _pGlob.softBodySolver);
    _pGlob.world.getWorldInfo().set_m_gravity(new Ammo.btVector3(0, -9.8, 0));

    _pGlob.softBodyHelpers = new Ammo.btSoftBodyHelpers();

} else {

    _pGlob.collisionConfiguration = new Ammo.btDefaultCollisionConfiguration();
    _pGlob.dispatcher = new Ammo.btCollisionDispatcher(_pGlob.collisionConfiguration);
    _pGlob.broadphase = new Ammo.btDbvtBroadphase();
    _pGlob.solver = new Ammo.btSequentialImpulseConstraintSolver();
    _pGlob.world = new Ammo.btDiscreteDynamicsWorld(_pGlob.dispatcher, _pGlob.broadphase,
            _pGlob.solver, _pGlob.collisionConfiguration);

}

_pGlob.syncList = [];
_pGlob.consList = [];

// internal info
_pGlob.collisionData = [];

// goes to collision callback
_pGlob.collisionInfo = {
    objectA: '',
    objectB: '',
    distance: 0,
    positionOnA: [0, 0, 0],
    positionOnB: [0, 0, 0],
    normalOnB: [0, 0, 0]
};

_pGlob.fps = 120;
_pGlob.transTmp = new Ammo.btTransform();
_pGlob.transTmp2 = new Ammo.btTransform();

_pGlob.world.setGravity( new Ammo.btVector3( 0, -9.8, 0 ) );

// external physics interface
if (PL) {
    PL.physics = PL.physics || {};
    PL.physics.world = _pGlob.world;
    PL.physics.bodies = {};
    PL.physics.constraints = {};
    PL.physics.addToSyncList = function(obj, body, type) {
        _pGlob.syncList.push({
            obj: obj,
            body: body,
            type: type,
            simulated: true,
            mass: (body.getInvMass() !==0) ? 1.0/body.getInvMass() : 0
        });
        PL.physics.bodies[obj.name] = body;
    }
    PL.physics.removeFromSyncList = function(obj, body) {
        _pFindRemovePhysicsBody(obj);
        delete PL.physics.bodies[obj.name];
    }
}

function tick(dt) {

    var DISTANCE_EPSILON = 0.000001;

    if (_pGlob.collisionData.length) {

        var numManifolds = _pGlob.world.getDispatcher().getNumManifolds();

        for (var i = 0; i < numManifolds; i++) {
            var contactManifold = _pGlob.world.getDispatcher().getManifoldByIndexInternal(i);

            var bodyA = Ammo.castObject(contactManifold.getBody0(), Ammo.btRigidBody);
            var bodyB = Ammo.castObject(contactManifold.getBody1(), Ammo.btRigidBody);

            var collDataMatch = null;
            var objsSwapped = false;

            for (var j = 0; j < _pGlob.collisionData.length; j++) {
                var cd = _pGlob.collisionData[j];

                if (cd.bodyA == bodyA && cd.bodyB == bodyB) {
                    collDataMatch = cd;
                    break;
                }

                if (cd.bodyA == bodyB && cd.bodyB == bodyA) {
                    collDataMatch = cd;
                    objsSwapped = true;
                    break;
                }
            }

            if (!collDataMatch)
                continue;

            var numContacts = contactManifold.getNumContacts();

            for (var j = 0; j < numContacts; j++) {
                var pt = contactManifold.getContactPoint(j);

                if (pt.getDistance() < DISTANCE_EPSILON) {
                    var ptA = pt.getPositionWorldOnA();
                    var ptB = pt.getPositionWorldOnB();
                    var noB = pt.get_m_normalWorldOnB();

                    _pGlob.collisionInfo.objectA = collDataMatch.objA ? getPickedObjectName(collDataMatch.objA) : '';
                    _pGlob.collisionInfo.objectB = collDataMatch.objB ? getPickedObjectName(collDataMatch.objB) : '';

                    _pGlob.collisionInfo.distance = pt.getDistance();

                    if (!objsSwapped) {
                        _pGlob.collisionInfo.positionOnA[0] = ptA.x();
                        _pGlob.collisionInfo.positionOnA[1] = ptA.y();
                        _pGlob.collisionInfo.positionOnA[2] = ptA.z();

                        _pGlob.collisionInfo.positionOnB[0] = ptB.x();
                        _pGlob.collisionInfo.positionOnB[1] = ptB.y();
                        _pGlob.collisionInfo.positionOnB[2] = ptB.z();

                        _pGlob.collisionInfo.normalOnB[0] = noB.x();
                        _pGlob.collisionInfo.normalOnB[1] = noB.y();
                        _pGlob.collisionInfo.normalOnB[2] = noB.z();
                    } else {
                        _pGlob.collisionInfo.positionOnA[0] = ptB.x();
                        _pGlob.collisionInfo.positionOnA[1] = ptB.y();
                        _pGlob.collisionInfo.positionOnA[2] = ptB.z();

                        _pGlob.collisionInfo.positionOnB[0] = ptA.x();
                        _pGlob.collisionInfo.positionOnB[1] = ptA.y();
                        _pGlob.collisionInfo.positionOnB[2] = ptA.z();

                        _pGlob.collisionInfo.normalOnB[0] = -noB.x();
                        _pGlob.collisionInfo.normalOnB[1] = -noB.y();
                        _pGlob.collisionInfo.normalOnB[2] = -noB.z();
                    }

                    collDataMatch.collideCb();

                    // mark as collided all collision data from the same exec instance
                    for (var k = 0; k < _pGlob.collisionData.length; k++) {
                        var cd = _pGlob.collisionData[k];
                        if (cd.execInstanceID == collDataMatch.execInstanceID) {
                            cd.collideFlag = true;
                        }
                    }
                }
            }
        }

        for (var i = 0; i < _pGlob.collisionData.length; i++) {
            var cd = _pGlob.collisionData[i];

            if (!cd.collideFlag) {
                _pGlob.collisionInfo.objectA = '';
                _pGlob.collisionInfo.objectB = '';

                _pGlob.collisionInfo.distance = 0;

                _pGlob.collisionInfo.positionOnA[0] = 0;
                _pGlob.collisionInfo.positionOnA[1] = 0;
                _pGlob.collisionInfo.positionOnA[2] = 0;

                _pGlob.collisionInfo.positionOnB[0] = 0;
                _pGlob.collisionInfo.positionOnB[1] = 0;
                _pGlob.collisionInfo.positionOnB[2] = 0;

                _pGlob.collisionInfo.normalOnB[0] = 0;
                _pGlob.collisionInfo.normalOnB[1] = 0;
                _pGlob.collisionInfo.normalOnB[2] = 0;

                cd.noCollideCb();

                // no need to process other collision data from the same exec instance
                for (var j = i+1; j < _pGlob.collisionData.length; j++) {
                    var cdj = _pGlob.collisionData[j];
                    if (cdj.execInstanceID == cd.execInstanceID) {
                        cdj.collideFlag = true;
                    }
                }
            }

            cd.collideFlag = false;
        }
    }

    _pGlob.world.stepSimulation(dt, 10, 1/120);

    // sync physics and graphics

    for (var i = 0; i < _pGlob.syncList.length; i++) {
        var syncData = _pGlob.syncList[i];
        if (!syncData.simulated)
            continue;

        var body = syncData.body;

        if (syncData.type == 'SOFT_BODY') {

            var geometry = syncData.obj.geometry;
            var volumePositions = geometry.attributes.position.array;
            var volumeNormals = geometry.ammoNeedNormals ? geometry.attributes.normal.array : null;

            var association = geometry.ammoIndexAssociation;
            var numVerts = association.length;
            var nodes = body.get_m_nodes();

            for (var j = 0; j < numVerts; j++) {

                var node = nodes.at(j);

                var nodePos = node.get_m_x();
                var x = nodePos.x();
                var y = nodePos.y();
                var z = nodePos.z();

                if (volumeNormals) {
                    var nodeNormal = node.get_m_n();
                    var nx = nodeNormal.x();
                    var ny = nodeNormal.y();
                    var nz = nodeNormal.z();
                }

                var assocVertex = association[j];

                for (var k = 0, kl = assocVertex.length; k < kl; k++) {

                    var indexVertex = assocVertex[k];
                    volumePositions[indexVertex] = x;
                    if (volumeNormals)
                        volumeNormals[indexVertex] = nx;

                    indexVertex++;
                    volumePositions[indexVertex] = y;
                    if (volumeNormals)
                        volumeNormals[indexVertex] = ny;

                    indexVertex++;
                    volumePositions[indexVertex] = z;
                    if (volumeNormals)
                        volumeNormals[indexVertex] = nz;

                }

            }

            geometry.attributes.position.needsUpdate = true;
            if (volumeNormals)
                geometry.attributes.normal.needsUpdate = true;

            if (geometry.attributes.previous) {
                v3d.MeshLine.updateAttributes(geometry);
            }

        } else if (!body.isStaticOrKinematicObject()) {
            var ms = body.getMotionState();
            if (ms) {
                ms.getWorldTransform(_pGlob.transTmp);
                var p = _pGlob.transTmp.getOrigin();
                var q = _pGlob.transTmp.getRotation();
                // dynamic objects can't be parented to something
                syncData.obj.position.set(p.x(), p.y(), p.z());
                syncData.obj.quaternion.set(q.x(), q.y(), q.z(), q.w());
            }

        } else if (body.isKinematicObject()) {

            var pos = syncData.obj.getWorldPosition(_pGlob.vec3Tmp);
            var quat = syncData.obj.getWorldQuaternion(_pGlob.quatTmp);

            _pGlob.transTmp.setIdentity();
            _pGlob.transTmp.setOrigin(new Ammo.btVector3(pos.x, pos.y, pos.z));
            _pGlob.transTmp.setRotation(new Ammo.btQuaternion(quat.x, quat.y, quat.z, quat.w));

            body.setWorldTransform(_pGlob.transTmp);

            // needed to calculate interpolated velocity
            body.getMotionState().setWorldTransform(_pGlob.transTmp);

        }
    }

}

appInstance.renderCallbacks.push(tick);
if (PL.editorRenderCallbacks)
    PL.editorRenderCallbacks.push([appInstance, tick]);

} else {
    console.error('create physics world: physics modules not found, please copy them to the app directory');
}


createPhysicsBody('GHOST', 'shot_proxy', 'BOX', 0);
createPhysicsBody('GHOST', 'invader_proxy', 'BOX', 0);
detectCollision('shot_proxy', 'invader_proxy', function() {
  if (!invader_blast_pause && !game_over) {
    invader_blast_pause = true;
    invader_been_hit = true;
    changeVis('invader_a', false);
    changeVis('invader_b', false);
    changeVis('blast', true);
    setObjTransform('shot', false, 'position', [0, -5, ''], false);
    playSound(boom_sound, false);
    inv_exp_reset();
  }
}, function() {});

registerEveryFrame(function() {
  if (invader_blast_pause) {
    changeVis('invader_a', false);
    changeVis('invader_b', false);
    changeVis('inv_shot', false);
    changeVis('blast', true);
  } else {
    changeVis('blast', false);
  }
});

createPhysicsBody('GHOST', 'inv_shot_proxy', 'BOX', 0);
createPhysicsBody('GHOST', 'turret_proxy', 'BOX', 0);
detectCollision('inv_shot_proxy', 'turret_proxy', function() {
  if (!turret_exploding && !game_over) {
    turret_exploding = true;
    turret_been_hit = true;
    changeVis('turret', false);
    changeVis('tur_exp_a', true);
    setObjTransform('inv_shot', false, 'position', [1, 5, ''], false);
    playSound(explosion_sound, false);
    turret_explosion_anim();
  }
}, function() {});

registerEveryFrame(function() {
  if (turret_exploding) {
    changeVis('turret', false);
  } else {
    changeVis('turret', true);
    changeVis('tur_exp_a', false);
    changeVis('tur_exp_b', false);
  }
});

registerEveryFrame(function() {
  if (game_over) {
    changeVis('turret', false);
    changeVis('tur_exp_a', true);
    changeVis('inv_shot', false);
    changeVis('GAME_OVER', true);
  } else {
    changeVis('GAME_OVER', false);
  }
});

registerEveryFrame(function() {
  if (game_over) {
    if (getGamepadProp(0, 'CONNECTION_STATUS', '0')) {
      if (getGamepadProp(0, 'BUTTON', '9')) {
        game_over = false;
        initialize();
      }
    }
  }
});



} // end of PL.init function

PL.disposeListeners = function() {
    if (_pGlob) {
        _pGlob.eventListeners.forEach(({ target, type, listener, optionsOrUseCapture }) => {
            target.removeEventListener(type, listener, optionsOrUseCapture);
        });
        _pGlob.eventListeners.length = 0;
    }
}

PL.dispose = function() {
    PL.disposeListeners();
    _pGlob = null;
    // backward compatibility
    if (v3d[Symbol.toStringTag] !== 'Module') {
        delete v3d.PL;
        delete v3d.puzzles;
    }
}

PL.loadPhysics = function() {
    return new Promise(function(resolve, reject) {
        if (!window.Ammo) {
            // COMPAT: < 4.2.0, new puzzles, old engine
            const ammoURL = v3d.findModulePath ? v3d.findModulePath('ammo.wasm.js') :
                    new URL('ammo.wasm.js', document.baseURI).href;

            import(ammoURL).then(mod => {
                let AmmoInit = mod.default;
                // COMPAT: < 4.2.0, new puzzles, old ammo
                if (AmmoInit) {
                    // COMPAT: < 4.4.0, old non-async ammo module
                    if (AmmoInit.constructor.name == 'AsyncFunction') {
                        AmmoInit().then(Ammo => {
                            window.Ammo = Ammo;
                            resolve(Ammo);
                        }).catch(e => {
                            console.error('Failed to fetch ammo.wasm.wasm module', e);
                            resolve();
                        });
                    } else {
                        new AmmoInit().then(Ammo => {
                            window.Ammo = Ammo;
                            resolve(Ammo);
                        }).catch(e => {
                            console.error('Failed to fetch ammo.wasm.wasm module', e);
                            resolve();
                        });
                    }
                } else {
                    // COMPAT: < 4.2.0, old non-modularized ammo.js
                    // which is not connected to html (rare case)
                    resolve();
                }
            }).catch(e => {
                console.error('Failed to fetch ammo.wasm.js/ammo.wasm.wasm modules', e);
                resolve();
            });
        } else {
            resolve(window.Ammo);
        }
    });
}


return PL;

}

export { createPL };