react-simple-game-engine 0.1.63 → 0.1.66

package/lib/classes/scene.js

@@ -0,0 +1,433 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+import { WorldManagement } from "./world-management";
+import { copyProperties, createAssetImage, createAssetSound, tick, } from "../utils";
+import { Sound } from "./sound";
+import { SoundType } from "../export-enums";
+var Scene = /** @class */ (function () {
+    function Scene() {
+        this.entityPropsChangeListeners = {};
+        this.soundBackgroundOptionsChangeListeners = [];
+        this.soundOnceOptionsChangeListeners = [];
+        this.prefabs = [];
+        this.sounds = [];
+        this.sprites = [];
+        this.assetsDelay = 0;
+        this.sessionId = "".concat(Math.random(), "-").concat(new Date().getTime());
+        this.tag = this.constructor.tag;
+        this.ui = this.constructor.ui;
+        this._loadedAssets = false;
+        this.onBorn();
+        this.soundsDecor = this.__proto__.soundsDecor;
+    }
+    Object.defineProperty(Scene.prototype, "UI", {
+        get: function () {
+            var Ui = this.ui || (function () { return null; });
+            return Ui;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Scene.prototype, "UIProps", {
+        get: function () {
+            return this.getUIProps();
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Scene.prototype, "soundBackgroundOptions", {
+        get: function () {
+            return Sound.Management[SoundType.BACKGROUND];
+        },
+        set: function (options) {
+            copyProperties(Sound.Management[SoundType.BACKGROUND], options);
+            for (var _i = 0, _a = this.soundBackgroundOptionsChangeListeners; _i < _a.length; _i++) {
+                var listener = _a[_i];
+                listener(Sound.Management[SoundType.BACKGROUND]);
+            }
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Scene.prototype, "soundOnceOptions", {
+        get: function () {
+            return Sound.Management[SoundType.ONCE];
+        },
+        set: function (options) {
+            copyProperties(Sound.Management[SoundType.ONCE], options);
+            for (var _i = 0, _a = this.soundOnceOptionsChangeListeners; _i < _a.length; _i++) {
+                var listener = _a[_i];
+                listener(Sound.Management[SoundType.ONCE]);
+            }
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Scene.prototype.onSoundOnceOptionsChange = function (func) {
+        var listeners = this.soundOnceOptionsChangeListeners;
+        listeners.push(func);
+        return function () {
+            var index = listeners.indexOf(func);
+            if (index > -1) {
+                listeners.splice(index, 1);
+            }
+        };
+    };
+    Scene.prototype.onSoundBackgroundOptionsChange = function (func) {
+        var listeners = this.soundBackgroundOptionsChangeListeners;
+        listeners.push(func);
+        return function () {
+            var index = listeners.indexOf(func);
+            if (index > -1) {
+                listeners.splice(index, 1);
+            }
+        };
+    };
+    Scene.prototype.bootSoundOptions = function () {
+        var options = this.getSoundOptions();
+        copyProperties(Sound.Management[SoundType.ONCE], options[SoundType.ONCE] || {});
+        copyProperties(Sound.Management[SoundType.BACKGROUND], options[SoundType.BACKGROUND] || {});
+    };
+    Scene.prototype.getSoundOptions = function () {
+        return {};
+    };
+    Scene.prototype.onBorn = function () { };
+    Scene.prototype.getUIProps = function () {
+        return {};
+    };
+    Object.defineProperty(Scene.prototype, "loadedAssets", {
+        get: function () {
+            return this._loadedAssets;
+        },
+        set: function (loadedAssets) {
+            var _a;
+            this._loadedAssets = loadedAssets;
+            (_a = this.loadAssetsListener) === null || _a === void 0 ? void 0 : _a.call(this, loadedAssets);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Scene.prototype.emitEntityPropsChange = function (name, value) {
+        var listeners = this.entityPropsChangeListeners[name] || [];
+        for (var _i = 0, listeners_1 = listeners; _i < listeners_1.length; _i++) {
+            var listener = listeners_1[_i];
+            listener(value);
+        }
+    };
+    Scene.prototype.onEntityPropsChange = function (name, func) {
+        var listeners = (this.entityPropsChangeListeners[name] =
+            this.entityPropsChangeListeners[name] || []);
+        listeners.push(func);
+        return function () {
+            var index = listeners.indexOf(func);
+            if (index > -1) {
+                listeners.splice(index, 1);
+            }
+        };
+    };
+    Scene.prototype.onLoadAssetNotify = function (func) {
+        this.loadAssetsListener = func;
+    };
+    Scene.prototype.destructor = function () {
+        this.worldManagement.destructor();
+        for (var _i = 0, _a = this.sounds; _i < _a.length; _i++) {
+            var sound = _a[_i];
+            sound.stop();
+        }
+    };
+    Scene.prototype.switchToScene = function (tag) {
+        this.manager.gotoScene(tag);
+    };
+    Scene.prototype.loadSprites = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, Promise.all(Scene.spritesDecor.map(function (decor) { return __awaiter(_this, void 0, void 0, function () {
+                            var sprite;
+                            return __generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0:
+                                        if (!decor.src) return [3 /*break*/, 2];
+                                        return [4 /*yield*/, createAssetImage(decor.src)];
+                                    case 1:
+                                        sprite = _a.sent();
+                                        this[decor.propertyKey] = sprite;
+                                        this.sprites.push(sprite);
+                                        _a.label = 2;
+                                    case 2: return [2 /*return*/];
+                                }
+                            });
+                        }); }))];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    Scene.prototype.loadSounds = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, Promise.all(this.soundsDecor.map(function (decor) { return __awaiter(_this, void 0, void 0, function () {
+                            var sound;
+                            return __generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0:
+                                        if (!decor.src) return [3 /*break*/, 2];
+                                        return [4 /*yield*/, createAssetSound(decor.src, decor.type)];
+                                    case 1:
+                                        sound = _a.sent();
+                                        if (decor.volumn) {
+                                            sound.volumn = decor.volumn;
+                                        }
+                                        this[decor.propertyKey] = sound;
+                                        this.sounds.push(sound);
+                                        _a.label = 2;
+                                    case 2: return [2 /*return*/];
+                                }
+                            });
+                        }); }))];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    Scene.prototype.createSprites = function () {
+        var srcables = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            srcables[_i] = arguments[_i];
+        }
+        return __awaiter(this, void 0, void 0, function () {
+            var _this = this;
+            return __generator(this, function (_a) {
+                return [2 /*return*/, Promise.all(srcables.map(function (srcable) { return __awaiter(_this, void 0, void 0, function () {
+                        var src, sprite;
+                        return __generator(this, function (_a) {
+                            switch (_a.label) {
+                                case 0:
+                                    src = (typeof srcable === "string" ? { src: srcable } : srcable).src;
+                                    return [4 /*yield*/, createAssetImage(src)];
+                                case 1:
+                                    sprite = _a.sent();
+                                    this.sprites.push(sprite);
+                                    return [2 /*return*/, sprite];
+                            }
+                        });
+                    }); }))];
+            });
+        });
+    };
+    Scene.prototype.createSounds = function () {
+        var srcables = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            srcables[_i] = arguments[_i];
+        }
+        return __awaiter(this, void 0, void 0, function () {
+            var _this = this;
+            return __generator(this, function (_a) {
+                return [2 /*return*/, Promise.all(srcables.map(function (srcable) { return __awaiter(_this, void 0, void 0, function () {
+                        var _a, volumn, src, _b, type, sound;
+                        return __generator(this, function (_c) {
+                            switch (_c.label) {
+                                case 0:
+                                    _a = typeof srcable === "string"
+                                        ? { src: srcable, volumn: undefined, type: undefined }
+                                        : srcable, volumn = _a.volumn, src = _a.src, _b = _a.type, type = _b === void 0 ? SoundType.ONCE : _b;
+                                    return [4 /*yield*/, createAssetSound(src, type)];
+                                case 1:
+                                    sound = _c.sent();
+                                    if (volumn) {
+                                        sound.volumn = volumn;
+                                    }
+                                    this.sounds.push(sound);
+                                    return [2 /*return*/, sound];
+                            }
+                        });
+                    }); }))];
+            });
+        });
+    };
+    Scene.prototype.mapSprites = function () {
+        var srcs = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            srcs[_i] = arguments[_i];
+        }
+        return __awaiter(this, void 0, void 0, function () {
+            var spritesDecor;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        spritesDecor = Scene.spritesDecor.filter(function (decor) { return !decor.src; });
+                        return [4 /*yield*/, Promise.all(srcs.map(function (src, index) { return __awaiter(_this, void 0, void 0, function () {
+                                var decor, sprite;
+                                return __generator(this, function (_a) {
+                                    switch (_a.label) {
+                                        case 0:
+                                            decor = spritesDecor[index];
+                                            if (!decor) return [3 /*break*/, 2];
+                                            return [4 /*yield*/, createAssetImage(src)];
+                                        case 1:
+                                            sprite = _a.sent();
+                                            this[decor.propertyKey] = sprite;
+                                            this.sprites.push(sprite);
+                                            _a.label = 2;
+                                        case 2: return [2 /*return*/];
+                                    }
+                                });
+                            }); }))];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    Scene.prototype.mapSounds = function () {
+        var srcs = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            srcs[_i] = arguments[_i];
+        }
+        return __awaiter(this, void 0, void 0, function () {
+            var soundsDecor;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        soundsDecor = this.soundsDecor.filter(function (decor) { return !decor.src; });
+                        return [4 /*yield*/, Promise.all(srcs.map(function (src, index) { return __awaiter(_this, void 0, void 0, function () {
+                                var decor, sound;
+                                return __generator(this, function (_a) {
+                                    switch (_a.label) {
+                                        case 0:
+                                            decor = soundsDecor[index];
+                                            if (!decor) return [3 /*break*/, 2];
+                                            return [4 /*yield*/, createAssetSound(src, decor.type)];
+                                        case 1:
+                                            sound = _a.sent();
+                                            if (decor.volumn) {
+                                                sound.volumn = decor.volumn;
+                                            }
+                                            this[decor.propertyKey] = sound;
+                                            this.sounds.push(sound);
+                                            _a.label = 2;
+                                        case 2: return [2 /*return*/];
+                                    }
+                                });
+                            }); }))];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    Scene.prototype.loadAssets = function (delay) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (delay != null) {
+                            this.assetsDelay = delay;
+                        }
+                        // if delay less than 0, it will wait forever
+                        return [4 /*yield*/, tick(this.assetsDelay < 0 ? undefined : this.assetsDelay)];
+                    case 1:
+                        // if delay less than 0, it will wait forever
+                        _a.sent();
+                        this.loadedAssets = false;
+                        return [4 /*yield*/, Promise.all([
+                                this.loadSounds(),
+                                this.loadSprites(),
+                                this.onLoadAssets(),
+                            ]).catch(function (err) {
+                                console.warn("Load assets fail", err.toString());
+                            })];
+                    case 2:
+                        _a.sent();
+                        this.loadedAssets = true;
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    Scene.prototype.onLoadAssets = function () {
+        return __awaiter(this, void 0, void 0, function () { return __generator(this, function (_a) {
+            return [2 /*return*/];
+        }); });
+    };
+    Scene.prototype.getPrefab = function (Class) {
+        return this.prefabs.find(function (pf) { return pf instanceof Class; });
+    };
+    Scene.prototype.bootstrap = function (camera) {
+        this.bootSoundOptions();
+        this.worldManagement = new WorldManagement(camera, this);
+        var components = this.getComponents(camera);
+        var layerIndex = 0;
+        for (var _i = 0, components_1 = components; _i < components_1.length; _i++) {
+            var component = components_1[_i];
+            component.worldManagement = this.worldManagement;
+            component.layerIndex = layerIndex++;
+            if (component.isPrefab) {
+                this.prefabs.push(component);
+            }
+            else {
+                var entity = component.output();
+                this.worldManagement.addEntity(entity);
+            }
+        }
+    };
+    Scene.prototype.onDraw = function () { };
+    Scene.prototype.onUpdate = function () { };
+    Scene.prototype.action = function () {
+        if (Renderer.running) {
+            this.onUpdate();
+            this.worldManagement.update();
+        }
+        Renderer.background(41, 41, 41);
+        this.onDraw();
+        this.worldManagement.draw();
+    };
+    Scene.spritesDecor = [];
+    return Scene;
+}());
+export { Scene };

package/lib/classes/sound-watcher.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sound-watcher.d.ts","sourceRoot":"","sources":["../../src/classes/sound-watcher.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAuB,MAAM,OAAO,CAAC;AACvD,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAC5C,OAAO,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAClD,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAEhC,aAAK,qBAAqB,GAAG;IAC3B,KAAK,EAAE,KAAK,CAAC;IACb,QAAQ,EAAE,CAAC,KAAK,EAAE,eAAe,CAAC,SAAS,CAAC,IAAI,CAAC,KAAK,SAAS,CAAC;CACjE,CAAC;AACF,wBAAgB,gBAAgB,CAAC,EAAE,KAAK,EAAE,QAAQ,EAAE,EAAE,qBAAqB,eAS1E;AAED,aAAK,2BAA2B,GAAG;IACjC,KAAK,EAAE,KAAK,CAAC;IACb,QAAQ,EAAE,CAAC,KAAK,EAAE,eAAe,CAAC,SAAS,CAAC,UAAU,CAAC,KAAK,SAAS,CAAC;CACvE,CAAC;AACF,wBAAgB,sBAAsB,CAAC,EACrC,KAAK,EACL,QAAQ,GACT,EAAE,2BAA2B,eAU7B"}

package/lib/classes/sound-watcher.js

@@ -0,0 +1,33 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+import { Fragment as _Fragment, jsx as _jsx } from "react/jsx-runtime";
+import { useEffect, useState } from "react";
+export function SoundOnceWatcher(_a) {
+    var scene = _a.scene, children = _a.children;
+    var _b = useState(scene.soundOnceOptions), values = _b[0], setValues = _b[1];
+    useEffect(function () {
+        return scene.onSoundOnceOptionsChange(function (options) {
+            setValues(__assign({}, options));
+        });
+    }, [scene]);
+    return _jsx(_Fragment, { children: children(values) });
+}
+export function SoundBackgroundWatcher(_a) {
+    var scene = _a.scene, children = _a.children;
+    var _b = useState(scene.soundBackgroundOptions), values = _b[0], setValues = _b[1];
+    useEffect(function () {
+        return scene.onSoundBackgroundOptionsChange(function (options) {
+            setValues(__assign({}, options));
+        });
+    }, [scene]);
+    return _jsx(_Fragment, { children: children(values) });
+}

package/lib/classes/sound.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sound.d.ts","sourceRoot":"","sources":["../../src/classes/sound.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAC5C,OAAO,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAGlD,qBAAa,KAAK;IAaJ,OAAO,CAAC,QAAQ,CAAC,IAAI;IAZjC,MAAM,CAAC,UAAU,EAAE,eAAe,CAShC;IACF,QAAQ,CAAC,MAAM,EAAE,gBAAgB,CAAe;gBAEnB,IAAI,GAAE,SAA0B;IAE7D,IAAI,MAAM,IAIM,MAAM,CAFrB;IAED,IAAI,MAAM,CAAC,GAAG,EAAE,MAAM,EAErB;IAEK,OAAO;IAQP,IAAI;IAMJ,IAAI;CAWX"}

package/lib/classes/sound.js

@@ -0,0 +1,119 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var _a;
+import { SoundType } from "../export-enums";
+// cant not Sound extends Audio, because TS complite, make call new Audio like a function
+var Sound = /** @class */ (function () {
+    function Sound(type) {
+        if (type === void 0) { type = SoundType.ONCE; }
+        this.type = type;
+        this.native = new Audio();
+    }
+    Object.defineProperty(Sound.prototype, "volumn", {
+        get: function () {
+            return this.native.volume;
+        },
+        set: function (vol) {
+            this.native.volume = vol;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Sound.prototype.playNow = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var canPlay;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        canPlay = Sound.Management[this.type].canPlay;
+                        if (!canPlay) return [3 /*break*/, 2];
+                        this.native.currentTime = 0;
+                        return [4 /*yield*/, this.play()];
+                    case 1:
+                        _a.sent();
+                        _a.label = 2;
+                    case 2: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    Sound.prototype.stop = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                this.native.pause();
+                this.native.currentTime = 0;
+                this.native.src = "";
+                return [2 /*return*/];
+            });
+        });
+    };
+    Sound.prototype.play = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, canPlay, loop;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        _a = Sound.Management[this.type], canPlay = _a.canPlay, loop = _a.loop;
+                        if (!canPlay) return [3 /*break*/, 2];
+                        if (loop) {
+                            this.native.loop = true;
+                        }
+                        else {
+                            this.native.loop = false;
+                        }
+                        return [4 /*yield*/, this.native.play()];
+                    case 1:
+                        _b.sent();
+                        _b.label = 2;
+                    case 2: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    Sound.Management = (_a = {},
+        _a[SoundType.ONCE] = {
+            canPlay: true,
+            loop: false,
+        },
+        _a[SoundType.BACKGROUND] = {
+            canPlay: true,
+            loop: true,
+        },
+        _a);
+    return Sound;
+}());
+export { Sound };

package/lib/classes/sprites/avatar.sprite.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"avatar.sprite.d.ts","sourceRoot":"","sources":["../../../src/classes/sprites/avatar.sprite.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AAE5C,OAAO,EAAE,gBAAgB,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAEpD,aAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAEF,aAAK,sBAAsB,CAAC,CAAC,SAAS,YAAY,IAAI,gBAAgB,CAAC,CAAC,CAAC,GAAG;IAE1E,MAAM,CAAC,EAAE,OAAO,CAAC,WAAW,CAAC,CAAC;CAC/B,CAAC;AAEF,qBAAa,YAAa,SAAQ,MAAM,CAAC,MAAM,GAAG,SAAS,GAAG,IAAI,CAAC;IACjE,OAAO,CAAC,OAAO,CAMb;IAEF,IAAI,MAAM,gBAET;IAED,MAAM;IAuBN,OAAO,CAAC,MAAM,CAAC,EAAE,sBAAsB,CAAC,IAAI,CAAC;CAc9C"}