@rbxts/replecs 0.4.0-rc.2 → 0.4.0-rc.3

package/out/replecs/client/init.luau

@@ -891,20 +891,11 @@ local function process_entity_updates(
 	end
 end
 
--- one update group: [u16 group mask, deleted ids, added ids, per entity
--- blocks] in read order. deletions come first so a server id reused by an
--- addition in the same group starts from a fresh entity
+-- one update group: [u16 group mask, added ids, per entity blocks, deleted
+-- ids] in read order. creations, then updates, then deletions
 local function process_update_group(self: Client, c: Cursor, custom_ids: CustomIdMap, variants: Array<any>?)
 	local mask = cursor.readu16(c)
 
-	local total_deleted = read_vlq_bitmask(c, mask, UPDATE_GROUP_BITS.deleted_entities)
-	for _ = 1, total_deleted do
-		local entity, server_id = find_entity(self, c)
-		if entity then
-			delete_entity(self, entity, server_id)
-		end
-	end
-
 	local total_added = read_vlq_bitmask(c, mask, UPDATE_GROUP_BITS.added_entities)
 	for _ = 1, total_added do
 		process_entity(self, c, custom_ids)
@@ -916,6 +907,14 @@ local function process_update_group(self: Client, c: Cursor, custom_ids: CustomI
 			process_entity_updates(self, entity, c, custom_ids, variants)
 		end)
 	end
+
+	local total_deleted = read_vlq_bitmask(c, mask, UPDATE_GROUP_BITS.deleted_entities)
+	for _ = 1, total_deleted do
+		local entity, server_id = find_entity(self, c)
+		if entity then
+			delete_entity(self, entity, server_id)
+		end
+	end
 end
 
 local function apply_command_buffer(

package/out/replecs/index.d.ts

@@ -0,0 +1,297 @@
+import type { Entity, Id, InferComponent, Pair, Tag, World } from "@rbxts/jecs";
+
+declare namespace Replecs {
+  export type SerdesTable<T = any> =
+    | {
+        bytespan?: number;
+        includes_variants?: false;
+        serialize: (value: T) => buffer;
+        deserialize: (buffer: buffer) => T;
+      }
+    | {
+        bytespan?: number;
+        includes_variants: true;
+        serialize: (value: T) => LuaTuple<[buffer, defined[] | undefined]>;
+        deserialize: (buffer: buffer, blobs: defined[] | undefined) => T;
+      };
+
+  export type Serdes<T = any> = SerdesTable<T>;
+
+  export interface Preprocessor<B = any, A = any> {
+    serialize: (value: B) => A;
+    deserialize: (value: A) => B;
+  }
+
+  export interface DeltaSerializer<T = any, D = T> {
+    snapshot?: (value: T) => T;
+    delta: (old: T, curr: T) => D;
+    apply: (curr: T, delta: D) => T;
+  }
+
+  type MemberFilterMap = Map<Player, boolean>;
+  export type MemberFilterPredicate = (player: Player) => boolean;
+  type MemberFilter =
+    | Player
+    | MemberFilterMap
+    | MemberFilterPredicate
+    | Record<string, never>
+    | undefined;
+  type Member = unknown;
+
+  export interface SharedInfo<T> {
+    lookup: Record<string, T>;
+    keys: string[];
+    indexes: T[];
+    members: Map<T, number>;
+  }
+  export interface HandleContext {
+    entity_id: number;
+    component: <T>(component: Entity<T>) => T;
+    target: (relation: Id, index?: number) => Entity | undefined;
+    pair_value: <T>(relation: Id<T>, target: Entity) => T | undefined;
+    has_pair: (relation: Id, target: Entity) => boolean;
+
+    entity: (server_entity: number) => Entity | undefined;
+    has: (tag: Entity) => boolean;
+  }
+  export interface CustomId {
+    identifier: string;
+    handle_callback: (ctx: HandleContext) => Entity;
+    handle(handler: (ctx: HandleContext) => Entity): void;
+  }
+
+  export interface Shared {
+    components: SharedInfo<Entity>;
+    custom_ids: SharedInfo<CustomId>;
+    serdes: Map<Id, SerdesTable>;
+  }
+  interface HandshakeSerdesInfo {
+    includes_variants?: boolean;
+    bytespan?: number;
+  }
+
+  export interface HandshakeInfo {
+    components: Record<string, boolean>;
+    custom_ids: Record<string, boolean>;
+    serdes: Record<string, HandshakeSerdesInfo>;
+  }
+
+  export interface Components {
+    shared: Tag;
+    networked: Entity<MemberFilter>;
+    reliable: Entity<MemberFilter>;
+    unreliable: Entity<MemberFilter>;
+    once: Entity<MemberFilter>;
+    relation: Entity<MemberFilter>;
+
+    serdes: Entity<SerdesTable>;
+    custom: Entity;
+    custom_handler: Entity<(value: any) => Entity>;
+
+    Shared: Tag;
+    Networked: Entity<MemberFilter>;
+    Reliable: Entity<MemberFilter>;
+    Unreliable: Entity<MemberFilter>;
+    Once: Entity<MemberFilter>;
+    Relation: Entity<MemberFilter>;
+
+    Serdes: Entity<SerdesTable>;
+    Custom: Entity;
+    CustomHandler: Entity<(value: any) => Entity>;
+  }
+
+  interface SerializationOptions {
+    set_serdes<T extends Id>(
+      component: InferComponent<T>,
+      serdes: SerdesTable<T>,
+    ): void;
+    remove_serdes(component: Id): void;
+
+    set_preprocessor<T extends Id, A = any>(
+      component: T,
+      preprocessor: Preprocessor<InferComponent<T>, A>,
+    ): void;
+    remove_preprocessor(component: Id): void;
+
+    set_delta_serializer<T extends Id, D = InferComponent<T>>(
+      component: T,
+      delta: DeltaSerializer<InferComponent<T>, D>,
+    ): void;
+    remove_delta_serializer(component: Id): void;
+  }
+
+  export interface ClientImp extends SerializationOptions {}
+
+  export interface Client extends ClientImp {
+    world: World;
+    inited?: boolean;
+
+    is_replicating: boolean;
+    after_replication_callbacks: (() => void)[];
+
+    components: Components;
+    shared: Shared;
+
+    init(world?: World): void;
+    destroy(): void;
+    handle_global(handler: (id: number) => Entity): void;
+    get_server_entity(client_entity: Entity): number | undefined;
+    get_client_entity(server_entity: number): Entity | undefined;
+
+    register_entity(entity: Entity, server_entity: number): void;
+    unregister_entity(entity: Entity): void;
+
+    after_replication(callback: () => void): void;
+    added(callback: (entity: Entity) => void): () => void;
+
+    hook<T>(
+      action: "changed",
+      relation: Pair<MemberFilter, T>,
+      callback: (entity: Entity, id: Id<T>, value: T) => void,
+    ): () => void;
+    hook<T>(
+      action: "removed",
+      relation: Pair<MemberFilter, T>,
+      callback: (entity: Entity, id: Id<T>) => void,
+    ): () => void;
+    hook(
+      action: "deleted",
+      entity: Entity,
+      callback: (entity: Entity) => void,
+    ): () => void;
+
+    override<T>(
+      action: "changed",
+      relation: Pair<MemberFilter, T>,
+      callback: (entity: Entity, id: Id<T>, value: T) => void,
+    ): () => void;
+    override<T>(
+      action: "removed",
+      relation: Pair<MemberFilter, T>,
+      callback: (entity: Entity, id: Id<T>) => void,
+    ): () => void;
+    override(
+      action: "deleted",
+      entity: Entity,
+      callback: (entity: Entity) => void,
+    ): () => void;
+
+    encode_component(component: Entity): number;
+    decode_component(encoded: number): Entity | undefined;
+    get_shared_count(): number;
+
+    register_custom_id(custom_id: CustomId): void;
+
+    apply_updates(buf: buffer, all_variants?: defined[][]): void;
+    apply_unreliable(buf: buffer, all_variants?: defined[][]): void;
+    apply_full(buf: buffer, variants?: defined[]): void;
+    apply_entity(buf: buffer, all_variants?: defined[][]): void;
+
+    generate_handshake(): HandshakeInfo;
+    verify_handshake(
+      handshake: HandshakeInfo,
+    ): LuaTuple<[true]> | LuaTuple<[false, string]>;
+  }
+
+  export interface ServerImp extends SerializationOptions {
+    set_networked(entity: Entity, filter?: MemberFilter): void;
+    set_reliable(
+      entity: Entity,
+      component: Entity,
+      filter?: MemberFilter,
+    ): void;
+    set_unreliable(
+      entity: Entity,
+      component: Entity,
+      filter?: MemberFilter,
+    ): void;
+    set_once(entity: Entity, component: Entity, filter?: MemberFilter): void;
+    set_pair(entity: Entity, id: Pair, filter?: MemberFilter): void;
+    set_unreliable_pair(entity: Entity, id: Pair, filter?: MemberFilter): void;
+    set_relation(entity: Entity, relation: Entity, filter?: MemberFilter): void;
+
+    stop_networked(entity: Entity): void;
+    stop_reliable(entity: Entity, component: Entity): void;
+    stop_unreliable(entity: Entity, component: Entity): void;
+    stop_once(entity: Entity, component: Entity): void;
+    stop_pair(entity: Entity, id: Pair): void;
+    stop_unreliable_pair(entity: Entity, id: Pair): void;
+    stop_relation(entity: Entity, relation: Entity): void;
+
+    /** Marks a reliable/once component dirty so its current value replicates again. */
+    force_change(entity: Entity, component: Entity): void;
+
+    set_global(entity: Entity, global_id: number): void;
+    remove_global(entity: Entity): void;
+    set_custom(entity: Entity, handler: Entity | CustomId): void;
+    remove_custom(entity: Entity): void;
+  }
+
+  export interface Server extends ServerImp {
+    world: World;
+    inited?: boolean;
+
+    components: Components;
+    shared: Shared;
+
+    init(world?: World): void;
+    destroy(): void;
+
+    encode_component(component: Entity): number;
+    decode_component(encoded: number): Entity | undefined;
+    get_shared_count(): number;
+
+    register_custom_id(custom_id: CustomId): void;
+
+    get_full(player: Player): LuaTuple<[buffer, defined[]]>;
+    collect_entity(
+      entity: Entity,
+    ): IterableFunction<LuaTuple<[Player, buffer, defined[][] | undefined]>>;
+    collect_updates(): IterableFunction<
+      LuaTuple<[Player, buffer, defined[][] | undefined]>
+    >;
+    collect_unreliable(): IterableFunction<
+      LuaTuple<[Player, buffer, defined[][] | undefined]>
+    >;
+
+    register_player(player: Player): void;
+    remove_player(player: Player): void;
+    mark_player_ready(player: Player): void;
+    is_player_ready(player: Player): boolean;
+
+    add_player_alias(client: Player, alias: defined): void;
+    remove_player_alias(alias: defined): void;
+
+    generate_handshake(): HandshakeInfo;
+    verify_handshake(
+      handshake: HandshakeInfo,
+    ): LuaTuple<[true]> | LuaTuple<[false, string]>;
+  }
+
+  export interface ReplecsLib extends SerializationOptions {
+    client: Client;
+    server: Server;
+    components: Components;
+
+    after_replication(callback: () => void): void;
+    register_custom_id(custom_id: CustomId): void;
+  }
+
+  export interface Replecs extends Components {
+    VERSION: string;
+    /** Client cap used to size the server bitmasks. Read at `create` / `create_server`. */
+    MAX_CLIENTS: number;
+
+    create: (world?: World) => ReplecsLib;
+    create_server: (world?: World) => Server;
+    create_client: (world?: World) => Client;
+    create_custom_id: (
+      identifier: string,
+      handler?: (ctx: HandleContext) => Entity,
+    ) => CustomId;
+  }
+}
+
+declare const Replecs: Replecs.Replecs;
+
+export = Replecs;

package/out/replecs/server/init.luau

@@ -2263,7 +2263,6 @@ end
 
 -- layout (read order is the reverse of write order):
 --   u16 group mask                         GROUP_BITS, vlq count per set bit
---   deleted entities                       entity ids
 --   added entities                         entity ids
 --   updates                                per entity:
 --     entity id
@@ -2276,12 +2275,20 @@ end
 --                                          changed / added / removed, each vlq counted
 --     full relations                       components then tags, each vlq counted
 --     relations removed                    relation ids, vlq
+--   deleted entities                       entity ids
 local function serialize_update_group(self: Server, group: SerializeGroup): (buffer, Array<any>)
 	local c = cursor.new()
 	local variants: Array<any> = {}
 	local group_mask = 0
 
 	local total = 0
+	for _, entity in group.deleted_entities do
+		write_entity_id(self, c, entity)
+		total += 1
+	end
+	group_mask = write_vlq_bitmask(c, total, group_mask, GROUP_BITS.deleted_entities)
+
+	total = 0
 	for entity, entry in group.updates do
 		serialize_entity_updates(self, c, entity, entry, variants)
 		total += 1
@@ -2295,13 +2302,6 @@ local function serialize_update_group(self: Server, group: SerializeGroup): (buf
 	end
 	group_mask = write_vlq_bitmask(c, total, group_mask, GROUP_BITS.added_entities)
 
-	total = 0
-	for _, entity in group.deleted_entities do
-		write_entity_id(self, c, entity)
-		total += 1
-	end
-	group_mask = write_vlq_bitmask(c, total, group_mask, GROUP_BITS.deleted_entities)
-
 	cursor.writeu16(c, group_mask)
 
 	return cursor.close(c), variants

package/out/replecs/ver.luau

@@ -1 +1 @@
-return "v0.4.0-rc.2"
+return "v0.4.0-rc.3"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rbxts/replecs",
-  "version": "0.4.0-rc.2",
+  "version": "0.4.0-rc.3",
   "description": "Replication library for Jecs",
   "main": "out/init.luau",
   "types": "out/index.d.ts",
@@ -21,8 +21,7 @@
     "out",
     "!**/*.spec.lua",
     "!**/*.spec.d.ts",
-    "!**/*.tsbuildinfo",
-    "!out/replecs/index.d.ts"
+    "!**/*.tsbuildinfo"
   ],
   "scripts": {
     "serve": "rojo sourcemap serve.project.json -o sourcemap.json --watch && rojo serve serve.project.json"