core2d 2.10.2

package/src/Input.mjs

@@ -0,0 +1,123 @@
+"use strict";
+
+import { Controller } from "./Controller.mjs";
+import { GamePad } from "./GamePad.mjs";
+import { Keyboard } from "./Keyboard.mjs";
+import { Mouse } from "./Mouse.mjs";
+import { Pointer } from "./Pointer.mjs";
+import { Static } from "./Static.mjs";
+import { Touch } from "./Touch.mjs";
+
+export class Input {
+	constructor() {
+		this._controllers = [];
+		this._controllerQueue = [];
+		this._controllerRequestQueue = [];
+		this._pointers = [];
+		this._pointerQueue = [];
+		this._pointerRequestQueue = [];
+		this._gamePads = 0;
+
+		const ON_KEYBOARD = (event) => {
+			removeEventListener("keydown", ON_KEYBOARD);
+			console.log("Keyboard detected.");
+			this.addController(new Keyboard(event));
+		};
+
+		const ON_MOUSE = (event) => {
+			removeEventListener("mousemove", ON_MOUSE);
+			console.log("Mouse detected.");
+			this.addPointer(new Mouse(event));
+		};
+
+		const ON_TOUCH = (event) => {
+			removeEventListener("touchstart", ON_TOUCH);
+			console.log("Touch detected.");
+			this.addPointer(new Touch(event));
+		};
+
+		addEventListener("keydown", ON_KEYBOARD, false);
+		addEventListener("mousemove", ON_MOUSE, false);
+		addEventListener("touchstart", ON_TOUCH, false);
+	}
+
+	static getGamePadAxes(id) {
+		if (Static.getGamepads()[id]) {
+			return Static.getGamepads()[id].axes;
+		}
+
+		return [];
+	}
+
+	static getGamePadButtons(id) {
+		const GAMEPAD = Static.getGamepads()[id];
+		return GAMEPAD && GAMEPAD.buttons || [];
+	}
+
+	addController(device) {
+		this._controllerQueue.push(device);
+		this.checkControllerQueues();
+	}
+
+	addPointer(device) {
+		this._pointerQueue.push(device);
+		this.checkPointerQueues();
+	}
+
+	checkGamePads() {
+		if (Static.getGamepads()[this._gamePads]) {
+			console.log("Game pad detected.");
+			this.addController(new GamePad(this._gamePads++));
+		}
+	}
+
+	checkControllerQueues() {
+		if (this._controllerRequestQueue.length > 0 && this._controllerQueue.length > 0) {
+			const REQUESTER = this._controllerRequestQueue.shift();
+			const DEVICE = this._controllerQueue.shift();
+			REQUESTER.setDevice(DEVICE);
+		}
+	}
+
+	checkPointerQueues() {
+		if (this._pointerRequestQueue.length > 0 && this._pointerQueue.length > 0) {
+			const REQUESTER = this._pointerRequestQueue.shift();
+			const DEVICE = this._pointerQueue.shift();
+			REQUESTER.setDevice(DEVICE);
+		}
+	}
+
+	getController(id = 0) {
+		if (this._controllers.length < id + 1) {
+			const CONTROLLER = new Controller();
+			this._controllers.push(CONTROLLER);
+			this._controllerRequestQueue.push(CONTROLLER);
+			this.checkControllerQueues();
+		}
+
+		return this._controllers[id];
+	}
+
+	getPointer(id = 0) {
+		if (this._pointers.length < id + 1) {
+			const POINTER = new Pointer();
+			this._pointers.push(POINTER);
+			this._pointerRequestQueue.push(POINTER);
+			this.checkPointerQueues();
+		}
+
+		return this._pointers[id];
+	}
+
+	update() {
+		this.checkGamePads();
+
+		for (let i in this._controllers) {
+			this._controllers[i].update();
+		}
+
+		for (let j in this._pointers) {
+			this._pointers[j].update();
+		}
+	}
+}

package/src/Key.mjs

@@ -0,0 +1,22 @@
+"use strict";
+
+export const Key = {
+	BACK: 8,
+	ENTER: 13,
+	SHIFT: 16,
+	CTRL: 17,
+	ALT: 18,
+	SPACE: 32,
+	LEFT: 37,
+	UP: 38,
+	RIGHT: 39,
+	DOWN: 40,
+	D: 68,
+	E: 69,
+	F: 70,
+	I: 73,
+	J: 74,
+	K: 75,
+	L: 76,
+	S: 83
+};

package/src/KeyMap.mjs

@@ -0,0 +1,25 @@
+"use strict";
+
+import { Command } from "./Command.mjs";
+import { Key } from "./Key.mjs";
+
+export const KeyMap = {
+	[Key.UP]: Command.UP,
+	[Key.E]: Command.UP,
+	[Key.I]: Command.UP,
+	[Key.DOWN]: Command.DOWN,
+	[Key.D]: Command.DOWN,
+	[Key.K]: Command.DOWN,
+	[Key.LEFT]: Command.LEFT,
+	[Key.S]: Command.LEFT,
+	[Key.J]: Command.LEFT,
+	[Key.RIGHT]: Command.RIGHT,
+	[Key.F]: Command.RIGHT,
+	[Key.L]: Command.RIGHT,
+	[Key.SPACE]: Command.A,
+	[Key.ALT]: Command.B,
+	[Key.CTRL]: Command.X,
+	[Key.SHIFT]: Command.Y,
+	[Key.ENTER]: Command.START,
+	[Key.BACK]: Command.SELECT,
+};

package/src/Keyboard.mjs

@@ -0,0 +1,34 @@
+"use sttrict";
+
+import { KeyMap } from "./KeyMap.mjs";
+
+export class Keyboard {
+	constructor(event) {
+		this._buffer = {};
+
+		this.onKey(event, true);
+		addEventListener("keydown", event => this.onKey(event, true), false);
+		addEventListener("keyup", event => this.onKey(event, false), false);
+	}
+
+	get commands() {
+		const RESULT = {};
+
+		for (let i in this._buffer) {
+			if (this._buffer[i]) {
+				RESULT[i] = true;
+			}
+		}
+
+		return RESULT;
+	}
+
+	onKey(event, isDown) {
+		const COMMAND = KeyMap[event.keyCode];
+		this._buffer[COMMAND] = isDown;
+
+		if (isDown && "number" == typeof(COMMAND)) {
+			event.preventDefault();
+		}
+	}
+}

package/src/Mouse.mjs

@@ -0,0 +1,34 @@
+"use strict";
+
+import { Point } from "./Point.mjs";
+
+export class Mouse extends Point {
+	constructor(event) {
+		super();
+		this.updateCoordinates(event);
+
+		addEventListener("mousedown", (event) => {
+			event.preventDefault();
+			this._isDown = true;
+		}, false);
+
+		addEventListener("mousemove", (event) => {
+			this.updateCoordinates(event);
+		}, false);
+
+		addEventListener("mouseup", (event) => {
+			event.preventDefault();
+			this._isDown = false;
+		}, false);
+	}
+
+	get command() {
+		return this._isDown;
+	}
+
+	updateCoordinates(event) {
+		event.preventDefault();
+		this.x = event.x ?? event.clientX ?? 0;
+		this.y = event.y ?? event.clientY ?? 0;
+	}
+}

package/src/Point.mjs

@@ -0,0 +1,38 @@
+"use strict";
+
+export class Point {
+	constructor(x = 0, y = 0) {
+		this.x = x;
+		this.y = y;
+	}
+
+	get position() {
+		return this;
+	}
+
+	setX(x) {
+		this.x = x;
+		return this;
+	}
+
+	setY(y) {
+		this.y = y;
+		return this;
+	}
+
+	setPosition(point) {
+		this.x = point.x;
+		this.y = point.y;
+		return this;
+	}
+
+	set position(point) {
+		this.setPosition(point);
+	}
+
+	distance(point) {
+		const dx = point.x - this.x;
+		const dy = point.y - this.y;
+		return Math.sqrt(dx * dx + dy * dy);
+	}
+}

package/src/Pointer.mjs

@@ -0,0 +1,44 @@
+"use strict";
+
+import { Engine } from "./Engine.mjs";
+import { Point } from "./Point.mjs";
+
+export class Pointer extends Point {
+	constructor() {
+		super();
+		this._active = false;
+		this._device = null;
+		this._hold = false;
+	}
+
+	get down() {
+		return this._active;
+	}
+
+	get push() {
+		return this._active && !this._hold;
+	}
+
+	setDevice(device) {
+		this._device = device;
+	}
+
+	update() {
+		if (!this._device) {
+			return;
+		}
+
+		this._hold = false;
+		const LAST = this._active;
+		this._active = this._device.command;
+
+		if (this._active && LAST) {
+			this._hold = true;
+		}
+
+		const REAL_X = this._device.x - Engine.offsetLeft;
+		const REAL_Y = this._device.y - Engine.offsetTop;
+		this.x = Math.floor(REAL_X * Engine.width / Engine.realWidth);
+		this.y = Math.floor(REAL_Y * Engine.height / Engine.realHeight);
+	}
+}

package/src/Rect.mjs

@@ -0,0 +1,127 @@
+"use strict";
+
+import { Point } from "./Point.mjs";
+
+export class Rect extends Point {
+	constructor(x, y, width = 0, height = 0) {
+		super(x, y);
+		this.width = width;
+		this.height = height;
+	}
+
+	get left() {
+		return this.x;
+	}
+
+	get right() {
+		return this.x + this.width - 1;
+	}
+
+	get top() {
+		return this.y;
+	}
+
+	get bottom() {
+		return this.y + this.height - 1;
+	}
+
+	get centerX() {
+		return this.x + Math.floor(this.width / 2);
+	}
+
+	get centerY() {
+		return this.y + Math.floor(this.height / 2);
+	}
+
+	get center() {
+		return new Point(this.centerX, this.centerY);
+	}
+
+	setWidth(width) {
+		this.width = width;
+		return this;
+	}
+
+	setHeight(height) {
+		this.height = height;
+		return this;
+	}
+
+	setSize(rect) {
+		this.setWidth(rect.width);
+		this.setHeight(rect.height);
+		return this;
+	}
+
+	setLeft(x) {
+		this.x = x;
+		return this;
+	}
+
+	setRight(x) {
+		this.x = x - this.width + 1;
+		return this;
+	}
+
+	setTop(y) {
+		this.y = y;
+		return this;
+	}
+
+	setBottom(y) {
+		this.y = y - this.height + 1;
+		return this;
+	}
+
+	setCenterX(x) {
+		this.x = x - Math.floor(this.width / 2);
+		return this;
+	}
+
+	setCenterY(y) {
+		this.y = y - Math.floor(this.height / 2);
+		return this;
+	}
+
+	setCenter(point) {
+		this.setCenterX(point.x);
+		this.setCenterY(point.y);
+		return this;
+	}
+
+	set left(x) {
+		this.setLeft(x);
+	}
+
+	set right(x) {
+		this.setRight(x);
+	}
+
+	set top(y) {
+		this.setTop(y);
+	}
+
+	set bottom(y) {
+		this.setBottom(y);
+	}
+
+	set centerX(x) {
+		this.setCenterX(x);
+	}
+
+	set centerY(y) {
+		this.setCenterY(y);
+	}
+
+	set center(point) {
+		this.setCenter(point);
+	}
+
+	makeUnion(rect) {
+		const RECT = new Rect(Math.min(this.x, rect.x), Math.min(this.y, rect.y));
+
+		return RECT
+			.setWidth(Math.max(this.right, rect.right) - RECT.x + 1)
+			.setHeight(Math.max(this.bottom, rect.bottom) - RECT.y + 1);
+	}
+}

package/src/RenderableList.mjs

@@ -0,0 +1,19 @@
+"use strict";
+
+export class RenderableList {
+	constructor() {
+		this._elements = [];
+	}
+
+	add(renderable) {
+		this._elements.push(renderable);
+	}
+
+	render(context) {
+		for (let i = 0; i < this._elements.length; ++i) {
+			this._elements[i].render(context);
+		}
+
+		this._elements.length = 0;
+	}
+}

package/src/Scene.mjs

@@ -0,0 +1,108 @@
+"use strict";
+
+import { Engine } from "./Engine.mjs";
+import { Sprite } from "./Sprite.mjs";
+import { Static } from "./Static.mjs";
+
+export class Scene extends Sprite {
+	constructor() {
+		super();
+		this.height = Engine.height;
+		this.width = Engine.width;
+		this._sprites = [];
+		this._spritesQueue = [];
+	}
+
+	init() {
+		// no default behavior
+	}
+
+	add(sprite) {
+		this._spritesQueue.push(sprite);
+		sprite.scene = this;
+		sprite.init();
+		sprite.x -= sprite.speedX;
+		sprite.y -= sprite.speedY;
+		return this;
+	}
+
+	build(map, tileFactory = null, offsetX = 0, offsetY = 0, x = 0, y = 0) {
+		tileFactory = tileFactory ?? function baseTileFactory(id) {
+			return new Sprite().addTag("tile").setImage(id);
+		};
+
+		for (let i = 0; i < map.length; ++i) {
+			const LINE = map[i];
+
+			for (let j = 0; j < LINE.length; ++j) {
+				const ID = map[i][j];
+
+				if (!ID || "" == ID.trim()) {
+					continue;
+				}
+
+				const TILE = tileFactory(ID);
+
+				if (TILE) {
+					const X = offsetX || TILE.width;
+					const Y = offsetY || TILE.height;
+					TILE.x = x + j * X;
+					TILE.y = y + i * Y;
+					this.add(TILE);
+				}
+			}
+		}
+
+		return this;
+	}
+
+	sync() {
+		Engine.paint(this, this.layerIndex);
+		let sprites = [];
+		const solidSprites = [];
+
+		for (let i = 0; i < this._sprites.length; ++i) {
+			const sprite = this._sprites[i];
+
+			if (sprite.sync()) {
+				if (sprite.essential) {
+					this.setExpired();
+				}
+			} else {
+				if (sprite.solid) {
+					solidSprites.push(sprite);
+				}
+
+				sprites.push(sprite);
+				Engine.paint(sprite, sprite.layerIndex);
+			}
+
+			sprite.collided = false;
+		}
+
+		Static.checkCollisions(solidSprites);
+		this._sprites = sprites.concat(this._spritesQueue);
+		this._spritesQueue = [];
+		return Sprite.prototype.sync.call(this);
+	}
+
+	getObjectsWithTag(tag) {
+		const RESULT = [];
+		const SPRITES = this._sprites.concat(this._spritesQueue);
+
+		for (let i = 0; i < SPRITES.length; ++i) {
+			const SPRITE = SPRITES[i];
+
+			if (SPRITE.hasTag(tag)) {
+				RESULT.push(SPRITE);
+			}
+		}
+
+		return RESULT;
+	}
+
+	setTransition(transition) {
+		this.transition = transition;
+		return this;
+	}
+}

package/src/Sound.mjs

@@ -0,0 +1,138 @@
+"use strict";
+
+import { Static } from "./Static.mjs";
+
+const DEFAULT_PLAY_VOLUME = 0.3;
+
+export class Sound {
+	constructor() {
+		this._isFading = false;
+		this._isMute = false;
+		this._nextThemeName = null;
+		this._queue = {};
+		this._theme = null;
+		this._themeId = null;
+		this._volume = 100;
+	}
+
+	fadeOut() {
+		if (!this._theme) {
+			return;
+		}
+
+		this._isFading = true;
+		this._volume = 100;
+	}
+
+	mute() {
+		this._isMute = !this._isMute;
+
+		if (!this._isMute) {
+			this._theme.play();
+		} else {
+			this._theme.pause();
+		}
+	}
+
+	pause() {
+		if (this._theme) {
+			this._theme.pause();
+		}
+	}
+
+	play(id, volume = DEFAULT_PLAY_VOLUME) {
+		if (this._isMute) {
+			return;
+		}
+
+		this._queue[id] = volume;
+	}
+
+	playTheme(id) {
+		if (id == this._themeId) {
+			return;
+		}
+
+		if (this._theme && this._theme.currentTime > 0) {
+			this._nextThemeName = id;
+
+			if (!this._isFading) {
+				this.fadeOut();
+			}
+
+			return;
+		}
+
+		this.stopTheme();
+		this._theme = Static.getElement(id);
+		this._themeId = id;
+
+		if (this._theme.currentTime > 0) {
+			this._theme.currentTime = 0;
+		}
+
+		if (this._isMute) {
+			return;
+		}
+
+		this._theme.volume = 1;
+		this._theme.play();
+	}
+
+	resume() {
+		if (this._isMute) {
+			return;
+		}
+
+		if (this._theme.paused) {
+			this._theme.play();
+		}
+	}
+
+	stopTheme() {
+		this._isFading = false;
+
+		if (this._theme) {
+			this._theme.pause();
+			this._theme.currentTime = 0;
+			this._themeId = null;
+		}
+	}
+
+	update() {
+		for (let id in this._queue) {
+			const SOUND = Static.getElement(id);
+
+			if (!SOUND?.pause) {
+				console.warn(`Could not find audio with id: ${id}`);
+			}
+
+			SOUND.pause();
+
+			if (SOUND.currentTime > 0) {
+				SOUND.currentTime = 0;
+			}
+
+			SOUND.volume = this._queue[id];
+			SOUND.play();
+		}
+
+		this._queue = {};
+
+		if (this._isFading) {
+			if (--this._volume > 0) {
+				this._theme.volume = this._volume / 100;
+			} else {
+				this.stopTheme();
+				this._isFading = false;
+				this._theme = null;
+
+				if (this._nextThemeName) {
+					this.playTheme(this._nextThemeName);
+					this._themeId = this._nextThemeName;
+					this._nextThemeName = null;
+				}
+			}
+		}
+	}
+}