@rbxts/replecs 0.4.0-rc.1 → 0.4.0-rc.2.ts.1

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

@@ -216,7 +216,6 @@ export type Server = ServerImp & {
 	last_active_bitmask: Bitmask,
 	newly_active_bitmask: Bitmask,
 	newly_unactive_bitmask: Bitmask,
-	pending_active: Set<Player>,
 
 	entity_bitmask_deltas: BitmaskDeltas,
 	component_bitmask_deltas: BitmaskDeltas,
@@ -2456,15 +2455,6 @@ local function collect_updates_groups(self: Server): Map<MaskHash, SerializeGrou
 	local newly_active = self.newly_active_bitmask
 	local newly_unactive = self.newly_unactive_bitmask
 
-	local client_indexes = self.registry.client_indexes
-	for player in self.pending_active do
-		local index = client_indexes[player]
-		if index then
-			bitmasks.set(active, index)
-		end
-	end
-	table.clear(self.pending_active)
-
 	bitmasks.exclude(active, last_active, newly_active)
 	bitmasks.exclude(last_active, active, newly_unactive)
 
@@ -3596,10 +3586,10 @@ function server.mark_player_ready(self: Server, player: Player)
 	registry:register_client(player)
 
 	local index = registry.client_indexes[player]
-	if index and bitmasks.test(self.client_active_bitmask, index) then
+	if not index then
 		return
 	end
-	self.pending_active[player] = true
+	bitmasks.set(self.client_active_bitmask, index)
 end
 
 function server.is_player_ready(self: Server, player: Player): boolean
@@ -3681,7 +3671,6 @@ function server.remove_player(self: Server, player: Player)
 		end
 	end
 
-	self.pending_active[player] = nil
 	registry:remove_client_aliases(player)
 	registry:unregister_client(player)
 end
@@ -3914,7 +3903,6 @@ function server.create(world: World?, components: types.Components?, max_clients
 	self.last_active_bitmask = buffer.create(self.bitmask_size)
 	self.newly_active_bitmask = buffer.create(self.bitmask_size)
 	self.newly_unactive_bitmask = buffer.create(self.bitmask_size)
-	self.pending_active = {}
 
 	self.entity_bitmask_deltas = {
 		added = buffer.create(self.bitmask_size),

package/out/replecs/ver.luau

@@ -1 +1 @@
-return "v0.4.0-rc.1"
+return "0.4.0-rc.2.ts.1"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rbxts/replecs",
-  "version": "0.4.0-rc.1",
+  "version": "0.4.0-rc.2.ts.1",
   "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"