silphius/app/ecs-components/tile-layers.js

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'),
        },
      },
    },
  };
}