@rbxts/replecs 0.3.1 → 0.4.0-rc.2

package/out/replecs/server/bitmasks.luau

@@ -0,0 +1,322 @@
+--!optimize 2
+
+type Bitmask = buffer
+
+local BITS_PER_ENTRY = 32
+local BYTES_PER_ENTRY = 4
+
+
+local function to_binary(n: number): string
+	local result = ""
+	while n > 0 do
+		result = (n % 2) .. result
+		n = math.floor(n / 2)
+	end
+	return string.rep("0", 32 - #result) .. result
+end
+
+
+local function bitmask_read_entry(bitmask: Bitmask, len: number, offset: number)
+	if offset >= len then
+		return 0
+	else
+		return buffer.readu32(bitmask, offset)
+	end
+end
+
+
+local function bitmasks_band(a: Bitmask, b: Bitmask, output: Bitmask)
+	local len_a = buffer.len(a)
+	local len_b = buffer.len(b)
+	local len_min = math.min(len_a, len_b)
+
+	for offset = 0, buffer.len(output) - BYTES_PER_ENTRY, BYTES_PER_ENTRY do
+		if offset >= len_min then
+			buffer.writeu32(output, offset, 0)
+		else
+			local a_val = buffer.readu32(a, offset)
+			local b_val = buffer.readu32(b, offset)
+			buffer.writeu32(output, offset, bit32.band(a_val, b_val))
+		end
+	end
+end
+
+
+local function bitmasks_bor(a: Bitmask, b: Bitmask, output: Bitmask)
+	local len_a = buffer.len(a)
+	local len_b = buffer.len(b)
+
+	for offset = 0, buffer.len(output) - BYTES_PER_ENTRY, BYTES_PER_ENTRY do
+		local a_val = if offset >= len_a then 0 else buffer.readu32(a, offset)
+		local b_val = if offset >= len_b then 0 else buffer.readu32(b, offset)
+		buffer.writeu32(output, offset, bit32.bor(a_val, b_val))
+	end
+end
+
+
+local function bitmasks_read_entry(bitmask: Bitmask, len: number, offset: number)
+	if offset >= len then
+		return 0
+	else
+		return buffer.readu32(bitmask, offset)
+	end
+end
+
+
+local function bitmasks_get_index(index: number): (number, number)
+	local entry_index = math.floor(index / BITS_PER_ENTRY)
+	local bit_position = index % BITS_PER_ENTRY
+	return entry_index, bit_position
+end
+
+
+local function bitmasks_set(bitmask: Bitmask, index: number)
+	local entry, offset = bitmasks_get_index(index)
+	local buffer_offset = entry * BYTES_PER_ENTRY
+	local len = buffer.len(bitmask)
+	if buffer_offset >= len then
+		return
+	end
+
+	local current = buffer.readu32(bitmask, buffer_offset)
+	local mask = bit32.lshift(1, offset)
+	buffer.writeu32(bitmask, buffer_offset, bit32.bor(current, mask))
+end
+
+
+local function bitmasks_reset(bitmask: Bitmask, index: number)
+	local entry, offset = bitmasks_get_index(index)
+	local buffer_offset = entry * BYTES_PER_ENTRY
+	local len = buffer.len(bitmask)
+	if buffer_offset >= len then
+		return
+	end
+
+	local current = buffer.readu32(bitmask, buffer_offset)
+	local mask = bit32.bnot(bit32.lshift(1, offset))
+	buffer.writeu32(bitmask, buffer_offset, bit32.band(current, mask))
+end
+
+
+local function bitmasks_test(bitmask: Bitmask, index: number): boolean
+	local entry, offset = bitmasks_get_index(index)
+	local buffer_offset = entry * BYTES_PER_ENTRY
+
+	local len = buffer.len(bitmask)
+	if buffer_offset >= len then
+		return false
+	end
+
+	local current = buffer.readu32(bitmask, buffer_offset)
+	local value = bit32.band(bit32.rshift(current, offset), 1)
+	return value == 1
+end
+
+
+local function bitmasks_exclude(base: Bitmask, exclude: Bitmask, output: Bitmask)
+	local len_base = buffer.len(base)
+	local len_exclude = buffer.len(exclude)
+
+	for offset = 0, buffer.len(output) - BYTES_PER_ENTRY, BYTES_PER_ENTRY do
+		local base_val = bitmasks_read_entry(base, len_base, offset)
+		local exclude_val = bitmasks_read_entry(exclude, len_exclude, offset)
+		buffer.writeu32(output, offset, bit32.band(base_val, bit32.bnot(exclude_val)))
+	end
+end
+
+
+
+local function bitmasks_load(source: Bitmask, target: Bitmask)
+	local source_len = buffer.len(source)
+	local target_len = buffer.len(target)
+
+	buffer.copy(target, 0, source, 0)
+	local difference = target_len - source_len
+	if difference > 0 then
+		buffer.fill(target, source_len, 0, difference)
+	end
+end
+
+
+
+local function bitmasks_clear(bitmask: Bitmask)
+	buffer.fill(bitmask, 0, 0)
+end
+
+local function bitmasks_clone(template: Bitmask, size: number?)
+	local buf_len = buffer.len(template)
+	local cloned = buffer.create((size and math.max(size, buf_len)) or buf_len)
+	buffer.copy(cloned, 0, template, 0)
+	return cloned
+end
+
+
+local function bitmask_hash(bitmask: Bitmask)
+	local highest_entry = -1
+	
+for i = buffer.len(bitmask) - BYTES_PER_ENTRY, 0, -BYTES_PER_ENTRY do
+		local value = buffer.readu32(bitmask, i)
+		if value ~= 0 then
+			highest_entry = i
+			break
+		end
+	end
+
+	if highest_entry == -1 then
+		return ""
+	end
+do		-- raw bytes as the key; trailing zero entries are trimmed so equal bit
+		-- sets hash the same regardless of buffer size
+		
+
+return buffer.readstring(bitmask, 0, highest_entry + BYTES_PER_ENTRY)
+end
+
+
+
+
+
+
+
+
+
+end
+
+
+
+
+local function bitmask_get_hole_mask(index: number): number
+	local _, bit_position = bitmasks_get_index(index)
+	return bit32.bnot(bit32.lshift(1, bit_position))
+end
+
+
+
+
+local function bitmask_punch_hole_mask(bitmask: Bitmask, mask: number, index: number)
+	local entry = math.floor(index / BITS_PER_ENTRY)
+	local buffer_offset = entry * BYTES_PER_ENTRY
+	if buffer_offset >= buffer.len(bitmask) then
+		return
+	end
+
+	local current = buffer.readu32(bitmask, buffer_offset)
+	buffer.writeu32(bitmask, buffer_offset, bit32.band(current, mask))
+end
+
+
+
+
+local function bitmask_iter_set(bitmask: Bitmask, callback: (index: number) -> ())
+	for offset = 0, buffer.len(bitmask) - BYTES_PER_ENTRY, BYTES_PER_ENTRY do
+		local word = buffer.readu32(bitmask, offset)
+		local base = offset * 8 -- byte offset * 8 = bit index of entry start
+
+		while word ~= 0 do
+			callback(base + bit32.countrz(word))
+			word = bit32.band(word, word - 1)
+		end
+	end
+end
+
+export type BitmaskDeltas = {
+	added: Bitmask,
+	removed: Bitmask,
+}
+
+
+local function load_bitmask_deltas(deltas: BitmaskDeltas)
+	buffer.fill(deltas.added, 0, 0)
+	buffer.fill(deltas.removed, 0, 0)
+end
+
+
+local function calculate_bitmask_deltas(last: Bitmask, target: Bitmask, output: BitmaskDeltas)
+	local len_last = buffer.len(last)
+	local len_target = buffer.len(target)
+	local added = output.added
+	local removed = output.removed
+
+	-- we asume the output have been loaded, this means it has been cleared
+	local len_added = buffer.len(added)
+	local len_removed = buffer.len(removed)
+
+	for offset = 0, math.max(len_added, len_removed) - BYTES_PER_ENTRY, BYTES_PER_ENTRY do
+		local last_val = bitmask_read_entry(last, len_last, offset)
+		local target_val = bitmask_read_entry(target, len_target, offset)
+
+		local added_delta = bit32.band(target_val, bit32.bnot(last_val))
+		local removed_delta = bit32.band(last_val, bit32.bnot(target_val))
+
+		buffer.writeu32(added, offset, added_delta)
+		buffer.writeu32(removed, offset, removed_delta)
+	end
+end
+
+
+local function bitmask_equals(a: Bitmask, b: Bitmask): boolean
+	local len_a = buffer.len(a)
+	local len_b = buffer.len(b)
+
+	for offset = 0, math.max(len_a, len_b) - BYTES_PER_ENTRY, BYTES_PER_ENTRY do
+		if bitmasks_read_entry(a, len_a, offset) ~= bitmasks_read_entry(b, len_b, offset) then
+			return false
+		end
+	end
+	return true
+end
+
+
+local function bitmask_is_empty(bitmask: Bitmask): boolean
+	for offset = 0, buffer.len(bitmask) - BYTES_PER_ENTRY, BYTES_PER_ENTRY do
+		if buffer.readu32(bitmask, offset) ~= 0 then
+			return false
+		end
+	end
+	return true
+end
+
+
+local function bitmask_get_buffer_size(bits: number)
+	return math.ceil(bits / BITS_PER_ENTRY) * BYTES_PER_ENTRY
+end
+
+
+
+
+local function bitmask_create_filled(bits: number): Bitmask
+	local size = bitmask_get_buffer_size(bits)
+	local bitmask = buffer.create(size)
+	buffer.fill(bitmask, 0, 0xFF)
+
+	local tail = bits % BITS_PER_ENTRY
+	if tail ~= 0 then
+		buffer.writeu32(bitmask, size - BYTES_PER_ENTRY, bit32.lshift(1, tail) - 1)
+	end
+	return bitmask
+end
+
+return {
+	band = bitmasks_band,
+	bor = bitmasks_bor,
+	read_entry = bitmasks_read_entry,
+	get_index = bitmasks_get_index,
+	set = bitmasks_set,
+	reset = bitmasks_reset,
+	test = bitmasks_test,
+	exclude = bitmasks_exclude,
+	iter_set = bitmask_iter_set,
+	load = bitmasks_load,
+	clear = bitmasks_clear,
+	clone = bitmasks_clone,
+	hash = bitmask_hash,
+	equals = bitmask_equals,
+	is_empty = bitmask_is_empty,
+	get_buffer_size = bitmask_get_buffer_size,
+	create_filled = bitmask_create_filled,
+	get_hole_mask = bitmask_get_hole_mask,
+	punch_hole_mask = bitmask_punch_hole_mask,
+
+	calculate_bitmask_deltas = calculate_bitmask_deltas,
+	load_bitmask_deltas = load_bitmask_deltas,
+}

package/out/replecs/server/filter_group.luau

@@ -0,0 +1,196 @@
+local types = require (script.Parent.Parent:WaitForChild('types'))
+local registry = require (script.Parent:WaitForChild('registry'))
+local bitmasks = require (script.Parent:WaitForChild('bitmasks'))
+local utils = require (script.Parent:WaitForChild('utils'))
+local common = require (script.Parent.Parent:WaitForChild('common'))
+
+type Bitmask = buffer
+
+type FilterSimple = types.FilterSimple
+
+type Set<T> = { [T]: boolean }
+type Map<K, V> = { [K]: V }
+type Array<T> = { T }
+
+type Listener = (Bitmask) -> ()
+
+type ListenerConnections = {
+	listeners: { Listener },
+	listeners_indexes: { [Listener]: number },
+}
+
+export type FilterMode = number
+
+export type FilterEntry = {
+	mode: FilterMode,
+	filter: FilterSimple,
+}
+
+export type FilterGroupClass = {
+	registry: registry.Registry,
+	parent: FilterGroup?,
+
+	derived: Set<FilterGroup>,
+	assigned_filter: FilterEntry?,
+	connected_listeners: ListenerConnections,
+}
+
+local FILTER_MODES = {
+	extend = 1,
+	exclude = 2,
+	include = 3,
+}
+
+local filter_group = {}
+filter_group.__index = filter_group
+
+export type FilterGroup = FilterGroupClass & typeof(filter_group)
+
+function filter_group.is_filter_group(value: any): boolean
+	return typeof(value) == "table" and getmetatable(value) == filter_group
+end
+
+local function fire_listeners(self: FilterGroup, bitmask: Bitmask)
+	for _, listener in self.connected_listeners.listeners do
+		listener(bitmask)
+	end
+end
+
+function filter_group.connect(self: FilterGroup, listener: Listener)
+	local connected = self.connected_listeners
+	local index = #connected.listeners + 1
+	connected.listeners[index] = listener
+	connected.listeners_indexes[listener] = index
+end
+
+function filter_group.disconnect(self: FilterGroup, listener: Listener)
+	local connected = self.connected_listeners
+	local index = connected.listeners_indexes[listener]
+	if not index then
+		return
+	end
+
+	local last_listener = table.remove(connected.listeners)
+	if last_listener and last_listener ~= listener then
+		connected.listeners[index] = last_listener
+		connected.listeners_indexes[last_listener] = index
+	end
+	connected.listeners_indexes[listener] = nil
+end
+
+local function create_filter_bitmask(self: FilterGroup, filter: FilterSimple): Bitmask
+	if typeof(filter) == "table" then
+		return self.registry:create_bitmask_from_set(filter)
+	else
+		return self.registry:create_bitmask_from_member(filter)
+	end
+end
+
+-- the filter bitmask is resolved from the raw filter here, at calculation
+-- time, so clients registered after the filter was assigned still resolve
+function filter_group.apply_filter(self: FilterGroup, bitmask: Bitmask)
+	local filter = self.assigned_filter
+	if not filter then
+		return
+	end
+
+	local filter_bitmask = create_filter_bitmask(self, filter.filter)
+
+	if filter.mode == FILTER_MODES.extend then
+		bitmasks.bor(bitmask, filter_bitmask, bitmask)
+	elseif filter.mode == FILTER_MODES.exclude then
+		bitmasks.exclude(bitmask, filter_bitmask, bitmask)
+	elseif filter.mode == FILTER_MODES.include then
+		bitmasks.band(bitmask, filter_bitmask, bitmask)
+	end
+end
+
+function filter_group.calculate_up(self: FilterGroup): Bitmask
+	local parent = self.parent
+	local bitmask: Bitmask
+	if parent then
+		bitmask = filter_group.calculate_up(parent)
+	else
+		bitmask = bitmasks.create_filled(self.registry.client_next_index)
+	end
+
+	filter_group.apply_filter(self, bitmask)
+	return bitmask
+end
+
+function filter_group.calculate_down(self: FilterGroup, parent_bitmask: Bitmask)
+	local bitmask = bitmasks.clone(parent_bitmask, bitmasks.get_buffer_size(self.registry.client_next_index))
+	filter_group.apply_filter(self, bitmask)
+
+	fire_listeners(self, bitmask)
+
+	for derived in self.derived do
+		filter_group.calculate_down(derived, bitmask)
+	end
+end
+
+local function recalculate_filter_group(group: FilterGroup)
+	local parent = group.parent
+
+	local parent_bitmask: Bitmask
+	if parent then
+		parent_bitmask = filter_group.calculate_up(parent)
+	else
+		parent_bitmask = bitmasks.create_filled(group.registry.client_next_index)
+	end
+
+	filter_group.calculate_down(group, parent_bitmask)
+end
+
+function filter_group.extend(self: FilterGroup, filter: FilterSimple)
+	if not utils.get_used_filter_type(filter) then
+		common.log_error "extend() only accepts include filters"
+	end
+
+	self.assigned_filter = {
+		mode = FILTER_MODES.extend,
+		filter = filter,
+	}
+	recalculate_filter_group(self)
+end
+
+function filter_group.filter(self: FilterGroup, filter: FilterSimple)
+	local mode = FILTER_MODES.exclude
+
+	if utils.get_used_filter_type(filter) then
+		mode = FILTER_MODES.include
+	end
+
+	self.assigned_filter = {
+		mode = mode,
+		filter = filter,
+	}
+	recalculate_filter_group(self)
+end
+
+function filter_group.create(client_registry: registry.Registry): FilterGroup
+	local self: FilterGroupClass = {
+		registry = client_registry,
+
+		parent = nil,
+		connected_listeners = {
+			listeners = {},
+			listeners_indexes = {},
+		},
+		derived = setmetatable({}, { __mode = "k" }) :: any,
+		assigned_filter = nil,
+	}
+
+	setmetatable(self, filter_group)
+	return self :: any
+end
+
+function filter_group.derive(self: FilterGroup): FilterGroup
+	local derived = filter_group.create(self.registry)
+	derived.parent = self
+
+	self.derived[derived] = true
+	return derived
+end
+
+return filter_group