mr-crocs-adventures/js/retro/RetroArchitecture.js

250 lines
7.8 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";
export default class RetroArchitecture
{
constructor(tilesetSprite, tiles, columns, rows)
{
this.tileset = tilesetSprite;
this.tiles = tiles;
this.rows = rows;
this.columns = columns;
this.matrix = [];
this.tileWidth = this.tileset.getWidth() / this.tiles;
this.tileHeight = this.tileset.getHeight();
this.startX = 0;
this.startY = 0;
this.targetX = 0;
this.targetY = 0;
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);
}
}
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) {
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) {
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 {x: x, y: y};
}
getCeilingHeight(position)
{
let tilePosition = this.getTileForPosition(position, 0);
while (tilePosition !== null && tilePosition.y > 0) {
if (this.matrix[tilePosition.y][tilePosition.x] !== null) {
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) {
return tilePosition.y * this.tileHeight;
}
tilePosition.y++;
}
return 9999999999;
}
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) {
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) {
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 = null)
{
let viewX = parseInt(Math.floor(Math.max(0, camera.position.x) / this.tileWidth));
let viewWidth = parseInt(Math.min(Math.ceil(camera.width), this.columns));
let viewY = parseInt(Math.floor(Math.max(0, camera.position.y)) / this.tileHeight);
let 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 !== undefined) {
context.drawImage(
this.tileset.canvas,
field.tile * this.tileWidth,
0,
this.tileWidth,
this.tileHeight,
x * this.tileWidth - camera.position.x,
y * this.tileHeight - camera.position.y,
this.tileWidth,
this.tileHeight
);
}
}
}
}
static createFromData(data)
{
let tileset = new RetroSprite(data.tileset, data.scale);
let architecture = new RetroArchitecture(
tileset,
data.tiles,
data.columns,
data.rows
);
architecture.startX = data.startX;
architecture.startY = data.startY;
architecture.targetX = data.targetX;
architecture.targetY = data.targetY;
for (let y = 0; y < data.rows; y++) {
for (let x = 0; x < data.columns; x++) {
if (data.matrix[y][x] > -1) {
architecture.matrix[y][x] = new RetroArchitectureTile(
data.matrix[y][x],
x * architecture.tileWidth,
y * architecture.tileHeight,
architecture.tileWidth,
architecture.tileHeight
)
}
}
}
return architecture;
}
}