@rbxts/replecs 0.3.1 → 0.4.0-rc.2

package/out/replecs/server/registry.luau

@@ -0,0 +1,178 @@
+--!optimize 2
+local bitmasks = require (script.Parent:WaitForChild('bitmasks'))
+local utils = require (script.Parent.Parent:WaitForChild('utils'))
+
+type Set<T> = { [T]: boolean }
+type Map<K, V> = { [K]: V }
+type Array<T> = { T }
+type Bitmask = buffer
+
+type Client = any
+export type MemberPredicator = (Client) -> boolean
+
+type RegistryClass = {
+	client_indexes: Map<Client, number>,
+	-- reverse of client_indexes, kept in sync by register/unregister
+	index_clients: Map<number, Client>,
+
+	client_next_index: number,
+	client_count: number,
+
+	-- indexes released by unregister, reused before growing client_next_index
+	free_indexes: Array<number>,
+
+	-- alternate keys a filter may use for a client (a user id, a name...);
+	-- resolved to the client before registration is considered
+	client_aliases: Map<any, Client>,
+
+	-- hard cap on registered clients: every bitmask is allocated to hold
+	-- exactly this many bits, so an index past it would fall off the buffer
+	max_clients: number,
+	bitmask_size: number,
+}
+
+local registry = {}
+registry.__index = registry
+
+export type Registry = RegistryClass & typeof(registry)
+
+-- a filter can name a player before it joined the registry: register it on
+-- the spot so the bit is stable once the player is ready. a player that
+-- already left is never registered, its bit would leak into every mask
+local function resolve_member(self: Registry, member: Client): number?
+	local index = self.client_indexes[member]
+	if index then
+		return index
+	end
+
+	-- an alias stands for its client: registered or not, the client is what
+	-- gets the bit, the alias itself is never registered
+	local aliased = self.client_aliases[member]
+	if aliased ~= nil then
+		member = aliased
+		index = self.client_indexes[member]
+		if index then
+			return index
+		end
+	end
+
+	if not utils.is_client_valid(member) then
+		return nil
+	end
+
+	registry.register_client(self, member)
+	return self.client_indexes[member]
+end
+
+function registry.add_alias(self: Registry, client: Client, alias: any)
+	self.client_aliases[alias] = client
+end
+
+function registry.remove_alias(self: Registry, alias: any)
+	self.client_aliases[alias] = nil
+end
+
+-- drops every alias pointing at the client
+function registry.remove_client_aliases(self: Registry, client: Client)
+	local aliases = self.client_aliases
+	for alias, aliased in aliases do
+		if aliased == client then
+			aliases[alias] = nil
+		end
+	end
+end
+
+
+function registry.create_bitmask_from_set(self: Registry, member_set: Map<Client, boolean>): Bitmask
+	local resolved_members: Array<number> = {}
+	for member in member_set do
+		local resolved = resolve_member(self, member)
+		if resolved then
+			table.insert(resolved_members, resolved)
+		end
+	end
+
+	local bitmask = buffer.create(self.bitmask_size)
+
+	for _, index in resolved_members do
+		bitmasks.set(bitmask, index)
+	end
+
+	return bitmask
+end
+
+
+function registry.create_bitmask_from_member(self: Registry, member: Client): Bitmask
+	local bitmask = buffer.create(self.bitmask_size)
+	local index = resolve_member(self, member)
+	if index then
+		bitmasks.set(bitmask, index)
+	end
+	return bitmask
+end
+
+
+function registry.create_bitmask_from_function(self: Registry, predicator: MemberPredicator)
+	local bitmask = buffer.create(self.bitmask_size)
+
+	for member, index in self.client_indexes do
+		if predicator(member) then
+			bitmasks.set(bitmask, index)
+		end
+	end
+
+	return bitmask
+end
+
+function registry.register_client(self: Registry, member: Client)
+	if self.client_indexes[member] then
+		return
+	end
+	if self.client_count >= self.max_clients then
+		error(`client limit of {self.max_clients} reached, raise MAX_CLIENTS to register more`)
+	end
+
+	local reused = table.remove(self.free_indexes)
+	local index: number
+	if reused then
+		index = reused
+	else
+		index = self.client_next_index
+		self.client_next_index += 1
+	end
+	self.client_indexes[member] = index
+	self.index_clients[index] = member
+	self.client_count += 1
+end
+
+function registry.unregister_client(self: Registry, member: Client)
+	local index = self.client_indexes[member]
+	if not index then
+		return
+	end
+
+	table.insert(self.free_indexes, index)
+	self.client_indexes[member] = nil
+	self.index_clients[index] = nil
+	self.client_count -= 1
+end
+
+local DEFAULT_MAX_CLIENTS = 128
+
+function registry.create(max_clients: number?): Registry
+	local self = {} :: Registry
+
+	local cap = max_clients or DEFAULT_MAX_CLIENTS
+	self.max_clients = cap
+	self.bitmask_size = bitmasks.get_buffer_size(cap)
+	self.client_indexes = {}
+	self.index_clients = {}
+	self.client_next_index = 0
+	self.client_count = 0
+	self.free_indexes = {}
+	self.client_aliases = {}
+
+	return setmetatable(self, registry) :: any
+end
+
+return registry

package/out/replecs/server/utils.luau

@@ -0,0 +1,20 @@
+type Set<T> = { [T]: boolean }
+
+local utils = {}
+
+function utils.is_include_filter(filter: Set<any>): boolean
+	for _, allow in filter do
+		return allow
+	end
+	return true
+end
+
+function utils.get_used_filter_type(filter: any)
+	if typeof(filter) == "table" then
+		return utils.is_include_filter(filter)
+	else
+		return true
+	end
+end
+
+return utils

package/out/replecs/shared.luau

@@ -0,0 +1,70 @@
+local types = require (script.Parent:WaitForChild('types'))
+local common = require (script.Parent:WaitForChild('common'))
+local customid = require (script.Parent:WaitForChild('customid'))
+
+type Component = common.Component
+type Entity = common.Entity
+type World = common.World
+
+local ECS_NAME = common.ecs_name
+
+local shared = {}
+
+local function create_shared_lookup<T>(lookup: { [string]: T }): types.SharedInfo<T>
+	local keys = {}
+	local indexes = {}
+	local members = {}
+
+	for name in lookup do
+		table.insert(keys, name)
+	end
+	table.sort(keys)
+
+	for index, name in keys do
+		local member = lookup[name]
+		members[member] = index
+		indexes[index] = member
+	end
+
+	return {
+		lookup = lookup,
+		keys = keys,
+		indexes = indexes,
+		members = members,
+	}
+end
+
+function shared.resolve_shared(
+	world: World,
+	components: types.Components,
+	registered_custom_ids: { [customid.CustomId]: boolean },
+	serdes: { [Component]: types.Serdes }
+): types.Shared
+	local shared = {} :: types.Shared
+
+	local components_lookup: { [string]: Entity } = table.clone(common.implicitly_shared)
+	local custom_ids_lookup = {}
+
+	for component, name in world:query(ECS_NAME):with(components.shared):iter() do
+		if components_lookup[name] then
+			common.log_error(`detected two components with the same {name} name: ({components_lookup[name]}, {component})`)
+		end
+		components_lookup[name] = component
+	end
+
+	for component in world:query(components.shared):without(ECS_NAME):iter() do
+		common.log_warn(`shared component: {component} has no name assigned.`)
+	end
+
+	for custom in registered_custom_ids do
+		custom_ids_lookup[custom.identifier] = custom
+	end
+
+	shared.serdes = serdes
+	shared.components = create_shared_lookup(components_lookup)
+	shared.custom_ids = create_shared_lookup(custom_ids_lookup) :: types.SharedInfo<customid.CustomId>
+
+	return shared
+end
+
+return shared

package/out/replecs/types.luau

@@ -1,23 +1,27 @@
 local customid = require (script.Parent:WaitForChild('customid'))
 local common = require (script.Parent:WaitForChild('common'))
 
-export type PlayerFilter = {
-	[Player]: boolean,
-}
-
-export type FunctionFilter = (player: Player) -> boolean
-export type AnyFilter = PlayerFilter | Player
-
 type Entity = common.Entity
 type World = common.World
 type Component<T = any> = common.Component<T>
 
+type Player = any
+
+export type FilterSet = {
+	[Player]: boolean,
+}
+export type FilterPlayer = Player
+export type FilterPredicator = (Player) -> boolean
+export type FilterAny = FilterPlayer | FilterSet | FilterPredicator
+export type FilterSimple = FilterPlayer | FilterSet
+
 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 },
@@ -34,17 +38,30 @@ export type Serdes<T = any> = {
 	deserialize: (buffer,...{ any }) -> T,
 }
 
+export type Preprocessor<B = any, A = any> = {
+	serialize: (B) -> A,
+	deserialize: (A) -> B,
+}
+
+export type DeltaSerializer<T = any, D = T> = {
+	snapshot: ((value: T) -> T)?,
+	delta: (old: T, curr: T) -> D,
+	apply: (curr: T, delta: D) -> T,
+}
+
 export type Components = {
 	shared: Entity,
 	Shared: Entity,
 	networked: Component<any?>,
-	Networked: Component<AnyFilter?>,
-	reliable: Component<AnyFilter?>,
-	Reliable: Component<AnyFilter?>,
-	unreliable: Component<AnyFilter?>,
-	Unreliable: Component<AnyFilter?>,
-	relation: Component<AnyFilter?>,
-	Relation: Component<AnyFilter?>,
+	Networked: Component<FilterAny?>,
+	reliable: Component<FilterAny?>,
+	Reliable: Component<FilterAny?>,
+	unreliable: Component<FilterAny?>,
+	Unreliable: Component<FilterAny?>,
+	once: Component<FilterAny?>,
+	Once: Component<FilterAny?>,
+	relation: Component<FilterAny?>,
+	Relation: Component<FilterAny?>,
 
 	serdes: Component<Serdes>,
 	Serdes: Component<Serdes>,
@@ -52,8 +69,6 @@ export type Components = {
 	Custom: Entity,
 	custom_handler: Component<(val: any) -> Entity?>,
 	CustomHandler: Component<(val: any) -> Entity?>,
-	global: Component<number>,
-	Global: Component<number>,
 	__alive_tracking__: Entity,
 }