Source: packages/ecs-js/component.js

  1. const ComponentRefs = require('./componentrefs');
  2. const UUID = require('uuid/v1');
  3. const CoreProperties = new Set([
  4.   'ecs', 'entity', 'type', '_values', '_ready', 'id',
  5.   'updated', 'constructor', 'stringify', 'clone', 'getObject'
  6. ]);
  8. /**ECS base class of component
  9.  * @class BaseComponent
  10.  */
  11. class BaseComponent {
  13.   constructor(ecs, entity, initialValues) {
  15.     Object.defineProperty(this, 'ecs', { enumerable: false, value: ecs });
  16.     Object.defineProperty(this, 'entity', { enumerable: true, value: entity });
  17.     Object.defineProperty(this, 'type', { enumerable: false, value: this.constructor.name });
  18.     Object.defineProperty(this, '_values', { enumerable: false, value: {} });
  19.     Object.defineProperty(this, '_refs', { enumerable: false, value: {} });
  20.     Object.defineProperty(this, '_ready', { writable: true, enumerable: false, value: false });
  21.     Object.defineProperty(this, 'id', { enumerable: true, value: initialValues.id || UUID() });
  22.     Object.defineProperty(this, 'updated', { enumerable: false, writable: true, value: this.ecs.ticks });
  24.     //loop through inheritance by way of prototypes
  25.     //avoiding constructor->super() boilerplate for every component
  26.     //also avoiding proxies just for a simple setter on properties
  27.     const definitions = [];
  28.     for (var c = this.constructor; c !== null; c = Object.getPrototypeOf(c)) {
  29.       if (!c.definition) continue;
  30.       definitions.push(c.definition);
  31.     }
  32.     //we want to inherit deep prototype defintions first
  33.     definitions.reverse();
  35.     for (let idx = 0, l = definitions.length; idx < l; idx++) {
  37.       const definition = definitions[idx];
  38.       // set component properties from Component.properties
  39.       if (!definition.properties) {
  40.         continue;
  41.       }
  42.       const properties = definition.properties;
  43.       const keys = Object.keys(properties);
  44.       for (let idx = 0, l = keys.length; idx < l; idx++) {
  45.         const property = keys[idx];
  46.         if (CoreProperties.has(property)) {
  47.           throw new Error(`Cannot override property in Component definition: ${property}`);
  48.         }
  49.         const value = properties[property];
  50.         if (this._values.hasOwnProperty(property)) {
  51.           this[property] = value;
  52.           continue;
  53.         }
  54.         switch (value) {
  55.           case '<EntitySet>':
  56.             Object.defineProperty(this, property, {
  57.               //writable: true,
  58.               enumerable: true,
  59.               set: (value) => {
  60.                 Reflect.set(this._values, property, ComponentRefs.EntitySet(value, this, property));
  61.               },
  62.               get: () => {
  63.                 return Reflect.get(this._values, property);
  64.               }
  65.             });
  66.             //this._refs[property] = this[property];
  67.             this[property] = [];
  68.             break;
  69.           case '<EntityObject>':
  70.             Object.defineProperty(this, property, {
  71.               writable: false,
  72.               enumerable: true,
  73.               value: ComponentRefs.EntityObject({}, this, property)
  74.             });
  75.             this._refs[property] = this[property];
  76.             break;
  77.           case '<Entity>':
  78.             Object.defineProperty(this, property, {
  79.               enumerable: true,
  80.               writeable: true,
  81.               set: (value) => {
  83.                 if (value && value.id) {
  84.                   value = value.id;
  85.                 }
  86.                 const old = Reflect.get(this._values, property);
  87.                 if (old && old !== value) {
  88.                   this.ecs.deleteRef(old, this.entity.id, this.id, property);
  89.                 }
  90.                 if (value && value !== old) {
  91.                   this.ecs.addRef(value, this.entity.id, this.id, property);
  92.                 }
  93.                 const result = Reflect.set(this._values, property, value);
  94.                 this.ecs._sendChange(this, 'setEntity', property, old, value);
  95.                 return result;
  96.               },
  97.               get: () => {
  99.                 return this.ecs.getEntity(this._values[property]);
  100.               }
  101.             });
  102.             this._values[property] = null;
  103.             break;
  104.           case '<ComponentObject>':
  105.             Object.defineProperty(this, property, {
  106.               writable: false,
  107.               enumerable: true,
  108.               value: ComponentRefs.ComponentObject({}, this)
  109.             });
  110.             this._refs[property] = this[property];
  111.             break;
  112.           case '<ComponentSet>':
  113.             Object.defineProperty(this, property, {
  114.               //writable: true,
  115.               enumerable: true,
  116.               set: (value) => {
  117.                 Reflect.set(this._values, property, ComponentRefs.ComponentSet(value, this, property));
  118.               },
  119.               get: () => {
  120.                 return Reflect.get(this._values, property);
  121.               }
  122.             });
  123.             //this._refs[property] = this[property];
  124.             this[property] = [];
  125.             break;
  126.           case '<Component>':
  127.             Object.defineProperty(this, property, {
  128.               enumerable: true,
  129.               writeable: true,
  130.               set: (value) => {
  132.                 if (typeof value === 'object') {
  133.                   value = value.id;
  134.                 }
  135.                 const old = Reflect.get(this._values, property);
  136.                 const result = Reflect.set(this._values, property, value);
  137.                 this.ecs._sendChange(this, 'setComponent', property, old, value);
  138.                 return result;
  139.               },
  140.               get: () => {
  142.                 return this.entity.componentMap[this._values[property]];
  143.               }
  144.             });
  145.             this._values[property] = null;
  146.             break;
  147.           default:
  148.             let reflect = null;
  149.             if (typeof value === 'string' && value.startsWith('<Pointer ')) {
  150.               reflect = value.substring(9, value.length - 1).trim().split('.')
  151.             }
  152.             Object.defineProperty(this, property, {
  153.               enumerable: true,
  154.               writeable: true,
  155.               set: (value) => {
  157.                 const old = Reflect.get(this._values, property, value);
  158.                 const result = Reflect.set(this._values, property, value);
  159.                 if (reflect) {
  160.                   let node = this;
  161.                   let fail = false;
  162.                   for (let i = 0; i < reflect.length - 1; i++) {
  163.                     const subprop = reflect[i];
  164.                     /* $lab:coverage:off$ */
  165.                     if (typeof node === 'object' && node !== null && node.hasOwnProperty(subprop)) {
  166.                     /* $lab:coverage:on */
  167.                       node = node[subprop];
  168.                     } else {
  169.                       fail = true;
  170.                     }
  171.                   }
  172.                   if (!fail) {
  173.                     Reflect.set(node, reflect[reflect.length - 1], value);
  174.                     node = value;
  175.                   }
  176.                 }
  177.                 this.ecs._sendChange(this, 'set', property, old, value);
  178.                 return result;
  179.               },
  180.               get: () => {
  181.                 if (!reflect) {
  182.                   return Reflect.get(this._values, property);
  183.                 }
  184.                 let node = this;
  185.                 let fail = false;
  186.                 for (let i = 0; i < reflect.length - 1; i++) {
  187.                   const subprop = reflect[i];
  188.                   /* $lab:coverage:off$ */
  189.                   if (typeof node === 'object' && node !== null && node.hasOwnProperty(subprop)) {
  190.                   /* $lab:coverage:on */
  191.                     node = node[subprop];
  192.                   } else {
  193.                     fail = true;
  194.                   }
  195.                 }
  196.                 if (!fail) {
  197.                   return Reflect.get(node, reflect[reflect.length - 1]);
  198.                 } else {
  199.                   return Reflect.get(this._values, property);
  200.                 }
  201.               }
  202.             });
  203.             this._values[property] = value;
  204.             break;
  205.         }
  206.       }
  207.     }
  209.     // don't allow new properties
  210.     Object.seal(this);
  211.     Object.seal(this._values);
  212.     const values = { ...initialValues };
  213.     delete values.type;
  214.     delete values.entity;
  215.     delete values.id;
  216.     Object.assign(this, values);
  217.     this.ecs._sendChange(this, 'addComponent');
  218.     this._ready = true;
  219.   }
  222.   stringify() {
  224.     return JSON.stringify(this.getObject());
  225.   }
  227.   getObject() {
  229.     const serialize  = this.constructor.definition.serialize;
  230.     let values = this._values;
  231.     if (serialize) {
  232.       /* $lab:coverage:off$ */
  233.       if (serialize.skip) return undefined;
  234.       /* $lab:coverage:on$ */
  235.       if (serialize.ignore.length > 0) {
  236.         values = {}
  237.         const props = new Set([...serialize.ignore]);
  238.         for (const prop of Object.keys(this._values).filter(prop => !props.has(prop))) {
  239.           values[prop] = this._values[prop];
  240.         }
  241.       }
  242.     }
  243.     return Object.assign({ id: this.id, type: this.type }, values, this._refs);
  244.   }
  246. }
  248. BaseComponent.definition = {
  249.   properties: {
  250.   },
  251.   multiset: false,
  252.   serialize: {
  253.     skip: false,
  254.     ignore: [],
  255.   }
  256. };
  258. module.exports = BaseComponent;