401 lines
10 KiB
JavaScript
401 lines
10 KiB
JavaScript
import EntityFactory from './entity-factory.js';
|
|
import Schema from './schema.js';
|
|
|
|
import {Encoder, Decoder} from '@msgpack/msgpack';
|
|
|
|
const decoder = new Decoder();
|
|
const encoder = new Encoder();
|
|
|
|
export default class Ecs {
|
|
|
|
$$caret = 1;
|
|
|
|
Components = {};
|
|
|
|
diff = {};
|
|
|
|
Systems = {};
|
|
|
|
$$entities = {};
|
|
|
|
$$entityFactory = new EntityFactory();
|
|
|
|
constructor({Systems, Components} = {}) {
|
|
for (const componentName in Components) {
|
|
this.Components[componentName] = new Components[componentName](this);
|
|
}
|
|
for (const systemName in Systems) {
|
|
this.Systems[systemName] = new Systems[systemName](this);
|
|
}
|
|
}
|
|
|
|
apply(patch) {
|
|
const creating = [];
|
|
const destroying = [];
|
|
const removing = [];
|
|
const updating = [];
|
|
for (const entityIdString in patch) {
|
|
const entityId = parseInt(entityIdString);
|
|
const components = patch[entityId];
|
|
if (false === components) {
|
|
destroying.push(entityId);
|
|
continue;
|
|
}
|
|
const componentsToRemove = [];
|
|
const componentsToUpdate = {};
|
|
for (const componentName in components) {
|
|
if (false === components[componentName]) {
|
|
componentsToRemove.push(componentName);
|
|
}
|
|
else {
|
|
componentsToUpdate[componentName] = components[componentName];
|
|
}
|
|
}
|
|
if (componentsToRemove.length > 0) {
|
|
removing.push([entityId, componentsToRemove]);
|
|
}
|
|
if (this.$$entities[entityId]) {
|
|
updating.push([entityId, componentsToUpdate]);
|
|
}
|
|
else {
|
|
creating.push([entityId, componentsToUpdate]);
|
|
}
|
|
}
|
|
this.destroyMany(destroying);
|
|
this.insertMany(updating);
|
|
this.removeMany(removing);
|
|
this.createManySpecific(creating);
|
|
}
|
|
|
|
changed(criteria) {
|
|
const it = Object.entries(this.diff).values();
|
|
return {
|
|
[Symbol.iterator]() {
|
|
return this;
|
|
},
|
|
next: () => {
|
|
let result = it.next();
|
|
while (!result.done) {
|
|
for (const componentName of criteria) {
|
|
if (!(componentName in result.value[1])) {
|
|
result = it.next();
|
|
continue;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
if (result.done) {
|
|
return {done: true, value: undefined};
|
|
}
|
|
return {done: false, value: this.get(result.value[0])};
|
|
},
|
|
};
|
|
}
|
|
|
|
create(components = {}) {
|
|
const [entityId] = this.createMany([components]);
|
|
return entityId;
|
|
}
|
|
|
|
createMany(componentsList) {
|
|
const specificsList = [];
|
|
for (const components of componentsList) {
|
|
specificsList.push([this.$$caret++, components]);
|
|
}
|
|
return this.createManySpecific(specificsList);
|
|
}
|
|
|
|
createManySpecific(specificsList) {
|
|
const entityIds = [];
|
|
const creating = {};
|
|
for (let i = 0; i < specificsList.length; i++) {
|
|
const [entityId, components] = specificsList[i];
|
|
const componentNames = [];
|
|
for (const componentName in components) {
|
|
if (this.Components[componentName]) {
|
|
componentNames.push(componentName);
|
|
}
|
|
}
|
|
entityIds.push(entityId);
|
|
this.rebuild(entityId, () => componentNames);
|
|
for (const componentName of componentNames) {
|
|
if (!creating[componentName]) {
|
|
creating[componentName] = [];
|
|
}
|
|
creating[componentName].push([entityId, components[componentName]]);
|
|
}
|
|
this.markChange(entityId, components);
|
|
}
|
|
for (const i in creating) {
|
|
this.Components[i].createMany(creating[i]);
|
|
}
|
|
this.reindex(entityIds);
|
|
return entityIds;
|
|
}
|
|
|
|
createSpecific(entityId, components) {
|
|
return this.createManySpecific([[entityId, components]]);
|
|
}
|
|
|
|
deindex(entityIds) {
|
|
for (const systemName in this.Systems) {
|
|
this.Systems[systemName].deindex(entityIds);
|
|
}
|
|
}
|
|
|
|
static deserialize(ecs, view) {
|
|
const componentNames = Object.keys(ecs.Components);
|
|
const {entities, systems} = decoder.decode(view.buffer);
|
|
for (const system of systems) {
|
|
const System = ecs.system(system);
|
|
if (System) {
|
|
System.active = true;
|
|
}
|
|
}
|
|
const specifics = [];
|
|
let max = 1;
|
|
for (const id in entities) {
|
|
max = Math.max(max, parseInt(id));
|
|
specifics.push([
|
|
parseInt(id),
|
|
Object.fromEntries(
|
|
Object.entries(entities[id])
|
|
.filter(([componentName]) => componentNames.includes(componentName)),
|
|
),
|
|
]);
|
|
}
|
|
ecs.$$caret = max + 1;
|
|
ecs.createManySpecific(specifics);
|
|
return ecs;
|
|
}
|
|
|
|
destroy(entityId) {
|
|
this.destroyMany([entityId]);
|
|
}
|
|
|
|
destroyAll() {
|
|
this.destroyMany(this.entities);
|
|
}
|
|
|
|
destroyMany(entityIds) {
|
|
const destroying = {};
|
|
this.deindex(entityIds);
|
|
for (const entityId of entityIds) {
|
|
if (!this.$$entities[entityId]) {
|
|
throw new Error(`can't destroy non-existent entity ${entityId}`);
|
|
}
|
|
for (const componentName of this.$$entities[entityId].constructor.componentNames) {
|
|
if (!destroying[componentName]) {
|
|
destroying[componentName] = [];
|
|
}
|
|
destroying[componentName].push(entityId);
|
|
}
|
|
this.$$entities[entityId] = undefined;
|
|
this.diff[entityId] = false;
|
|
}
|
|
for (const i in destroying) {
|
|
this.Components[i].destroyMany(destroying[i]);
|
|
}
|
|
}
|
|
|
|
get entities() {
|
|
const it = Object.values(this.$$entities).values();
|
|
return {
|
|
[Symbol.iterator]() {
|
|
return this;
|
|
},
|
|
next: () => {
|
|
let result = it.next();
|
|
while (!result.done && !result.value) {
|
|
result = it.next();
|
|
}
|
|
if (result.done) {
|
|
return {done: true, value: undefined};
|
|
}
|
|
return {done: false, value: result.value.id};
|
|
},
|
|
};
|
|
}
|
|
|
|
get(entityId) {
|
|
return this.$$entities[entityId];
|
|
}
|
|
|
|
insert(entityId, components) {
|
|
this.insertMany([[entityId, components]]);
|
|
}
|
|
|
|
insertMany(entities) {
|
|
const inserting = {};
|
|
const unique = new Set();
|
|
for (const [entityId, components] of entities) {
|
|
this.rebuild(entityId, (componentNames) => [...new Set(componentNames.concat(Object.keys(components)))]);
|
|
const diff = {};
|
|
for (const componentName in components) {
|
|
if (!inserting[componentName]) {
|
|
inserting[componentName] = [];
|
|
}
|
|
diff[componentName] = {};
|
|
inserting[componentName].push([entityId, components[componentName]]);
|
|
}
|
|
unique.add(entityId);
|
|
this.markChange(entityId, diff);
|
|
}
|
|
for (const componentName in inserting) {
|
|
this.Components[componentName].insertMany(inserting[componentName]);
|
|
}
|
|
this.reindex(unique.values());
|
|
}
|
|
|
|
markChange(entityId, components) {
|
|
// Deleted?
|
|
if (false === components) {
|
|
this.diff[entityId] = false;
|
|
}
|
|
// Created?
|
|
else if (!this.diff[entityId]) {
|
|
const filtered = {};
|
|
for (const componentName in components) {
|
|
filtered[componentName] = false === components[componentName]
|
|
? false
|
|
: components[componentName];
|
|
}
|
|
this.diff[entityId] = filtered;
|
|
}
|
|
// Otherwise, merge.
|
|
else {
|
|
for (const componentName in components) {
|
|
this.diff[entityId][componentName] = false === components[componentName]
|
|
? false
|
|
: this.Components[componentName].mergeDiff(
|
|
this.diff[entityId][componentName] || {},
|
|
components[componentName],
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
rebuild(entityId, componentNames) {
|
|
let existing = [];
|
|
if (this.$$entities[entityId]) {
|
|
existing.push(...this.$$entities[entityId].constructor.componentNames);
|
|
}
|
|
const Class = this.$$entityFactory.makeClass(componentNames(existing), this.Components);
|
|
this.$$entities[entityId] = new Class(entityId);
|
|
}
|
|
|
|
reindex(entityIds) {
|
|
for (const systemName in this.Systems) {
|
|
this.Systems[systemName].reindex(entityIds);
|
|
}
|
|
}
|
|
|
|
remove(entityId, components) {
|
|
this.removeMany([[entityId, components]]);
|
|
}
|
|
|
|
removeMany(entities) {
|
|
const removing = {};
|
|
const unique = new Set();
|
|
for (const [entityId, components] of entities) {
|
|
unique.add(entityId);
|
|
const diff = {};
|
|
for (const componentName of components) {
|
|
diff[componentName] = false;
|
|
if (!removing[componentName]) {
|
|
removing[componentName] = [];
|
|
}
|
|
removing[componentName].push(entityId);
|
|
}
|
|
this.markChange(entityId, diff);
|
|
this.rebuild(entityId, (componentNames) => componentNames.filter((type) => !components.includes(type)));
|
|
}
|
|
for (const componentName in removing) {
|
|
this.Components[componentName].destroyMany(removing[componentName]);
|
|
}
|
|
this.reindex(unique.values());
|
|
}
|
|
|
|
static serialize(ecs, view) {
|
|
const buffer = encoder.encode(ecs.toJSON());
|
|
if (!view) {
|
|
view = new DataView(new ArrayBuffer(buffer.length));
|
|
}
|
|
(new Uint8Array(view.buffer)).set(buffer);
|
|
return view;
|
|
}
|
|
|
|
setClean() {
|
|
this.diff = {};
|
|
}
|
|
|
|
size() {
|
|
let size = 0;
|
|
// # of components.
|
|
size += 2;
|
|
for (const type in this.Components) {
|
|
size += Schema.sizeOf(type, {type: 'string'});
|
|
}
|
|
// # of entities.
|
|
size += 4;
|
|
for (const entityId of this.entities) {
|
|
size += this.get(entityId).size();
|
|
}
|
|
return size;
|
|
}
|
|
|
|
system(systemName) {
|
|
return this.Systems[systemName];
|
|
}
|
|
|
|
tick(elapsed) {
|
|
for (const systemName in this.Systems) {
|
|
if (this.Systems[systemName].active) {
|
|
this.Systems[systemName].tick(elapsed);
|
|
}
|
|
}
|
|
for (const systemName in this.Systems) {
|
|
if (this.Systems[systemName].active) {
|
|
this.Systems[systemName].finalize(elapsed);
|
|
}
|
|
}
|
|
this.tickDestruction();
|
|
}
|
|
|
|
tickDestruction() {
|
|
const unique = new Set();
|
|
for (const systemName in this.Systems) {
|
|
const System = this.Systems[systemName];
|
|
if (System.active) {
|
|
for (let j = 0; j < System.destroying.length; j++) {
|
|
unique.add(System.destroying[j]);
|
|
}
|
|
System.tickDestruction();
|
|
}
|
|
}
|
|
if (unique.size > 0) {
|
|
this.destroyMany(unique.values());
|
|
}
|
|
}
|
|
|
|
toJSON() {
|
|
const entities = {};
|
|
for (const id in this.$$entities) {
|
|
if (this.$$entities[id]) {
|
|
entities[id] = this.$$entities[id].toJSON();
|
|
}
|
|
}
|
|
const systems = [];
|
|
for (const systemName in this.Systems) {
|
|
if (this.Systems[systemName].active) {
|
|
systems.push(systemName);
|
|
}
|
|
}
|
|
return {
|
|
entities,
|
|
systems,
|
|
};
|
|
}
|
|
|
|
}
|