wgge 0.0.1

package/core/animation/ProgressRotation.js

@@ -0,0 +1,40 @@
+import Rotation from "../model/vector/Rotation";
+import {EASING_FLAT} from "./ProgressValue";
+
+export default class ProgressRotation {
+
+	/**
+	 * @type Number
+	 */
+	start;
+
+	/**
+	 * @type Number
+	 */
+	distance;
+
+	/**
+	 * @type Number
+	 */
+	progress;
+
+	/**
+	 *
+	 * @param {Number} start
+	 * @param {Number} end
+	 * @param {(float) => float} easing
+	 * @param {Number} progress
+	 */
+	constructor(start, end, easing = EASING_FLAT, progress = 0) {
+		this.start = Rotation.normalizeValue(start);
+		this.distance = Rotation.diff(end, start);
+		this.easing = easing;
+		this.progress = progress;
+	}
+
+	get(progress = null) {
+		if (progress !== null) this.progress = progress;
+		return Rotation.normalizeValue(this.start + (this.easing(this.progress) * this.distance));
+	}
+
+}

package/core/animation/ProgressValue.js

@@ -0,0 +1,27 @@
+export const EASING_FLAT = (x) => x;
+export const EASING_EXPONENTIAL_IN = (x, e = 2) => Math.pow(x,e);
+export const EASING_EXPONENTIAL_IN_OUT = (x, e = 2) => (x <= 0.5) ? Math.pow(x * 2, e) / 2 : 1 - Math.pow(2 - x * 2, e) / 2;
+export const EASING_QUAD_IN = EASING_EXPONENTIAL_IN;
+export const EASING_QUAD_IN_OUT = EASING_EXPONENTIAL_IN_OUT;
+export const EASING_CUBIC_IN = (x) => EASING_EXPONENTIAL_IN(x, 3);
+export const EASING_CUBIC_IN_OUT = (x) => EASING_EXPONENTIAL_IN_OUT(x, 3);
+
+export default class ProgressValue {
+	start;
+	end;
+	progress;
+	easing;
+
+	constructor(start, end, easing = EASING_FLAT, progress = 0) {
+		this.start = Number(start);
+		this.diff = Number(end) - this.start;
+		this.easing = easing;
+		this.progress = Number(progress);
+	}
+
+	get(progress = null) {
+		if (progress !== null) this.progress = Number(progress);
+		return this.start + (this.easing(this.progress) * this.diff);
+	}
+
+}

package/core/animation/ProgressVector2.js

@@ -0,0 +1,23 @@
+import ProgressValue, {EASING_FLAT} from "./ProgressValue";
+import Vector2 from "../model/vector/Vector2";
+
+export default class ProgressVector2 {
+	progressX;
+	progressY;
+
+	constructor(start, end, easing = EASING_FLAT, progress = 0) {
+		this.progressX = new ProgressValue(start.x, end.x, easing, progress);
+		this.progressY = new ProgressValue(start.y, end.y, easing, progress);
+	}
+
+	setProgress(progress) {
+		this.progressX.progress = progress;
+		this.progressY.progress = progress;
+	}
+
+	get(progress = null) {
+		if (progress !== null) this.setProgress(progress);
+		return new Vector2(this.progressX.get(), this.progressY.get());
+	}
+
+}

package/core/audio/AudioModel.js

@@ -0,0 +1,36 @@
+import ObjectModel from "../model/ObjectModel";
+import StringValue from "../model/value/StringValue";
+import FloatValue from "../model/value/FloatValue";
+import BoolValue from "../model/value/BoolValue";
+
+export default class AudioModel extends ObjectModel {
+
+	/**
+	 * @type StringValue
+	 */
+	url;
+
+	/**
+	 * @type FloatValue
+	 */
+	volume;
+
+	/**
+	 * @type BoolValue
+	 */
+	playing;
+
+	/**
+	 * @type BoolValue
+	 */
+	loop;
+
+	constructor(persistent = true) {
+		super(persistent);
+
+		this.url = this.addProperty('uri', new StringValue());
+		this.volume = this.addProperty('volume', new FloatValue(1));
+		this.playing = this.addProperty('audioOn', new BoolValue(true));
+		this.loop = this.addProperty('loop', new BoolValue(false));
+	}
+}

package/core/audio/AudioRenderer.js

@@ -0,0 +1,120 @@
+import RendererBase from "../renderer/RendererBase";
+
+const HAVE_ENOUGH_DATA = 4;
+
+export default class AudioRenderer extends RendererBase {
+
+	/**
+	 * @type AudioModel
+	 */
+	model;
+
+	audio;
+	audioContext;
+	destination;
+	source;
+
+	constructor(game, model, audioContext, destination) {
+		super(game, model);
+
+		this.model = model;
+		this.audioContext = audioContext;
+		this.destination = destination;
+
+		this.addAutoEvent(
+			this.game.audio.paused,
+			'change',
+			() => this.updatePlaying()
+		);
+	}
+
+	activateInternal() {
+		this.audio = new Audio();
+		this.source = this.audioContext.createMediaElementSource(this.audio);
+		this.source.connect(this.destination);
+		this.updateAudio();
+
+		this.audio.addEventListener('ended', () => {
+			if (!this.model.loop.get()) {
+				this.model.triggerEvent('remove-me', this.model);
+			}
+		});
+
+		this.game.assets.getAsset(this.model.url.get(), (audio) => {
+			if (!this.audio) {
+				console.log('audio loaded after renderer was deactivated');
+				return;
+			}
+
+			this.audio.addEventListener('canplaythrough', () => {
+				this.updatePlaying();
+			});
+
+			this.audio.src = audio.src;
+		});
+	}
+
+	deactivateInternal() {
+		this.pause();
+		this.source.disconnect();
+		this.source = null;
+		this.audio = null;
+	}
+
+	renderInternal() {
+		if (this.model.loop.isDirty) {
+			this.updateLoop();
+		}
+		if (this.model.volume.isDirty) {
+			this.updateVolume();
+		}
+		if (this.model.playing.isDirty) {
+			this.updatePlaying();
+		}
+	}
+
+	updateAudio() {
+		this.audio.autoplay = false;
+		this.audio.muted = false;
+		this.audio.controls = false;
+		this.updateLoop();
+		this.updateVolume();
+		this.updatePlaying();
+	}
+
+	updatePlaying() {
+		if (this.model.playing.get() && !this.game.audio.paused.get()) {
+			this.play();
+		} else {
+			this.pause();
+		}
+	}
+
+	updateLoop() {
+		this.audio.loop = this.model.loop.get();
+	}
+
+	updateVolume() {
+		this.audio.volume = this.model.volume.get();
+	}
+
+	rewind(time = 0) {
+		this.audio.currentTime = time;
+	}
+
+	replay() {
+		this.rewind();
+		this.play();
+	}
+
+	play() {
+		if (this.audio.readyState === HAVE_ENOUGH_DATA) {
+			this.audio.play();
+		}
+	}
+
+	pause() {
+		this.audio.pause();
+	}
+
+}

package/core/audio/global/GlobalAudioModel.js

@@ -0,0 +1,88 @@
+import ObjectModel from "../../model/ObjectModel";
+import FloatValue from "../../model/value/FloatValue";
+import BoolValue from "../../model/value/BoolValue";
+import ModelNodeCollection from "../../model/collection/ModelNodeCollection";
+import AudioModel from "../AudioModel";
+
+export default class GlobalAudioModel extends ObjectModel {
+
+	/**
+	 * @type BoolValue
+	 */
+	audioOn;
+
+	/**
+	 * @type FloatValue
+	 */
+	masterVolume;
+
+	/**
+	 * @type BoolValue
+	 */
+	musicOn;
+
+	/**
+	 * @type BoolValue
+	 */
+	paused;
+
+	/**
+	 * @type FloatValue
+	 */
+	musicVolume;
+
+	/**
+	 * @type BoolValue
+	 */
+	soundsOn;
+
+	/**
+	 * @type FloatValue
+	 */
+	soundsVolume;
+
+	/**
+	 * @type ModelNodeCollection<AudioModel>
+	 */
+	music;
+
+	/**
+	 * @type ModelNodeCollection<AudioModel>
+	 */
+	sounds;
+
+	constructor(persistent = true) {
+		super(persistent);
+
+		this.audioOn = this.addProperty('audioOn', new BoolValue(true));
+		this.masterVolume = this.addProperty('masterVolume', new FloatValue(1));
+		this.paused = this.addProperty('paused', new BoolValue(false));
+
+		this.musicOn = this.addProperty('musicOn', new BoolValue(true));
+		this.musicVolume = this.addProperty('musicVolume', new FloatValue(1));
+
+		this.soundsOn = this.addProperty('soundsOn', new BoolValue(true));
+		this.soundsVolume = this.addProperty('soundsVolume', new FloatValue(1));
+
+		this.music = this.addProperty('music', new ModelNodeCollection(null, false));
+		this.sounds = this.addProperty('sounds', new ModelNodeCollection(null, false));
+	}
+
+	playSound(url, loop = false) {
+		const sound = new AudioModel();
+		sound.url.set(url);
+		sound.loop.set(loop);
+		sound.playing.set(true);
+		this.sounds.add(sound);
+		return sound;
+	}
+
+	removeSound(audio) {
+		this.sounds.remove(audio);
+	}
+
+	changeMusic(audio) {
+		this.music.reset();
+		this.music.add(audio);
+	}
+}

package/core/audio/global/GlobalAudioRenderer.js

@@ -0,0 +1,108 @@
+import CollectionRenderer from "../../renderer/generic/CollectionRenderer";
+import AudioRenderer from "../AudioRenderer";
+import RendererBase from "../../renderer/RendererBase";
+import ConditionalNodeRenderer from "../../renderer/generic/ConditionalNodeRenderer";
+
+export default class GlobalAudioRenderer extends RendererBase {
+
+	/**
+	 * @type GlobalAudioModel
+	 */
+	model;
+
+	/**
+	 * @type AudioContext
+	 */
+	audioContext;
+
+	constructor(game, model) {
+		super(game, model);
+
+		this.model = model;
+
+		this.addChild(
+			new ConditionalNodeRenderer(
+				this.game,
+				this.model.musicOn,
+				() => this.model.musicOn.get(),
+				() => {
+					return new CollectionRenderer(
+						this.game,
+						this.model.music,
+						(m) => new AudioRenderer(this.game, m, this.audioContext, this.musicGainNode)
+					)
+				}
+			)
+		);
+
+		this.addChild(
+			new ConditionalNodeRenderer(
+				this.game,
+				this.model.soundsOn,
+				() => this.model.soundsOn.get(),
+				() => {
+					return new CollectionRenderer(
+						this.game,
+						this.model.sounds,
+						(m) => new AudioRenderer(this.game, m, this.audioContext, this.soundsGainNode)
+					)
+				}
+			)
+		);
+	}
+
+	activateInternal() {
+		this.audioContext = new AudioContext();
+
+		this.masterGainNode = this.audioContext.createGain();
+		this.musicGainNode = this.audioContext.createGain();
+		this.soundsGainNode = this.audioContext.createGain();
+
+		this.musicGainNode.connect(this.masterGainNode);
+		this.soundsGainNode.connect(this.masterGainNode);
+		this.masterGainNode.connect(this.audioContext.destination);
+
+		this.updateMasterVolume();
+		this.updateSoundsVolume();
+		this.updateMusicVolume();
+	}
+
+	deactivateInternal() {
+
+		this.masterGainNode.disconnect();
+		this.soundsGainNode.disconnect();
+		this.musicGainNode.disconnect();
+
+		this.masterGainNode = null;
+		this.soundsGainNode = null;
+		this.musicGainNode = null;
+		this.audioContext = null;
+	}
+
+	renderInternal() {
+		if (this.audioContext.state === "suspended") {
+			this.audioContext.resume();
+		}
+		if (this.model.masterVolume.isDirty) {
+			this.updateMasterVolume();
+		}
+		if (this.model.musicVolume.isDirty) {
+			this.updateMusicVolume();
+		}
+		if (this.model.soundsVolume.isDirty) {
+			this.updateSoundsVolume();
+		}
+	}
+
+	updateMasterVolume() {
+		this.masterGainNode.gain.value = this.model.masterVolume.get();
+	}
+
+	updateMusicVolume() {
+		this.musicGainNode.gain.value = this.model.musicVolume.get();
+	}
+
+	updateSoundsVolume() {
+		this.soundsGainNode.gain.value = this.model.soundsVolume.get();
+	}
+}

package/core/controller/AnimationController.js

@@ -0,0 +1,37 @@
+import ControllerBase from "./ControllerBase";
+
+export default class AnimationController extends ControllerBase {
+
+	/**
+	 * @type () => any|null
+	 */
+	onFinishedHandler;
+
+	/**
+	 *
+	 * @param game GameModel
+	 * @param model DirtyValue
+	 * @param onFinished () => any|null
+	 */
+	constructor(game, model, onFinished = null) {
+		super(game, model);
+
+		this.onFinishedHandler = onFinished;
+	}
+
+	/**
+	 *
+	 * @param func () => any
+	 * @returns {AnimationController}
+	 */
+	onFinished(func) {
+		this.onFinishedHandler = func;
+		return this;
+	}
+
+	finished() {
+		this.removeMyself();
+		if (this.onFinishedHandler) this.onFinishedHandler();
+	}
+
+}

package/core/controller/AnimationFloatController.js

@@ -0,0 +1,39 @@
+import AnimationController from "./AnimationController";
+import {EASING_FLAT} from "../animation/ProgressValue";
+import AnimatedValue from "../animation/AnimatedValue";
+
+export default class AnimationFloatController extends AnimationController {
+
+	/**
+	 * @type FloatValue
+	 */
+	model;
+
+	/**
+	 * @type AnimatedValue
+	 */
+	animated;
+
+	/**
+	 *
+	 * @param game GameModel
+	 * @param model DirtyValue
+	 * @param target Number
+	 * @param duration Number
+	 * @param easing (float) => float
+	 * @param elapsed Number
+	 */
+	constructor(game, model, target, duration, easing = EASING_FLAT, elapsed = 0) {
+		super(game, model);
+		this.model = model;
+		this.animated = new AnimatedValue(model.get(), target, duration, easing, elapsed);
+	}
+
+	updateInternal(delta) {
+		this.model.set(this.animated.get(delta));
+		if (this.animated.isFinished()) {
+			this.finished();
+		}
+	}
+
+}

package/core/controller/AnimationVector2Controller.js

@@ -0,0 +1,39 @@
+import AnimationController from "./AnimationController";
+import AnimatedVector2 from "../animation/AnimatedVector2";
+import {EASING_FLAT} from "../animation/ProgressValue";
+
+export default class AnimationVector2Controller extends AnimationController {
+
+	/**
+	 * @type AnimatedVector2
+	 */
+	animatedVector;
+
+	/**
+	 * @type Vector2
+	 */
+	model;
+
+	/**
+	 *
+	 * @param game GameModel
+	 * @param model Vector2
+	 * @param target Vector2
+	 * @param duration Number
+	 * @param easing (float) => float
+	 * @param elapsed Number
+	 */
+	constructor(game, model, target, duration, easing = EASING_FLAT, elapsed = 0) {
+		super(game, model);
+		this.model = model;
+		this.animatedVector = new AnimatedVector2(model, target, duration, easing, elapsed);
+	}
+
+	updateInternal(delta) {
+		this.model.set(this.animatedVector.get(delta));
+		if (this.animatedVector.isFinished()) {
+			this.finished();
+		}
+	}
+
+}

package/core/controller/CollectionController.js

@@ -0,0 +1,47 @@
+import ControllerBase from "./ControllerBase";
+
+export default class CollectionController extends ControllerBase {
+
+	/**
+	 * @type ModelNodeCollection
+	 */
+	model;
+
+	constructor(game, model, controllerFactory) {
+		super(game, model);
+		this.model = model;
+
+		this.controllerFactory = controllerFactory;
+
+		this.addAutoEvent(
+			this.model.children,
+			'add',
+			(model) => this.createController(model)
+		);
+
+		this.addAutoEvent(
+			this.model.children,
+			'remove',
+			(model) => this.removeController(model)
+		);
+	}
+
+	activateInternal() {
+		this.resetChildren();
+		this.model.children.forEach((model) => this.createController(model));
+	}
+
+	deactivateInternal() {
+		this.resetChildren();
+	}
+
+	createController(model) {
+		return this.addChild(this.controllerFactory(model));
+	}
+
+	removeController(model) {
+		const controller = this.children.find((ch) => ch.model === model);
+		this.removeChild(controller);
+	}
+
+}

package/core/controller/ConditionalNodeController.js

@@ -0,0 +1,51 @@
+import ControllerBase from "./ControllerBase";
+
+export default class ConditionalNodeController extends ControllerBase {
+
+	/**
+	 * @type DirtyValue
+	 */
+	model;
+
+	constructor(game, model, condition, controllerFactory, defaultControllerFactory = null) {
+		super(game, model);
+		this.model = model;
+
+		this.condition = condition;
+
+		this.controllerFactory = controllerFactory;
+		this.defaultControllerFactory = defaultControllerFactory;
+
+		this.controller = null;
+		this.isUsingDefaultController = false;
+
+		this.addAutoEvent(
+			this.model,
+			'change',
+			() => this.updateController(),
+			true
+		);
+	}
+
+	updateController() {
+		if (this.condition()) {
+			if (this.isUsingDefaultController || this.controller === null) {
+				this.resetChildren();
+				this.controller = this.addChild(this.controllerFactory());
+				this.isUsingDefaultController = false;
+			}
+		} else {
+			if (this.defaultControllerFactory) {
+				if (this.controller === null || this.isUsingDefaultController === false) {
+					this.resetChildren();
+					this.controller = this.addChild(this.defaultControllerFactory());
+					this.isUsingDefaultController = true;
+				}
+			} else {
+				this.resetChildren();
+				this.controller = null;
+			}
+		}
+	}
+
+}