core2d 2.10.2

package/src/Sprite.mjs

@@ -0,0 +1,368 @@
+"use strict";
+
+import { Animation } from "./Animation.mjs";
+import { Direction } from "./Direction.mjs";
+import { Frame } from "./Frame.mjs";
+import { Rect } from "./Rect.mjs";
+import { Static } from "./Static.mjs";
+
+export class Sprite extends Rect {
+	constructor() {
+		super();
+		this.accelerationX = 0;
+		this.accelerationY = 0;
+		this.alpha = 1;
+		this.boundary = null;
+		this.color = null;
+		this.essential = false;
+		this.expiration = 0;
+		this.expired = false;
+		this.layerIndex = 0;
+		this.maxSpeedX = 0;
+		this.maxSpeedY = 0;
+		this.solid = false;
+		this.speedX = 0;
+		this.speedY = 0;
+		this.visible = true;
+		this._animation = null;
+		this._lastSpeedX = 0;
+		this._lastSpeedY = 0;
+		this._lastX = this.x;
+		this._lastY = this.y;
+		this._tags = {};
+		this._tick = 0;
+	}
+
+	get angle() {
+		return Static.toDegrees(Math.atan2(this.speedY, this.speedX));
+	}
+
+	get direction() {
+		const DIRECTION = new Direction();
+
+		if (this.x < this._lastX) {
+			DIRECTION.setLeft();
+		} else if (this.x > this._lastX) {
+			DIRECTION.setRight();
+		}
+
+		if (this.y < this._lastY) {
+			DIRECTION.setTop();
+		} else if (this.y > this._lastY) {
+			DIRECTION.setBottom();
+		}
+
+		return DIRECTION;
+	}
+
+	get image() {
+		return this._animation && this._animation.image;
+	}
+
+	get tick() {
+		return this._tick;
+	}
+
+	setAccelerationX(accelerationX = 0) {
+		this.accelerationX = accelerationX;
+		return this;
+	}
+
+	setAccelerationY(accelerationY = 0) {
+		this.accelerationY = accelerationY;
+		return this;
+	}
+
+	setAlpha(alpha = 1) {
+		this.alpha = alpha;
+		return this;
+	}
+
+	setBoundary(rect = null) {
+		this.boundary = rect || this.scene;
+		return this;
+	}
+
+	setColor(color) {
+		this.color = color;
+		return this;
+	}
+
+	setEssential(isEssential = true) {
+		this.essential = isEssential;
+		return this;
+	}
+
+	setExpiration(expiration = 0) {
+		this.expiration = expiration;
+		return this;
+	}
+
+	setExpired(isExpired = true) {
+		this.expired = isExpired;
+		return this;
+	}
+
+	setLayerIndex(layerIndex = 0) {
+		this.layerIndex = layerIndex;
+		return this;
+	}
+
+	setMaxSpeedX(maxSpeedX = 0) {
+		this.maxSpeedX = maxSpeedX;
+		return this;
+	}
+
+	setMaxSpeedY(maxSpeedY = 0) {
+		this.maxSpeedY = maxSpeedY;
+		return this;
+	}
+
+	setSolid(isSolid = true) {
+		this.solid = isSolid;
+		return this;
+	}
+
+	setSpeedX(speedX = 0) {
+		this.speedX = speedX;
+		return this;
+	}
+
+	setSpeedY(speedY = 0) {
+		this.speedY = speedY;
+		return this;
+	}
+
+	setVisible(isVisible = true) {
+		this.visible = isVisible;
+		return this;
+	}
+
+	setAnimation(animation) {
+		if (animation == this._animation) {
+			return this;
+		}
+
+		this._animation = animation;
+		this._animation.setFrameIndex(0);
+		this.height = this._animation.height;
+		this.width = this._animation.width;
+		return this;
+	}
+
+	setImage(image) {
+		this.setAnimation(new Animation([new Frame(image)]));
+		return this;
+	}
+
+	set image(image) {
+		this.setImage(image);
+	}
+
+	setSpeedToAngle(speed, degrees) {
+		const RADIANS = Static.toRadians(degrees);
+		this.setSpeedX(speed * Math.cos(RADIANS));
+		this.setSpeedY(speed * Math.sin(RADIANS));
+		return this;
+	}
+
+	setSpeedToPoint(speed, point) {
+		const SQUARE_DISTANCE = Math.abs(this.centerX - point.x) + Math.abs(this.centerY - point.y);
+		this.setSpeedX((point.x - this.centerX) * speed / SQUARE_DISTANCE);
+		this.setSpeedY((point.y - this.centerY) * speed / SQUARE_DISTANCE);
+		return this;
+	}
+
+	addTag(tag) {
+		this._tags[tag] = true;
+		return this;
+	}
+
+	bounceFrom(direction) {
+		if ((this.speedX < 0 && direction.left) || (this.speedX > 0 && direction.right)) {
+			this.bounceX();
+		}
+
+		if ((this.speedY < 0 && direction.top) || (this.speedY > 0 && direction.bottom)) {
+			this.bounceY();
+		}
+
+		return this;
+	}
+
+	bounceX() {
+		this.setSpeedX(this.speedX * -1);
+		this.x += this.speedX;
+		return this;
+	}
+
+	bounceY() {
+		this.setSpeedY(this.speedY * -1);
+		this.y += this.speedY;
+		return this;
+	}
+
+	expire() {
+		this.expired = true;
+	}
+
+	getCollision(sprite) {
+		const DIRECTION = new Direction();
+		const TA = this.top;
+		const RA = this.right;
+		const BA = this.bottom;
+		const LA = this.left;
+		const XA = this.centerX;
+		const YA = this.centerY;
+		const TB = sprite.top;
+		const RB = sprite.right;
+		const BB = sprite.bottom;
+		const LB = sprite.left;
+
+		if (XA <= LB && RA < RB) {
+			DIRECTION.setRight();
+		} else if (XA >= RB && LA > LB) {
+			DIRECTION.setLeft();
+		}
+
+		if (YA <= TB && BA < BB) {
+			DIRECTION.setBottom();
+		} else if (YA >= BB && TA > TB) {
+			DIRECTION.setTop();
+		}
+
+		return DIRECTION;
+	}
+
+	hasCollision(rect) {
+		return !(
+			this.left > rect.right ||
+	this.right < rect.left ||
+	this.top > rect.bottom ||
+	this.bottom < rect.top
+		);
+	}
+
+	hasTag(tag) {
+		return this._tags[tag];
+	}
+
+	init() {
+		// no default behavior
+	}
+
+	offBoundary() {
+		this.setExpired();
+	}
+
+	onAnimationLoop() {
+		// no default behavior
+	}
+
+	onCollision(sprite) {
+		// no default behavior
+		return sprite;
+	}
+
+	pause() {
+		this._lastSpeedX = this.speedX;
+		this._lastSpeedY = this.speedY;
+		this.speedX = 0;
+		this.speedY = 0;
+		return this;
+	}
+
+	render(context) {
+		if (!this.visible) {
+			return false;
+		}
+
+		const X = Math.floor(this.x + this.scene.x);
+		const Y = Math.floor(this.y + this.scene.y);
+
+		if (this.alpha < 1) {
+			context.globalAlpha = this.alpha;
+		}
+
+		if (this.color) {
+			context.fillStyle = this.color;
+			context.fillRect(X, Y, this.width, this.height);
+		}
+
+		if (this._animation) {
+			context.drawImage(this._animation.image, X, Y, this.width, this.height);
+		}
+
+		if (this.alpha < 1) {
+			context.globalAlpha = 1;
+		}
+
+		return true;
+	}
+
+	resume() {
+		this.speedX = this._lastSpeedX;
+		this.speedY = this._lastSpeedY;
+		return this;
+	}
+
+	stop() {
+		this._lastSpeedX = 0;
+		this._lastSpeedY = 0;
+		this.speedX = 0;
+		this.speedY = 0;
+	}
+
+	sync() {
+		this._lastX = this.x;
+		this._lastY = this.y;
+		this.update();
+
+		if (++this._tick == this.expiration) {
+			this.setExpired();
+		}
+
+		if (this.expired) {
+			return true;
+		}
+
+		if (this._animation && this._animation.sync()) {
+			this.onAnimationLoop();
+		}
+
+		this.x += this.speedX;
+		this.y += this.speedY;
+		this.speedX += this.accelerationX;
+		this.speedY += this.accelerationY;
+
+		if (this.maxSpeedX && Math.abs(this.speedX) > this.maxSpeedX) {
+			const SIGNAL = this.speedX / Math.abs(this.speedX);
+			this.speedX = this.maxSpeedX * SIGNAL;
+		}
+
+		if (this.maxSpeedY && Math.abs(this.speedY) > this.maxSpeedY) {
+			const SIGNAL = this.speedY / Math.abs(this.speedY);
+			this.speedY = this.maxSpeedY * SIGNAL;
+		}
+
+		if (this.boundary && !this.hasCollision(this.boundary)) {
+			this.offBoundary();
+		}
+
+		return false;
+	}
+
+	update() {
+		// no default behavior
+	}
+
+	zoom(ratio) {
+		const widthChange = this.width * ratio;
+		this.width += widthChange;
+		this.x -= widthChange / 2;
+		const heightChange = this.height * ratio;
+		this.height += heightChange;
+		this.y -= heightChange / 2;
+		return this;
+	}
+}

package/src/Static.mjs

@@ -0,0 +1,77 @@
+"use strict";
+
+import { ACL } from "./ACL.mjs";
+
+export class Static {
+	static checkCollisions(sprites) {
+		const LENGTH = sprites.length;
+
+		for (let i = 0; i < LENGTH - 1; ++i) {
+			const LEFT_SPRITE = sprites[i];
+
+			for (let j = i + 1; j < LENGTH; ++j) {
+				const RIGHT_SPRITE = sprites[j];
+
+				if (LEFT_SPRITE.hasCollision(RIGHT_SPRITE)) {
+					LEFT_SPRITE.collided = true;
+					LEFT_SPRITE.onCollision(RIGHT_SPRITE);
+					RIGHT_SPRITE.collided = true;
+					RIGHT_SPRITE.onCollision(LEFT_SPRITE);
+				}
+			}
+		}
+	}
+
+	static getElement(id) {
+		const element = ACL.document.getElementById(id);
+
+		if (!element) {
+			console.warn(`Could not find element with id: ${id}`);
+		}
+
+		return element;
+	}
+
+	static getElements(name) {
+		return Array.from(ACL.document.getElementsByTagName(name));
+	}
+
+	static getGamepads() {
+		if (!navigator.getGamepads) {
+			return [];
+		}
+
+		return navigator.getGamepads();
+	}
+
+	static getImage(image) {
+		if ("string" == typeof(image)) {
+			return this.getElement(image);
+		}
+
+		return image;
+	}
+
+	static makeEnum(array) {
+		return this.makeHash(array, true);
+	}
+
+	static makeHash(array, indexed) {
+		const RESULT = {};
+
+		for (let i = 0; i < array.length; ++i) {
+			const VALUE = array[i];
+			RESULT[VALUE] = indexed ? i : VALUE;
+		}
+
+		return RESULT;
+	}
+
+	static toDegrees(radians) {
+		return radians * 180 / Math.PI;
+	}
+
+	static toRadians(degrees) {
+		return degrees * Math.PI / 180;
+	}
+}

package/src/TextSprite.mjs

@@ -0,0 +1,144 @@
+"use strict";
+
+import { ACL } from "./ACL.mjs";
+import { Color } from "./Color.mjs";
+import { FontFamily } from "./FontFamily.mjs";
+import { Sprite } from "./Sprite.mjs";
+
+const hiddenCanvas = ACL.document.createElement("canvas");
+const hiddenContext = hiddenCanvas.getContext("2d");
+
+export class TextSprite extends Sprite {
+	constructor(text = "") {
+		super();
+		this._text = text;
+		this._fontFamily = FontFamily.Monospace;
+		this._fontSize = 16;
+		this.fontColor = Color.White;
+		this.lineWidth = 0;
+		this.shadowBlur = 0;
+		this.shadowColor = null;
+		this.shadowOffsetX = 0;
+		this.shadowOffsetY = 0;
+		this.strokeStyle = null;
+		this._updateFont();
+	}
+
+	render(context) {
+		if (Sprite.prototype.render.call(this, context)) {
+			context.fillStyle = this.fontColor;
+			context.font = this._font;
+			context.textBaseline = "top";
+
+			if (this.shadowColor) {
+				context.shadowColor = this.shadowColor;
+				context.shadowOffsetX = this.shadowOffsetX;
+				context.shadowOffsetY = this.shadowOffsetY;
+				context.shadowBlur = this.shadowBlur;
+			}
+
+			context.fillText(this._text, this.left + this.scene.x, this.bottom + this.scene.y, this.width);
+
+			if (this.shadowColor) {
+				context.shadowColor = null;
+				context.shadowOffsetX = 0;
+				context.shadowOffsetY = 0;
+				context.shadowBlur = 0;
+			}
+
+			if (this.strokeStyle) {
+				context.lineWidth = this.lineWidth;
+				context.strokeStyle = this.strokeStyle;
+				context.strokeText(this._text, this.left + this.scene.x, this.bottom + this.scene.y, this.width);
+				context.lineWidth = 0;
+				context.strokeStyle = null;
+			}
+		}
+	}
+
+	setFontColor(fontColor) {
+		this.fontColor = fontColor;
+		return this;
+	}
+
+	setFontFamily(fontFamily) {
+		this._fontFamily = fontFamily;
+		this._updateFont();
+		return this;
+	}
+
+	setFontSize(fontSize) {
+		this._fontSize = fontSize;
+		this.height = fontSize;
+		this._updateFont();
+		return this;
+	}
+
+	setLineWidth(lineWidth) {
+		this.lineWidth = lineWidth;
+		return this;
+	}
+
+	setShadowBlur(shadowBlur) {
+		this.shadowBlur = shadowBlur;
+		return this;
+	}
+
+	setShadowColor(shadowColor) {
+		this.shadowColor = shadowColor;
+		return this;
+	}
+
+	setShadowOffsetX(shadowOffsetX) {
+		this.shadowOffsetX = shadowOffsetX;
+		return this;
+	}
+
+	setShadowOffsetY(shadowOffsetY) {
+		this.shadowOffsetY = shadowOffsetY;
+		return this;
+	}
+
+	setStrokeStyle(strokeStyle) {
+		this.strokeStyle = strokeStyle;
+		return this;
+	}
+
+	setText(text) {
+		this._text = text;
+		this._updateFont();
+		return this;
+	}
+
+	get fontFamily() {
+		return this._fontFamily;
+	}
+
+	get fontSize() {
+		return this._fontSize;
+	}
+
+	get text() {
+		return this._text;
+	}
+
+	set fontFamily(fontFamily) {
+		this.setFontFamily(fontFamily);
+	}
+
+	set fontSize(fontSize) {
+		this.setFontSize(fontSize);
+	}
+
+	set text(text) {
+		this.setText(text);
+	}
+
+	_updateFont() {
+		this._font = `${this._fontSize}px ${this._fontFamily}`;
+		hiddenContext.textBaseline = "top";
+		hiddenContext.font = this._font;
+		const measurement = hiddenContext.measureText(this._text);
+		this.width = measurement.width;
+	}
+}

package/src/Touch.mjs

@@ -0,0 +1,40 @@
+"use strict";
+
+import { Point } from "./Point.mjs";
+
+export class Touch extends Point {
+	constructor(event) {
+		super();
+		event.preventDefault();
+		this._isDown = true;
+		this.updateCoordinates(event);
+
+		addEventListener("touchend", (event) => {
+			event.preventDefault();
+			this._isDown = false;
+			this.updateCoordinates(event);
+		}, false);
+
+		addEventListener("touchmove", (event) => {
+			event.preventDefault();
+			this.updateCoordinates(event);
+		}, false);
+
+		addEventListener("touchstart", () => {
+			event.preventDefault();
+			this._isDown = true;
+			this.updateCoordinates(event);
+		}, false);
+	}
+
+	get command() {
+		return this._isDown;
+	}
+
+	updateCoordinates(event) {
+		const TOUCHES = event.changedTouches;
+		const TOUCH = TOUCHES[0];
+		this.x = TOUCH.pageX;
+		this.y = TOUCH.pageY;
+	}
+}

package/src/Transition.mjs

@@ -0,0 +1,21 @@
+"use strict";
+
+import { Color } from "./Color.mjs";
+import { Sprite } from "./Sprite.mjs";
+
+export class Transition extends Sprite {
+	init() {
+		this.setColor(Color.Black);
+		this.setHeight(this.scene.height);
+		this._increase = this.scene.width / 32;
+	}
+
+	sync() {
+		if (this.width > this.scene.width) {
+			return true;
+		}
+
+		this.width += this._increase;
+		return Sprite.prototype.sync.call(this);
+	}
+}

package/src/plugin/BaseTile.mjs

@@ -0,0 +1,10 @@
+"use strict";
+
+import { Sprite } from "../Sprite.mjs";
+
+export 	class BaseTile extends Sprite {
+	constructor(id) {
+		super();
+		this.setImage(id);
+	}
+}

package/src/plugin/ClickableSprite.mjs

@@ -0,0 +1,24 @@
+"use static";
+
+import { Sprite } from "../Sprite.mjs";
+
+export 	class ClickableSprite extends Sprite {
+	constructor() {
+		super();
+		this.addTag("clickable");
+		this.setSolid();
+	}
+
+	onClick() {
+		// no default behavior
+	}
+
+	onHoverIn() {
+		// no default behavior
+	}
+
+	onHoverOut() {
+		// no default behavior
+	}
+}
+

package/src/plugin/ControllableSprite.mjs

@@ -0,0 +1,38 @@
+"use strict";
+
+import { Command } from "../Command.mjs";
+import { Core2D } from "../Core2D.mjs";
+import { Sprite } from "../Sprite.mjs";
+
+export 	class ControllableSprite extends Sprite {
+	constructor() {
+		super();
+		this.controller = Core2D.getController();
+		this.step = 2;
+	}
+
+	setStep(step) {
+		this.step = step;
+		return this;
+	}
+
+	sync() {
+		if (this.controller.keyDown(Command.LEFT) && this.left > 0) {
+			this.x -= this.step;
+		}
+
+		if (this.controller.keyDown(Command.RIGHT) && this.right < this.scene.width) {
+			this.x += this.step;
+		}
+
+		if (this.controller.keyDown(Command.UP) && this.top > 0) {
+			this.y -= this.step;
+		}
+
+		if (this.controller.keyDown(Command.DOWN) && this.bottom < this.scene.height) {
+			this.y += this.step;
+		}
+
+		return Sprite.prototype.sync.call(this);
+	}
+}