385 lines
12 KiB
JavaScript
385 lines
12 KiB
JavaScript
import RetroSprite from "./RetroSprite.js";
|
|
import RetroArchitectureTile from "./RetroArchitectureTile.js";
|
|
import GeometryRectCollection from "../geometry/GeometryRectCollection.js";
|
|
import GeometryPoint from "../geometry/GeometryPoint.js";
|
|
import GeometryRect from "../geometry/GeometryRect.js";
|
|
import GraphicSet from "../GraphicSet.js";
|
|
import Setting from "../Setting.js";
|
|
import Camera from "../Camera.js";
|
|
import Level from "../Level.js";
|
|
|
|
export default class RetroArchitecture
|
|
{
|
|
/**
|
|
* @param {{sprite: RetroSprite, tiles: number}} retroTileset
|
|
* @param {number} columns
|
|
* @param {number} rows
|
|
* @param {{sprite: RetroSprite, tiles: number}} retroTilesetBackground
|
|
*/
|
|
constructor(retroTileset, columns, rows, retroTilesetBackground = null)
|
|
{
|
|
/** @type {RetroSprite} */
|
|
this.tilesetSprite = retroTileset.sprite;
|
|
|
|
/** @type {RetroSprite|null} */
|
|
this.tilesetSpriteBackground = retroTilesetBackground !== null
|
|
? retroTilesetBackground.sprite
|
|
: null;
|
|
|
|
/** @type {number} */
|
|
this.tiles = retroTileset.tiles;
|
|
|
|
/** @type {number} */
|
|
this.tilesBackground = retroTilesetBackground !== null
|
|
? retroTilesetBackground.tiles
|
|
: 0;
|
|
|
|
/** @type {string|null} */
|
|
this.backgroundColor = null;
|
|
|
|
/** @type {string|null} */
|
|
this.backgroundImage = null;
|
|
|
|
/** @type {number} */
|
|
this.rows = rows;
|
|
|
|
/** @type {number} */
|
|
this.columns = columns;
|
|
|
|
/** @type {Array<Array<RetroArchitectureTile>>} */
|
|
this.matrix = [];
|
|
|
|
/** @type {number} */
|
|
this.tileWidth = this.tilesetSprite.getWidth() / this.tiles;
|
|
|
|
/** @type {number} */
|
|
this.tileHeight = this.tilesetSprite.getHeight();
|
|
|
|
/** @type {number} */
|
|
this.startX = 0;
|
|
|
|
/** @type {number} */
|
|
this.startY = 0;
|
|
|
|
/** @type {number} */
|
|
this.targetX = 0;
|
|
|
|
/** @type {number} */
|
|
this.targetY = 0;
|
|
|
|
/** @type {GeometryPoint} */
|
|
this.targetPosition = new GeometryPoint(this.targetX, this.targetY);
|
|
|
|
this.init();
|
|
}
|
|
|
|
init()
|
|
{
|
|
for (let y = 0; y < this.rows; y++) {
|
|
let row = [];
|
|
|
|
for (let x = 0; x < this.columns; x++) {
|
|
row.push(null);
|
|
}
|
|
|
|
this.matrix.push(row);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @param {string|null} color
|
|
*/
|
|
setBackgroundColor(color)
|
|
{
|
|
this.backgroundColor = color;
|
|
}
|
|
|
|
/**
|
|
* @param {string|null} image
|
|
*/
|
|
setBackgroundImage(image)
|
|
{
|
|
this.backgroundImage = image;
|
|
}
|
|
|
|
/**
|
|
* @param {GeometryRect} rect
|
|
* @returns {GeometryRectCollection}
|
|
*/
|
|
getCollisionRects(rect)
|
|
{
|
|
let posX = Math.floor(rect.position.x / this.tileWidth) - 2;
|
|
let posY = Math.floor(rect.position.y / this.tileHeight) - 2;
|
|
let rangeX = parseInt( posX + rect.width / this.tileWidth) + 4;
|
|
let rangeY = parseInt(posY + rect.height / this.tileHeight) + 4;
|
|
|
|
let collection = new GeometryRectCollection();
|
|
|
|
for (let y = Math.max(0, posY); y < rangeY; y++) {
|
|
for (let x = Math.max(0, posX); x < rangeX; x++) {
|
|
if (
|
|
y < this.matrix.length &&
|
|
x < this.matrix[y].length &&
|
|
this.matrix[y][x] !== null && this.matrix[y][x].tile.index > -1
|
|
) {
|
|
let intersection = this.matrix[y][x].rect.getRectIntersection(rect);
|
|
|
|
if (intersection !== null) {
|
|
collection.addRect(intersection);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return collection;
|
|
}
|
|
|
|
hasRectCollision(rect)
|
|
{
|
|
let posX = Math.floor(rect.position.x / this.tileWidth) - 2;
|
|
let posY = Math.floor(rect.position.y / this.tileHeight) - 2;
|
|
let rangeX = parseInt( posX + rect.width / this.tileWidth) + 4;
|
|
let rangeY = parseInt(posY + rect.height / this.tileHeight) + 4;
|
|
|
|
for (let y = Math.max(0, posY); y < rangeY; y++) {
|
|
for (let x = Math.max(0, posX); x < rangeX; x++) {
|
|
if (this.matrix[y][x] !== null && this.matrix[y][x].tile.index > -1) {
|
|
if (this.matrix[y][x].rect.getRectIntersection(rect) !== null) {
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
getTileForPosition(position, offsetX = 0, offsetY = 0)
|
|
{
|
|
let x = parseInt(position.x / this.tileWidth) + offsetX;
|
|
let y = parseInt(position.y / this.tileHeight) + offsetY;
|
|
|
|
if (x < 0 || x >= this.columns || y < 0 || y >= this.rows) {
|
|
return null;
|
|
}
|
|
|
|
return new GeometryPoint(x, y);
|
|
}
|
|
|
|
getCeilingHeight(position)
|
|
{
|
|
let tilePosition = this.getTileForPosition(position, 0);
|
|
|
|
while (tilePosition !== null && tilePosition.y > 0) {
|
|
if (
|
|
this.matrix[tilePosition.y][tilePosition.x] !== null &&
|
|
this.matrix[tilePosition.y][tilePosition.x].tile.index > -1
|
|
) {
|
|
return tilePosition.y * this.tileHeight + this.tileHeight;
|
|
}
|
|
|
|
tilePosition.y--;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
getGroundHeight(position)
|
|
{
|
|
let tilePosition = this.getTileForPosition(position);
|
|
|
|
while (tilePosition !== null && tilePosition.y < this.rows) {
|
|
if (
|
|
this.matrix[tilePosition.y][tilePosition.x] !== null &&
|
|
this.matrix[tilePosition.y][tilePosition.x].tile.index > -1
|
|
) {
|
|
return tilePosition.y * this.tileHeight;
|
|
}
|
|
|
|
tilePosition.y++;
|
|
}
|
|
|
|
return (this.rows + 10) * this.tileHeight;
|
|
}
|
|
|
|
getWallRight(position)
|
|
{
|
|
let tilePosition = this.getTileForPosition(new GeometryPoint(position.x, position.y), 1, 0);
|
|
|
|
while (tilePosition !== null && tilePosition.x < this.columns) {
|
|
if (
|
|
this.matrix[tilePosition.y][tilePosition.x] !== null &&
|
|
this.matrix[tilePosition.y][tilePosition.x].tile.index > -1
|
|
) {
|
|
return tilePosition.x * this.tileWidth;
|
|
}
|
|
|
|
tilePosition.x++;
|
|
}
|
|
|
|
return this.tileWidth * this.columns;
|
|
}
|
|
|
|
getWallLeft(position)
|
|
{
|
|
let tilePosition = this.getTileForPosition(new GeometryPoint(position.x, position.y), -1,0);
|
|
|
|
while (tilePosition !== null && tilePosition.x > 0) {
|
|
if (
|
|
this.matrix[tilePosition.y][tilePosition.x] !== null &&
|
|
this.matrix[tilePosition.y][tilePosition.x].tile.index > -1
|
|
) {
|
|
return tilePosition.x * this.tileWidth + this.tileWidth;
|
|
}
|
|
|
|
tilePosition.x--;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
isInsideArchitecture(geometryPoint)
|
|
{
|
|
let architectureRect = new GeometryRect(
|
|
0, 0, this.tileWidth * this.columns, this.tileHeight * this.rows
|
|
);
|
|
|
|
return architectureRect.isContainingPoint(geometryPoint);
|
|
}
|
|
|
|
setMovableToStartPosition(movable)
|
|
{
|
|
movable.position.x = this.tileWidth * this.startX + this.tileWidth * 0.5;
|
|
movable.position.y = this.tileHeight * this.startY + this.tileHeight * 0.5;
|
|
}
|
|
|
|
setMovableToTargetPosition(movable)
|
|
{
|
|
movable.position.x = this.tileWidth * this.targetX + this.tileWidth * 0.5;
|
|
movable.position.y = this.tileHeight * this.targetY + this.tileHeight;
|
|
}
|
|
|
|
isMovableInsideTargetPosition(movable)
|
|
{
|
|
let tileRect = new GeometryRect(
|
|
this.targetX * this.tileWidth,
|
|
this.targetY * this.tileHeight,
|
|
this.tileWidth,
|
|
this.tileHeight
|
|
);
|
|
|
|
return tileRect.isContainingPoint(movable.getPositionHeadLeft()) ||
|
|
tileRect.isContainingPoint(movable.getPositionHeadRight()) ||
|
|
tileRect.isContainingPoint(movable.getPositionFootLeft()) ||
|
|
tileRect.isContainingPoint(movable.getPositionFootRight());
|
|
}
|
|
|
|
draw(context, camera = new Camera())
|
|
{
|
|
const viewX = parseInt(Math.floor(Math.max(0, camera.position.x) / this.tileWidth));
|
|
const viewWidth = parseInt(Math.min(Math.ceil(camera.width), this.columns));
|
|
const viewY = parseInt(Math.floor(Math.max(0, camera.position.y)) / this.tileHeight);
|
|
const viewHeight = parseInt(Math.min(Math.ceil(camera.height), this.rows));
|
|
|
|
for (let y = viewY; y < viewHeight; y++) {
|
|
for (let x = viewX; x < viewWidth; x++) {
|
|
let field = this.matrix[y][x];
|
|
|
|
if (field === null || field.tile.index === -1) {
|
|
continue;
|
|
}
|
|
|
|
if (field.tile.index > -1) {
|
|
this.drawField(context, x, y, camera, field);
|
|
} else {
|
|
this.drawBackgroundField(context, x, y, camera, field);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
drawField(context, x, y, camera, field)
|
|
{
|
|
context.drawImage(
|
|
this.tilesetSprite.canvas,
|
|
(field.tile.index % this.tiles) * this.tileWidth,
|
|
0,
|
|
this.tileWidth,
|
|
this.tileHeight,
|
|
Math.round(x * this.tileWidth - camera.position.x),
|
|
Math.round(y * this.tileHeight - camera.position.y),
|
|
this.tileWidth,
|
|
this.tileHeight,
|
|
);
|
|
}
|
|
|
|
drawBackgroundField(context, x, y, camera, field)
|
|
{
|
|
context.drawImage(
|
|
this.tilesetSpriteBackground.canvas,
|
|
-(field.tile.index % 2) * this.tileWidth,
|
|
0,
|
|
this.tileWidth,
|
|
this.tileHeight,
|
|
Math.round(x * this.tileWidth - camera.position.x),
|
|
Math.round(y * this.tileHeight - camera.position.y),
|
|
this.tileWidth,
|
|
this.tileHeight,
|
|
);
|
|
}
|
|
|
|
getStartPosition()
|
|
{
|
|
return new GeometryPoint(this.startX * this.tileWidth, this.startY * this.tileHeight);
|
|
}
|
|
|
|
/**
|
|
* @param {Level} level
|
|
*/
|
|
static createFromData(level)
|
|
{
|
|
let graphicSet = GraphicSet[level.getTilesetId()];
|
|
|
|
const tilesetSprite = new RetroSprite(
|
|
Setting.TILESET_LOCATION + graphicSet.tileset,
|
|
graphicSet.scale
|
|
);
|
|
|
|
const tilesetBackground = level.terrain.tileset.background !== null
|
|
? new RetroSprite(level.terrain.tileset.background.image.src)
|
|
: null;
|
|
|
|
const architecture = new RetroArchitecture(
|
|
{sprite: tilesetSprite, tiles: graphicSet.tiles},
|
|
level.getColumns(),
|
|
level.getRows(),
|
|
tilesetBackground === null ? null : {sprite: tilesetBackground, tiles: level.terrain.tileset.background.tiles}
|
|
);
|
|
|
|
architecture.setBackgroundColor(graphicSet.backgroundColor);
|
|
architecture.setBackgroundImage(graphicSet.backgroundImage);
|
|
|
|
architecture.startX = level.getStartX();
|
|
architecture.startY = level.getStartY();
|
|
architecture.targetX = level.getTargetX();
|
|
architecture.targetY = level.getTargetY();
|
|
architecture.targetPosition = new GeometryPoint(level.getTargetX(), level.getTargetY());
|
|
|
|
for (let y = 0; y < level.getRows(); y++) {
|
|
for (let x = 0; x < level.getColumns(); x++) {
|
|
if (level.getTilesetMatrix()[y][x].index !== -1) {
|
|
architecture.matrix[y][x] = new RetroArchitectureTile(
|
|
level.getTilesetMatrix()[y][x],
|
|
x * architecture.tileWidth,
|
|
y * architecture.tileHeight,
|
|
architecture.tileWidth,
|
|
architecture.tileHeight
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
return architecture;
|
|
}
|
|
}
|