avocado-old/packages/entity/index.js

import * as I from 'immutable';
import D from 'debug';
import without from 'lodash.without';

import {compose, EventEmitter, fastApply} from '@avocado/core';
import {Resource} from '@avocado/resource';
import {Synchronized} from '@avocado/state';

import {hasTrait, lookupTrait} from './trait/registry';

const debug = D('@avocado:entity:traits');

const blacklistedAccessorKeys = [
  'state',
];

// This really seems like a whole lot of complicated nonsense, but it's an
// unfortunate consequence of V8 (and maybe others) not optimizing mutable
// accessors in fast hidden classes.
const traitAccessorForPropertyMap = {};
function traitAccessorForProperty(type, property) {
  if (!(type in traitAccessorForPropertyMap)) {
    traitAccessorForPropertyMap[type] = {};
  }
  if (!(property in traitAccessorForPropertyMap[type])) {
    traitAccessorForPropertyMap[type][property] = {
      get: function() {
        return this._traits[type][property];
      },
      set: function(value) {
        this._traits[type][property] = value;
      }
    };
  }
  return traitAccessorForPropertyMap[type][property];
}
function defineTraitAccessors(from, to, instance) {
  const type = instance.constructor.type();
  do {
    Object.getOwnPropertyNames(from).forEach((accessorKey) => {
      if (-1 !== blacklistedAccessorKeys.indexOf(accessorKey)) {
        return;
      }
      let descriptor = Object.getOwnPropertyDescriptor(from, accessorKey);
      // Make sure it's actually an accessor.
      if (!descriptor.get && !descriptor.set) {
        return;
      }
      const accessor = traitAccessorForProperty(type, accessorKey);
      if (descriptor.get) {
        descriptor.get = accessor.get;
      }
      if (descriptor.set) {
        descriptor.set = accessor.set;
      }
      Object.defineProperty(to, accessorKey, descriptor);
    });
  } while (Object.prototype !== (from = Object.getPrototypeOf(from)));
}
function enumerateTraitAccessorKeys(prototype) {
  const keys = [];
  do {
    Object.getOwnPropertyNames(prototype).forEach((accessorKey) => {
      if (-1 !== blacklistedAccessorKeys.indexOf(accessorKey)) {
        return;
      }
      let descriptor = Object.getOwnPropertyDescriptor(prototype, accessorKey);
      // Make sure it's actually an accessor.
      if (!descriptor.get && !descriptor.set) {
        return;
      }
      keys.push(accessorKey);
    });
  } while (Object.prototype !== (prototype = Object.getPrototypeOf(prototype)));
  return keys;
}

const decorate = compose(
  EventEmitter,
  Synchronized,
);

export class Entity extends decorate(Resource) {

  constructor(json) {
    super();
    this._hooks = {};
    this.isDirty = true;
    this._traits = {};
    this._traitsFlat = [];
    this._traitTickers = [];
    this._traitRenderTickers = [];
    this._traitsAcceptingPackets = [];
    this.once('destroyed', () => {
      this.removeAllTraits();
    });
    this.initializeSynchronizedChildren();
    if ('undefined' !== typeof json) {
      this.fromJSON(json);
    }
    // Bind to prevent lookup overhead.
    this.tick = this.tick.bind(this);
  }

  acceptPacket(packet) {
    for (let i = 0; i < this._traitsAcceptingPackets.length; i++) {
      const instance = this._traitsAcceptingPackets[i];
      instance.acceptPacket(packet);
    }
  }

  addTrait(type, json = {}) {
    if (this.is(type)) {
      debug(`Tried to add trait "${type}" when it already exists!`);
      return;
    }
    if (!hasTrait(type)) {
      debug(`Tried to add trait "${type}" which isn't registered!`);
      return;
    }
    const Trait = lookupTrait(type);
    // Ensure dependencies.
    const dependencies = Trait.dependencies();
    const allTypes = this.allTraitTypes();
    const lacking = without(dependencies, ...allTypes);
    if (lacking.length > 0) {
      debug(
        `Tried to add trait "${type}" but lack one or more dependents: "${
          lacking.join('", "')
        }"!`
      );
      return;
    }
    // Instantiate.
    const {params, state} = json;
    const instance = new Trait(this, params, state);
    // Proxy properties.
    defineTraitAccessors(Trait.prototype, this, instance);
    // Attach listeners.
    const listeners = instance.memoizedListeners();
    for (const eventName in listeners) {
      this.on(eventName, listeners[eventName]);
    }
    // Proxy methods.
    const methods = instance.methods();
    for (const key in methods) {
      this[key] = methods[key];
    }
    // Register hook listeners.
    const hooks = instance.hooks();
    for (const key in hooks) {
      this._hooks[key] = this._hooks[key] || [];
      this._hooks[key].push({
        fn: hooks[key],
        type: Trait.type(),
      });
    }
    // Add state.
    this.state = this._setInstanceState(this.state, type, instance);
    // Track trait.
    this._traits[type] = instance;
    this._traitsFlat.push(instance);
    if ('tick' in instance) {
      this._traitTickers.push(instance.tick);
    }
    if ('renderTick' in instance) {
      this._traitRenderTickers.push(instance.renderTick);
    }
    if ('acceptPacket' in instance) {
      this._traitsAcceptingPackets.push(instance);
    }
    this.emit('traitAdded', type, instance);
  }

  addTraits(traits) {
    for (const type in traits) {
      this.addTrait(type, traits[type]);
    }
  }

  allTraitInstances() {
    return this._traits;
  }

  allTraitTypes() {
    return Object.keys(this._traits);
  }

  fromJSON(json) {
    super.fromJSON(json);
    this.addTraits(json.traits);
    return this;
  }

  hydrate() {
    const promises = [];
    for (let i = 0; i < this._traitsFlat.length; i++) {
      const instance = this._traitsFlat[i];
      promises.push(instance.hydrate());
    }
    return Promise.all(promises);
  }

  invokeHook(hook, ...args) {
    const results = {};
    if (!(hook in this._hooks)) {
      return results;
    }
    for (const {fn, type} of this._hooks[hook]) {
      results[type] = fastApply(null, fn, args);
    }
    return results;
  }

  invokeHookFlat(hook, ...args) {
    const invokeResults = this.invokeHook(hook, ...args);
    const results = [];
    for (const type in invokeResults) {
      results.push(invokeResults[type]);
    }
    return results;
  }

  is(type) {
    return type in this._traits;
  }

  patchStateStep(type, step) {
    let instance = this._traits[type];
    // New trait requested?
    if (!this._traits[type]) {
      // Doesn't exist?
      if (!hasTrait(type)) {
        return;
      }
      if ('params' in step.value) {
        step.value.params = step.value.params.toJS();
      }
      this.addTrait(type, step.value);
      instance = this._traits[type];
    }
    else {
      // Accept state.
      instance.patchState([step]);
    }
    this.state = this._setInstanceState(this.state, type, instance);
  }

  renderTick(elapsed) {
    for (let i = 0; i < this._traitRenderTickers.length; i++) {
      this._traitRenderTickers[i](elapsed);
    }
  }

  removeAllTraits() {
    const types = this.allTraitTypes();
    this.removeTraits(types);
  }

  removeTrait(type) {
    if (!this.is(type)) {
      debug(`Tried to remove trait "${type}" when it doesn't exist!`);
      return;
    }
    // Destroy instance.
    const instance = this._traits[type];
    instance.destroy();
    // Remove methods, hooks, and properties.
    const methods = instance.methods();
    for (const key in methods) {
      delete this[key];
    }
    const hooks = instance.hooks();
    for (const key in hooks) {
      const implementation = this._hooks[key].find(({type: hookType}) => {
        return hookType === type;
      });
      this._hooks[key].splice(this._hooks[key].indexOf(implementation), 1);
    }
    const Trait = lookupTrait(type);
    const properties = enumerateTraitAccessorKeys(Trait.prototype);
    for (let i = 0; i < properties.length; ++i) {
      const property = properties[i];
      delete this[property];
    }
    // Remove all event listeners.
    const listeners = instance.memoizedListeners();
    for (const eventName in listeners) {
      this.off(eventName, listeners[eventName]);
    }
    instance._memoizedListeners = {};
    // Remove state.
    this.state = this.state.delete(type);
    // Remove instance.
    delete this._traits[type];
    this._traitsFlat.splice(this._traitsFlat.indexOf(instance), 1);
    if ('tick' in instance) {
      this._traitTickers.splice(
        this._traitTickers.indexOf(instance.tick),
        1
      );
    }
    if ('renderTick' in instance) {
      this._traitRenderTickers.splice(
        this._traitRenderTickers.indexOf(instance.renderTick),
        1
      );
    }
    const acceptPacketIndex = this._traitsAcceptingPackets.indexOf(instance);
    if (-1 !== acceptPacketIndex) {
      this._traitsAcceptingPackets.splice(acceptPacketIndex, 1);
    }
    // Unloop.
    instance.entity = undefined;
  }

  removeTraits(types) {
    types.forEach((type) => this.removeTrait(type));
  }

  _setInstanceState(state, type, instance) {
    return state.setIn(
      [type, 'state'], instance.state
    ).setIn(
      [type, 'params'], instance.params
    );
  }

  tick(elapsed) {
    for (let i = 0; i < this._traitTickers.length; i++) {
      this._traitTickers[i](elapsed);
    }
    if (AVOCADO_SERVER) {
      this.tickMutateState();
    }
  }

  tickMutateState() {
    this.state = this.state.withMutations((state) => {
      for (let i = 0; i < this._traitsFlat.length; i++) {
        const instance = this._traitsFlat[i];
        if (!instance.isDirty) {
          continue;
        }
        instance.isDirty = false;
        if (this.is('listed')) {
          this.list && this.list.markEntityDirty(this);
        }
        this._setInstanceState(state, instance.constructor.type(), instance);
      }
    });
  }

  toJSON() {
    const json = {};
    for (const type in this._traits) {
      json[type] = this._traits[type].toJSON();
    }
    return {
      ...super.toJSON(),
      traits: json,
    };
  }

}

export {EntityPacket} from './entity.packet';

export {EntityList, EntityListView} from './list';

export {EntityPacketSynchronizer} from './packet-synchronizer';

export {
  hasTrait,
  lookupTrait,
  registerTrait,
} from './trait/registry';

export {StateProperty, Trait} from './trait';