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

324 lines
9.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";
import GraphicSet from "../GraphicSet.js";
import Setting from "../Setting.js";
import Camera from "../Camera.js";
export default class RetroArchitecture
{
constructor(tilesetSprite, tiles, columns, rows)
{
this.tilesetSprite = tilesetSprite;
this.tiles = tiles;
this.backgroundColor = null;
this.backgroundImage = null;
this.rows = rows;
this.columns = columns;
this.matrix = [];
this.tileWidth = this.tilesetSprite.getWidth() / this.tiles;
this.tileHeight = this.tilesetSprite.getHeight();
this.terrainCanvas = document.createElement('canvas');
this.terrainCanvas.width = this.tileWidth * this.columns;
this.terrainCanvas.height = this.tileHeight * this.rows;
this.terrainContext = this.terrainCanvas.getContext('2d');
this.startX = 0;
this.startY = 0;
this.targetX = 0;
this.targetY = 0;
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);
}
}
render()
{
const camera = new Camera();
for (let y = 0; y < this.rows; y++) {
for (let x = 0; x < this.columns; x++) {
const field = this.matrix[y][x];
if (field === null) {
continue;
}
this.drawField(this.terrainContext, x, y, camera, field);
}
}
}
setBackgroundColor(color)
{
this.backgroundColor = color;
}
setBackgroundImage(image)
{
this.backgroundImage = image;
}
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 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) {
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 (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) {
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());
}
drawForFirefox(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++) {
const field = this.matrix[y][x];
if (field !== null) {
this.drawField(context, x, y, camera, field);
}
}
}
}
/**
*
* @param context
* @param camera Camera
*/
drawForChrome(context, camera)
{
context.drawImage(
this.terrainCanvas,
camera.position.x,
camera.position.y,
camera.width,
camera.height,
0,
0,
camera.width,
camera.height
);
}
drawField(context, x, y, camera, field)
{
context.drawImage(
this.tilesetSprite.canvas,
field.tile.index * this.tileWidth,
0,
this.tileWidth,
this.tileHeight,
x * this.tileWidth - camera.position.x,
y * this.tileHeight - camera.position.y,
this.tileWidth + 1,
this.tileHeight + 1
);
}
static createFromData(level)
{
let graphicSet = GraphicSet[level.getTilesetId()];
let tileset = new RetroSprite(
Setting.TILESET_LOCATION + graphicSet.tileset,
graphicSet.scale
);
let architecture = new RetroArchitecture(
tileset,
graphicSet.tiles,
level.getColumns(),
level.getRows()
);
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
);
}
}
}
architecture.render();
return architecture;
}
}