118 lines
3.1 KiB
JavaScript
118 lines
3.1 KiB
JavaScript
import Component from '@/ecs/component.js';
|
|
|
|
import vector2d from './helpers/vector-2d';
|
|
|
|
class LayerProxy {
|
|
constructor(instance, Component, index) {
|
|
this.instance = instance;
|
|
this.Component = Component;
|
|
this.index = index;
|
|
}
|
|
get area() {
|
|
return this.layer.area;
|
|
}
|
|
get data() {
|
|
return this.layer.data;
|
|
}
|
|
get layer() {
|
|
return this.instance.layers[this.index];
|
|
}
|
|
get source() {
|
|
return this.layer.source;
|
|
}
|
|
stamp(at, data) {
|
|
const changes = {};
|
|
for (const row in data) {
|
|
const columns = data[row];
|
|
for (const column in columns) {
|
|
const tile = columns[column];
|
|
const x = at.x + parseInt(column);
|
|
const y = at.y + parseInt(row);
|
|
if (x < 0 || y < 0 || x >= this.layer.area.x || y >= this.layer.area.y) {
|
|
continue;
|
|
}
|
|
const calculated = y * this.layer.area.x + x;
|
|
this.layer.data[calculated] = tile;
|
|
changes[calculated] = tile;
|
|
}
|
|
}
|
|
this.Component.markChange(this.instance.entity, 'layerChange', {[this.index]: changes});
|
|
}
|
|
tile({x, y}) {
|
|
if (x < 0 || y < 0 || x >= this.layer.area.x || y >= this.layer.area.y) {
|
|
return undefined;
|
|
}
|
|
return this.layer.data[y * this.layer.area.x + x];
|
|
}
|
|
get tileSize() {
|
|
return this.layer.tileSize;
|
|
}
|
|
}
|
|
|
|
export default class TileLayers extends Component {
|
|
insertMany(entities) {
|
|
for (const [id, {layerChange}] of entities) {
|
|
if (layerChange) {
|
|
const component = this.get(id);
|
|
const {layers} = component;
|
|
for (const layerIndex in layerChange) {
|
|
for (const calculated in layerChange[layerIndex]) {
|
|
const tile = layerChange[layerIndex][calculated];
|
|
layers[layerIndex].data[calculated] = tile;
|
|
}
|
|
layers[layerIndex] = {...layers[layerIndex]};
|
|
component.$$layersProxies[layerIndex] = new LayerProxy(component, this, layerIndex);
|
|
}
|
|
}
|
|
}
|
|
return super.insertMany(entities);
|
|
}
|
|
load(instance) {
|
|
for (const index in instance.layers) {
|
|
instance.$$layersProxies[index] = new LayerProxy(instance, this, index);
|
|
}
|
|
}
|
|
mergeDiff(original, update) {
|
|
if (!update.layerChange) {
|
|
return super.mergeDiff(original, update);
|
|
}
|
|
const layerChange = {
|
|
...original.layerChange,
|
|
};
|
|
for (const index in update.layerChange) {
|
|
layerChange[index] = {
|
|
...layerChange[index],
|
|
...update.layerChange[index],
|
|
};
|
|
}
|
|
return {layerChange};
|
|
}
|
|
instanceFromSchema() {
|
|
return class TileLayersInstance extends super.instanceFromSchema() {
|
|
$$layersProxies = {};
|
|
layer(index) {
|
|
return this.$$layersProxies[index];
|
|
}
|
|
}
|
|
}
|
|
static properties = {
|
|
layers: {
|
|
type: 'array',
|
|
subtype: {
|
|
type: 'object',
|
|
properties: {
|
|
area: vector2d('float32'),
|
|
data: {
|
|
type: 'array',
|
|
subtype: {
|
|
type: 'uint16',
|
|
},
|
|
},
|
|
source: {type: 'string'},
|
|
tileSize: vector2d('float32'),
|
|
},
|
|
},
|
|
},
|
|
};
|
|
}
|