@rbxts/replecs 0.2.4 → 0.3.0-test1

package/out/replecs/client.luau

@@ -70,8 +70,8 @@ type DeletedHookEntry = {
 type CustomIdMap = { [Entity]: CustomId | Entity }
 
 export type ClientImp = {
-	set_serdes: <T>(client: Client, id: Component<T>, serdes: types.Serdes<T>) -> (),
-	remove_serdes: (client: Client, id: Component) -> (),
+	set_serdes: <T>(self: Client, id: Component<T>, serdes: types.Serdes<T>) -> (),
+	remove_serdes: (self: Client, id: Component) -> (),
 }
 
 export type Client = ClientImp & {
@@ -158,6 +158,7 @@ local WORLD_ADD = common.world_add
 local WORLD_SET = common.world_set
 local WORLD_REMOVE = common.world_remove
 local WORLD_GET = common.world_get
+local WORLD_HAS = common.world_has
 local WORLD_DELETE = common.world_delete
 
 local HOOK_ADDED = common.hook_added
@@ -269,7 +270,9 @@ function client_replicator.entity_set_unreliable(
 		local command_buffer = get_or_create_command_buffer(client, entity)
 		command_buffer.unreliable_components[id] = { value = value }
 	else
-		client_replicator.entity_set(client, entity, id, value, changed_hooks)
+		if WORLD_HAS(client.world, entity, id) then
+			client_replicator.entity_set(client, entity, id, value, changed_hooks)
+		end
 	end
 end
 
@@ -1371,6 +1374,7 @@ function client_replicator.apply_unreliable(client: Client, buf: buffer, all_var
 				for _ = 1, total_unreliable do
 					local component = client_replicator.read_component_id(client, c)
 					local value = client_replicator.read_component_value(client, component, c, variants)
+
 					local unreliable_hooks = changed_hooks[PAIR(components.unreliable, component)]
 					client_replicator.entity_set_unreliable(client, entity, component, value, unreliable_hooks)
 				end

package/out/replecs/index.d.ts

@@ -1,18 +1,18 @@
-import type { Entity, Id, Pair, Tag, World } from "@rbxts/jecs";
+import type { Entity, Id, InferComponent, Pair, Tag, World } from "@rbxts/jecs";
 
 declare namespace Replecs {
-  export type SerdesTable =
+  export type SerdesTable<T = any> =
     | {
         bytespan?: number;
         includes_variants?: false;
-        serialize: (value: any) => buffer;
-        deserialize: (buffer: buffer) => any;
+        serialize: (value: T) => buffer;
+        deserialize: (buffer: buffer) => T;
       }
     | {
         bytespan?: number;
         includes_variants: true;
-        serialize: (value: any) => LuaTuple<[buffer, defined[] | undefined]>;
-        deserialize: (buffer: buffer, blobs: defined[] | undefined) => any;
+        serialize: (value: T) => LuaTuple<[buffer, defined[] | undefined]>;
+        deserialize: (buffer: buffer, blobs: defined[] | undefined) => T;
       };
 
   type MemberFilterMap = Map<Player, boolean>;
@@ -80,6 +80,14 @@ declare namespace Replecs {
     Global: Entity<number>;
   }
 
+  export interface ClientImp {
+    set_serdes<T extends Id>(
+      component: InferComponent<T>,
+      serdes: SerdesTable<T>,
+    ): void;
+    remove_serdes(component: Id): void;
+  }
+
   export interface Client {
     world: World;
     inited?: boolean;
@@ -91,9 +99,7 @@ declare namespace Replecs {
 
     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;
 
@@ -137,11 +143,14 @@ declare namespace Replecs {
 
     encode_component(component: Entity): number;
     decode_component(encoded: number): Entity;
+    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, all_variants?: defined[][]): void;
+    apply_entity(buf: buffer, all_variants?: defined[][]): void;
 
     generate_handshake(): HandshakeInfo;
     verify_handshake(
@@ -161,15 +170,23 @@ declare namespace Replecs {
       component: Entity,
       filter?: MemberFilter,
     ): void;
+    set_pair(entity: Entity, id: Pair, filter?: MemberFilter): void;
     set_relation(entity: Entity, relation: Entity, filter?: MemberFilter): void;
 
     stop_networked(entity: Entity, keep?: boolean): void;
     stop_reliable(entity: Entity, component: Entity, keep?: boolean): void;
     stop_unreliable(entity: Entity, component: Entity, keep?: boolean): void;
+    stop_pair(entity: Entity, id: Pair): void;
     stop_relation(entity: Entity, relation: Entity, keep?: boolean): void;
 
     set_custom(entity: Entity, handler: Entity | CustomId): void;
     remove_custom(entity: Entity): void;
+
+    set_serdes<T extends Id>(
+      component: InferComponent<T>,
+      serdes: SerdesTable<T>,
+    ): void;
+    remove_serdes(component: Id): void;
   }
 
   export interface Server extends ServerImp {
@@ -180,15 +197,20 @@ declare namespace Replecs {
     destroy(): void;
 
     encode_component(component: Entity): number;
-    decode_component(encoded: number): Entity;
+    decode_component(encoded: number): Entity | undefined;
+    get_shared_count(): number;
+
     register_custom_id(custom_id: CustomId): void;
 
-    get_full(player: Player): LuaTuple<[buffer, defined[][]?]>;
+    get_full(player: Player): LuaTuple<[buffer, defined[][] | undefined]>;
+    collect_entity(
+      entity: Entity,
+    ): IterableFunction<LuaTuple<[Player, buffer, defined[][] | undefined]>>;
     collect_updates(): IterableFunction<
-      LuaTuple<[Player, buffer, defined[][]?]>
+      LuaTuple<[Player, buffer, defined[][] | undefined]>
     >;
     collect_unreliable(): IterableFunction<
-      LuaTuple<[Player, buffer, defined[][]?]>
+      LuaTuple<[Player, buffer, defined[][] | undefined]>
     >;
 
     mark_player_ready(player: Player): void;
@@ -209,6 +231,12 @@ declare namespace Replecs {
 
     after_replication(callback: () => void): void;
     register_custom_id(custom_id: CustomId): void;
+
+    set_serdes<T extends Id>(
+      component: InferComponent<T>,
+      serdes: SerdesTable<T>,
+    ): void;
+    remove_serdes(component: Id): void;
   }
 
   export interface Replecs extends Components {

package/out/replecs/init.luau

@@ -13,6 +13,7 @@ export type Client = client.Client
 
 type Entity = common.Entity
 type World = common.World
+type Component<T = any> = common.Component<T>
 
 export type HandleContext = customid.HandleContext
 export type CustomId = customid.CustomId
@@ -26,6 +27,9 @@ export type ReplecsLib = {
 
 	after_replication: (self: ReplecsLib, callback: () -> ()) -> (),
 	register_custom_id: (self: ReplecsLib, custom_id: CustomId) -> (),
+
+	set_serdes: <T>(self: ReplecsLib, id: Component<T>, serdes: types.Serdes<T>) -> (),
+	remove_serdes: (self: ReplecsLib, id: Component) -> (),
 }
 
 type Replecs = types.Components & {
@@ -109,4 +113,22 @@ function replecs.register_custom_id(lib: ReplecsLib, custom_id: CustomId)
 	end
 end
 
+function replecs.set_serdes(lib: ReplecsLib, id: Component, serdes: Serdes)
+	if lib.server then
+		lib.server:set_serdes(id, serdes)
+	end
+	if lib.client then
+		lib.client:set_serdes(id, serdes)
+	end
+end
+
+function replecs.remove_serdes(lib: ReplecsLib, id: Component)
+	if lib.server then
+		lib.server:remove_serdes(id)
+	end
+	if lib.client then
+		lib.client:remove_serdes(id)
+	end
+end
+
 return replecs :: Replecs