@rbxts/replecs 0.1.0-alpha9-test5 → 0.2.0-cdtest.1

package/out/replecs/common.luau

@@ -1,52 +1,69 @@
 local jecs = require "../jecs"
+local customid = require "./customid"
+
+export type FunctionFilter = (player: Player) -> boolean
+export type AnyFilter = PlayerFilter | Player
+type Entity<T = any> = jecs.Entity<T>
 
 export type PlayerFilter = {
 	[Player]: boolean,
 }
 
+export type SharedInfo<T> = {
+	lookup: { [string]: T },
+	keys: { string },
+	indexes: { [number]: T },
+	members: { [T]: number },
+}
+export type HandshakeInfo = {
+	components: { [string]: boolean },
+	custom_ids: { [string]: boolean },
+	serdes: { [string]: {
+		includes_variants: boolean?,
+		bytespan: number?,
+	} },
+}
+
 export type Serdes = {
 	includes_variants: boolean?,
+	bytespan: number?,
 	serialize: (value: any) -> (buffer, { any }?),
 	deserialize: (buffer, { any }?) -> any,
 }
 
 export type Components = {
-	shared: jecs.Entity,
-	networked: jecs.Entity<PlayerFilter?>,
-	reliable: jecs.Entity,
-	unreliable: jecs.Entity,
-	pair: jecs.Entity,
-
-	serdes: jecs.Entity<Serdes>,
-	bytespan: jecs.Entity<number>,
-	custom: jecs.Entity,
-	custom_handler: jecs.Entity<(value: any) -> jecs.Entity>,
-	global: jecs.Entity<number>,
-	__alive_tracking__: jecs.Entity,
+	shared: Entity,
+	networked: Entity<AnyFilter?>,
+	reliable: Entity<AnyFilter?>,
+	unreliable: Entity<AnyFilter?>,
+	pair: Entity<AnyFilter?>,
+
+	serdes: Entity<Serdes>,
+	custom: Entity,
+	custom_handler: Entity<(val: any) -> Entity?>,
+	global: Entity<number>,
+	__alive_tracking__: Entity,
 }
 
 export type Shared = {
-	lookup: { [string]: jecs.Entity },
-
-	components: { [number]: jecs.Entity },
-	ids: { [jecs.Entity]: number },
+	components: SharedInfo<Entity>,
+	custom_ids: SharedInfo<customid.CustomId>,
 
-	bytespan: { [jecs.Entity]: number },
-	serdes: { [jecs.Entity]: Serdes },
+	serdes: { [Entity]: Serdes },
 }
 
 export type WorldHooks = {
 	added: (
 		world: jecs.World,
-		component: jecs.Entity,
-		fn: (entity: jecs.Entity, id: jecs.Id, value: any) -> ()
+		component: Entity,
+		fn: (entity: Entity, id: jecs.Id, value: any) -> ()
 	) -> () -> (),
 	changed: (
 		world: jecs.World,
-		component: jecs.Entity,
-		fn: (entity: jecs.Entity, id: jecs.Id, value: any) -> ()
+		component: Entity,
+		fn: (entity: Entity, id: jecs.Id, value: any) -> ()
 	) -> () -> (),
-	removed: (world: jecs.World, component: jecs.Entity, fn: (entity: jecs.Entity, id: jecs.Id) -> ()) -> () -> (),
+	removed: (world: jecs.World, component: Entity, fn: (entity: Entity, id: jecs.Id) -> ()) -> () -> (),
 }
 
 return nil

package/out/replecs/customid.luau

@@ -0,0 +1,39 @@
+local jecs = require "../jecs"
+
+type Entity<T = any> = jecs.Entity<T>
+type Id<T = any> = jecs.Id<T>
+type World = jecs.World
+
+export type HandleContext = {
+	entity_id: number,
+	component: <T>(component: Entity<T>) -> T,
+	target: (relation: jecs.Id, index: number?) -> Entity?,
+	pair_value: <T>(relation: jecs.Id<T>, target: Entity) -> T?,
+	has_pair: (relation: jecs.Id, target: Entity) -> boolean,
+
+	entity: (server_entity: number) -> Entity,
+	has: (tag: Entity) -> boolean,
+}
+
+export type CustomId = {
+	identifier: string,
+	handle_callback: ((ctx: HandleContext) -> Entity?)?,
+
+	handle: (self: CustomId, handler: (ctx: HandleContext) -> Entity?) -> (),
+}
+
+local custom_id = {}
+
+function custom_id.handle(custom: CustomId, callback: (ctx: HandleContext) -> Entity?)
+	custom.handle_callback = callback
+end
+
+function create(identifier: string, callback: ((ctx: HandleContext) -> Entity?)?): CustomId
+	local handler = {} :: CustomId
+	handler.identifier = identifier
+	handler.handle_callback = callback
+
+	return setmetatable(handler, custom_id) :: any
+end
+
+return { create = create }

package/out/replecs/index.d.ts

@@ -1,13 +1,15 @@
-import type { Entity, Pair, Tag, World } from "@rbxts/jecs";
+import type { Entity, Id, Pair, Tag, World } from "@rbxts/jecs";
 
 declare namespace Replecs {
    export type SerdesTable =
       | {
+           bytespan?: number;
            includes_variants?: false;
            serialize: (value: any) => buffer;
            deserialize: (buffer: buffer) => any;
         }
       | {
+           bytespan?: number;
            includes_variants: true;
            serialize: (value: any) => LuaTuple<[buffer, defined[] | undefined]>;
            deserialize: (buffer: buffer, blobs: defined[] | undefined) => any;
@@ -17,11 +19,41 @@ declare namespace Replecs {
    type MemberFilter = Player | MemberFilterMap | undefined;
    type Member = unknown;
 
-   interface MaskingController {
-      register_member(member: Member): void;
-      unregister_member(member: Member): void;
-      active_member(member: Member): void;
-      member_is_active(member: Member): boolean;
+   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>;
+   }
+   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 {
@@ -32,7 +64,6 @@ declare namespace Replecs {
       pair: Entity<MemberFilter>;
 
       serdes: Entity<SerdesTable>;
-      bytespan: Entity<number>;
       custom: Entity;
       custom_handler: Entity<(value: any) => Entity>;
       global: Entity<number>;
@@ -44,7 +75,6 @@ declare namespace Replecs {
       Pair: Entity<MemberFilter>;
 
       Serdes: Entity<SerdesTable>;
-      Bytespan: Entity<number>;
       Custom: Entity;
       CustomHandler: Entity<(value: any) => Entity>;
       Global: Entity<number>;
@@ -54,67 +84,120 @@ declare namespace Replecs {
       world: World;
       inited?: boolean;
 
+      is_relicating: boolean;
+      after_relication_callbacks: [() => void];
+
+      components: Components;
+
       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>(
-         entity: Entity,
          action: "changed",
          relation: Pair<MemberFilter, T>,
-         callback: (entity: Entity, id: Entity<T>, value: T) => void
+         callback: (entity: Entity, id: Id<T>, value: T) => void
       ): () => void;
       hook<T>(
-         entity: Entity,
          action: "removed",
          relation: Pair<MemberFilter, T>,
-         callback: (entity: Entity, id: Entity<T>) => void
+         callback: (entity: Entity, id: Id<T>) => void
       ): () => void;
       hook(
-         entity: Entity,
          action: "deleted",
+         entity: Entity,
          callback: (entity: Entity) => void
       ): () => void;
 
       override<T>(
-         entity: Entity,
          action: "changed",
          relation: Pair<MemberFilter, T>,
-         callback: (entity: Entity, id: Entity<T>, value: any) => void
+         callback: (entity: Entity, id: Id<T>, value: any) => void
       ): () => void;
       override<T>(
-         entity: Entity,
          action: "removed",
          relation: Pair<MemberFilter, T>,
-         callback: (entity: Entity, id: Entity<T>) => void
+         callback: (entity: Entity, id: Id<T>) => void
       ): () => void;
       override(
-         entity: Entity,
          action: "deleted",
+         entity: Entity,
          callback: (entity: Entity) => void
       ): () => void;
 
       encode_component(component: Entity): number;
       decode_component(encoded: number): Entity;
-
-      get_server_entity(client_entity: Entity): number | undefined;
-      get_client_entity(server_entity: number): Entity | undefined;
+      register_custom_id(custom_id: CustomId): void;
 
       apply_updates(buf: buffer, all_variants?: unknown[][]): void;
       apply_unreliable(buf: buffer, all_variants?: unknown[][]): void;
       apply_full(buf: buffer, all_variants?: unknown[][]): void;
+
+      generate_handshake(): HandshakeInfo;
+      verify_handshake(
+         handshake: HandshakeInfo
+      ): LuaTuple<[true]> | LuaTuple<[false, string]>;
    }
 
-   export interface Server {
+   export interface ServerImp {
+      set_networked(
+         server: Server,
+         entity: Entity,
+         filter?: MemberFilter
+      ): void;
+      stop_networked(server: Server, entity: Entity): void;
+
+      set_reliable(
+         server: Server,
+         entity: Entity,
+         component: Entity,
+         filter?: MemberFilter
+      ): void;
+      set_unreliable(
+         server: Server,
+         entity: Entity,
+         component: Entity,
+         filter?: MemberFilter
+      ): void;
+      set_pair(
+         server: Server,
+         entity: Entity,
+         relation: Entity,
+         filter?: MemberFilter
+      ): void;
+      set_custom(
+         server: Server,
+         entity: Entity,
+         handler: Entity | CustomId
+      ): void;
+
+      stop_reliable(server: Server, entity: Entity, component: Entity): void;
+      stop_unreliable(server: Server, entity: Entity, component: Entity): void;
+      stop_pair(server: Server, entity: Entity, relation: Entity): void;
+      remove_custom(server: Server, entity: Entity): void;
+   }
+
+   export interface Server extends ServerImp {
       world: World;
       inited?: boolean;
 
       init(world?: World): void;
       destroy(): void;
 
+      encode_component(component: Entity): number;
+      decode_component(encoded: number): Entity;
+      register_custom_id(custom_id: CustomId): void;
+
       get_full(player: Player): LuaTuple<[buffer, unknown[][]]>;
       collect_updates(): IterableFunction<
          LuaTuple<[Player, buffer, unknown[][]]>
@@ -123,16 +206,16 @@ declare namespace Replecs {
          LuaTuple<[Player, buffer, unknown[][]]>
       >;
 
-      encode_component(component: Entity): number;
-      decode_component(encoded: number): Entity;
-
       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;
 
-      masking: MaskingController;
+      generate_handshake(): HandshakeInfo;
+      verify_handshake(
+         handshake: HandshakeInfo
+      ): LuaTuple<[true]> | LuaTuple<[false, string]>;
    }
 
    export interface ReplecsLib {
@@ -140,12 +223,19 @@ declare namespace Replecs {
       server: Server;
 
       after_replication(callback: () => void): void;
+      register_custom_id(custom_id: CustomId): void;
    }
 
    export interface Replecs extends Components {
+      VERSION: string;
+
       create: (world?: World) => ReplecsLib;
       create_server: (world?: World) => Server;
       create_client: (world?: World) => Client;
+      create_custom_id: (
+         identifier: string,
+         handler?: (ctx: HandleContext) => Entity
+      ) => CustomId;
    }
 }
 

package/out/replecs/init.luau

@@ -3,15 +3,32 @@ local common = require "@self/common"
 
 local client = require "@self/client"
 local server = require "@self/server"
+local customid = require "@self/customid"
+local VERSION = require "@self/ver"
 
 export type Server = server.Server
 export type Client = client.Client
 
+export type HandleContext = customid.HandleContext
+export type CustomId = customid.CustomId
+export type HandshakeInfo = common.HandshakeInfo
+
+type Entity = jecs.Entity
+
 export type ReplecsLib = {
 	server: Server,
 	client: Client,
 
 	after_replication: (self: ReplecsLib, callback: () -> ()) -> (),
+	register_custom_id: (self: ReplecsLib, custom_id: CustomId) -> (),
+}
+
+type Replecs = common.Components & {
+	create: (world: jecs.World?) -> ReplecsLib,
+
+	create_server: (world: jecs.World?) -> Server,
+	create_client: (world: jecs.World?) -> Client,
+	create_custom_id: (identifier: string, handler: (ctx: HandleContext) -> Entity?) -> CustomId,
 }
 
 type MemberFilter = {
@@ -19,23 +36,22 @@ type MemberFilter = {
 }
 
 local replecs = {
+	VERSION = VERSION,
 	shared = jecs.tag(),
-	networked = jecs.component() :: jecs.Entity<(MemberFilter | Player)?>,
-	reliable = jecs.component() :: jecs.Entity<(MemberFilter | Player)?>,
-	unreliable = jecs.component() :: jecs.Entity<(MemberFilter | Player)?>,
-	pair = jecs.component() :: jecs.Entity<(MemberFilter | Player)?>,
-
-	serdes = jecs.component() :: jecs.Entity<common.Serdes>,
-	bytespan = jecs.component() :: jecs.Entity<number>,
-	custom = jecs.tag() :: jecs.Entity,
-	custom_handler = jecs.component() :: jecs.Entity<(any) -> jecs.Entity>,
-	global = jecs.component() :: jecs.Entity<number>,
+	networked = jecs.component(),
+	reliable = jecs.component(),
+	unreliable = jecs.component(),
+	pair = jecs.component(),
+
+	serdes = jecs.component(),
+	custom = jecs.tag(),
+	custom_handler = jecs.component(),
+	global = jecs.component(),
 	__alive_tracking__ = jecs.tag(),
 }
 
 replecs.__index = replecs
 replecs.Serdes = replecs.serdes
-replecs.Bytespan = replecs.bytespan
 replecs.Custom = replecs.custom
 replecs.CustomHandler = replecs.custom_handler
 replecs.Networked = replecs.networked
@@ -46,7 +62,6 @@ replecs.Shared = replecs.shared
 replecs.Global = replecs.global
 
 jecs.meta(replecs.serdes, jecs.Name, "replecs.serdes")
-jecs.meta(replecs.bytespan, jecs.Name, "replecs.bytespan")
 jecs.meta(replecs.custom, jecs.Name, "replecs.custom")
 jecs.meta(replecs.custom_handler, jecs.Name, "replecs.custom_handler")
 jecs.meta(replecs.networked, jecs.Name, "replecs.networked")
@@ -62,11 +77,11 @@ jecs.meta(replecs.custom, jecs.Exclusive)
 jecs.meta(replecs.global, jecs.Exclusive)
 
 function replecs.create_server(world: jecs.World?): Server
-	return server.create(world, replecs)
+	return server.create(world, replecs :: Replecs)
 end
 
 function replecs.create_client(world: jecs.World?): Client
-	return client.create(world, replecs)
+	return client.create(world, replecs :: Replecs)
 end
 
 function replecs.create(world: jecs.World?): ReplecsLib
@@ -76,15 +91,19 @@ function replecs.create(world: jecs.World?): ReplecsLib
 	local lib = {} :: ReplecsLib
 
 	if RunService:IsServer() then
-		lib.server = server.create(world, replecs)
+		lib.server = server.create(world, replecs :: Replecs)
 	end
 	if RunService:IsClient() then
-		lib.client = client.create(world, replecs)
+		lib.client = client.create(world, replecs :: Replecs)
 	end
 
 	return setmetatable(lib, replecs) :: any
 end
 
+function replecs.create_custom_id(identifier: string, handler: (ctx: HandleContext) -> Entity?)
+	return customid.create(identifier, handler)
+end
+
 function replecs.after_replication(lib: ReplecsLib, callback: () -> ())
 	local lib_client = lib.client
 	if lib_client then
@@ -94,4 +113,13 @@ function replecs.after_replication(lib: ReplecsLib, callback: () -> ())
 	end
 end
 
-return replecs
+function replecs.register_custom_id(lib: ReplecsLib, custom_id: CustomId)
+	if lib.server then
+		lib.server:register_custom_id(custom_id)
+	end
+	if lib.client then
+		lib.client:register_custom_id(custom_id)
+	end
+end
+
+return replecs :: Replecs