feat: basic framework

Author: mooooooi

.gitignore

@@ -0,0 +1,3 @@
+dist
+node_modules
+yarn.lock

package.json

@@ -0,0 +1,19 @@
+{
+  "name": "netcode",
+  "version": "1.0.0",
+  "description": "A js game framework for state-synchronization.",
+  "main": "dist/netcode.js",
+  "types": "dist/index.d.ts",
+  "repository": "https://github.com/netcodejs/netcode",
+  "author": "moruiyi",
+  "license": "GPL-3.0-or-later",
+  "devDependencies": {
+    "rollup": "^2.39.0",
+    "rollup-plugin-typescript2": "^0.30.0",
+    "tslib": "^2.1.0",
+    "typescript": "^4.1.5"
+  },
+  "scripts": {
+    "build": "yarn run rollup -c"
+  }
+}

rollup.config.js

@@ -0,0 +1,10 @@
+import typescript from 'rollup-plugin-typescript2'
+
+export default {
+    input: "src/index.ts",
+    output: {
+        file: "dist/netcode.js",
+        format: "es"
+    },
+    plugins: [typescript()]
+}

src/component.ts

@@ -0,0 +1,36 @@
+import { Macro } from "./macro";
+
+export let ComponentClassType: any[] = []
+export function Component<T extends { new(): any }>(target: T) {
+    target.prototype.__classId__ = ComponentClassType.push(target) - 1;
+}
+
+export function Param(type: ParamType): PropertyDecorator {
+    return function(target: any, propertyKey: string | symbol) {
+        if (!target.__schema__)
+            target.__schema__ = { count: 0, props: {} }
+        const s = target.__schema__;
+
+        const paramIndex = s.count++;
+        const v = { propertyKey, type, paramIndex };
+        s.props[paramIndex] = v
+        s.props[propertyKey] = v
+    }
+}
+
+export enum ParamType {
+    i8, u8, i16, u16, i32, u32, i64, u64, int, long, float, double, string, bool, f32, f64
+}
+
+export interface IComponent {
+    owner?:number;
+    __schema__?: Record<string | number, string | number>
+
+    onLoad?(): void;
+    onStart?(): void;
+    onDestroy?(): void;
+
+    update?(): void;
+    fixedUpdate?(): void;
+    lateUpdate?(): void;
+}

src/data/serializable.ts

@@ -0,0 +1,8 @@
+export interface Serializable<T extends String | ArrayBuffer> {
+    ser(buffer: DataBuffer<T>): void;
+    deser(buffer: DataBuffer<T>): void;
+}
+
+export interface DataBuffer<T extends String | ArrayBuffer> {
+
+}

src/domain.ts

@@ -0,0 +1,78 @@
+import { Entity } from "./entity";
+import { Macro } from "./macro";
+
+class EntityNotValidError extends Error {}
+class EntityRepeatRegisteredError extends Error {}
+class EntityGroupOutOfRangeYouCanOpenAutoResize extends Error {}
+class DomainDefinition {
+    private _entities: (Entity | null)[]
+    private _entityVersion: number[]
+    private _destroyEntityId: number[]
+    private _entityIdCursor = 0;
+
+    constructor(public capacity = 50, public autoResize = true) {
+        this._entities = new Array<Entity>(capacity);
+        this._entityVersion = new Array<number>(capacity);
+        this._entityVersion.fill(0);
+        this._destroyEntityId = new Array<number>(capacity);
+    }
+
+    reg(entity: Entity) {
+        if (this.isValid(entity))
+            throw new EntityRepeatRegisteredError(entity.toString());
+        if (this._entityIdCursor == this.capacity && this.autoResize)
+            this.resize(Math.ceil(this.capacity * 1.5))
+        else
+            throw new EntityGroupOutOfRangeYouCanOpenAutoResize(
+                `Domain: capacity: ${this.capacity}; ` + entity.toString());
+        this._unlockEntity(entity);
+        entity.id = this._getEntityId();
+        entity.version = this._entityVersion[entity.id];
+        this._lockEntity(entity);
+        this._entities[entity.id] = entity;
+    }
+
+    unreg(entity: Entity) {
+        if (!this.isValid(entity))
+            throw new EntityNotValidError(entity.toString());
+        this._entityVersion[entity.id]++;
+        this._destroyEntityId.push(entity.id);
+        this._entities[entity.id] = null;
+    }
+
+    resize(newSize: number) {
+        const oldSize = this.capacity;
+        this._entities.length = newSize;
+        this._entityVersion.length = newSize;
+        this._entityVersion.fill(0, oldSize, newSize);
+        this.capacity = newSize;
+    }
+
+    isValid(entity: Entity) {
+        return entity.id != Macro.NULL_NUM 
+            && entity.version != Macro.NULL_NUM
+            && entity.version == this._entityVersion[entity.id]
+    }
+
+    private _getEntityId() {
+        return this._destroyEntityId.length > 0
+            ? this._destroyEntityId.unshift() 
+            : this._entityIdCursor++;
+    }
+
+    private _lockEntity(entity: Entity) {
+        Object.defineProperties(entity, {
+            "id": { writable: false },
+            "version": { writable: false }
+        })
+    }
+
+    private _unlockEntity(entity: Entity) {
+        Object.defineProperties(entity, {
+            "id": { writable: true },
+            "version": { writable: true }
+        })
+    }
+}
+
+export const Domain = new DomainDefinition();

src/entity.ts

@@ -0,0 +1,13 @@
+import { Macro } from "./macro";
+
+export class Entity {
+    id = Macro.NULL_NUM
+    version = Macro.NULL_NUM
+    constructor() {
+        Object.seal(this);
+    }
+
+    toString() {
+        return `Entity: id=${this.id},version=${this.version}`
+    }
+}

src/index.ts

@@ -0,0 +1,4 @@
+export * from './component';
+export * from './entity';
+
+import './test'

src/macro.ts

@@ -0,0 +1,4 @@
+export const Macro = {
+    NULL_NUM: -1,
+    NULL_STR: "NULL"
+}

src/test.ts

@@ -0,0 +1,26 @@
+import { Component, IComponent, Param, ParamType, ComponentClassType } from "./component";
+
+@Component
+export class ViewComponrnt implements IComponent {
+    @Param(ParamType.int)
+    width: number = 0;
+    @Param(ParamType.int)
+    height: number = 0;
+
+    onLoad() {
+
+    }
+}
+
+@Component
+export class LogicComponent {
+    @Param(ParamType.bool)
+    alive: boolean = false
+}
+
+let v1 = new ViewComponrnt();
+let v2 = new ViewComponrnt();
+
+let l1 = new LogicComponent();
+// @ts-ignore
+console.log(v1.__schema__, v2.__schema__, v1.__schema__ === v2.__schema__, l1.__schema__, ComponentClassType);