@rbxts/replecs 0.3.1 → 0.4.0-rc.2

package/out/replecs/common.luau

@@ -109,7 +109,7 @@ local function WORLD_GET<T>(world: World, entity: Entity, id: Component<T>): T
 	return world:get(entity, id) :: T
 end
 
-local function WORLD_TARGET(world: World, entity: Entity, rel: Component, index: number?): jecs.Entity?
+local function WORLD_TARGET(world: World, entity: Entity, rel: Component, index: number?): Entity?
 	return world:target(entity, rel, index)
 end
 
@@ -131,8 +131,22 @@ end
 local PREREGISTER_COMPONENT = jecs.component
 local PREREGISTER_TAG = jecs.tag
 
-local function IS_COMPONENT(world: World, id: Component)
-	return not jecs.is_tag(world, id)
+local ECS_COMPONENT = jecs.Component
+
+-- jecs.is_tag misreports pairs that have not been used in the world yet, so
+-- component-ness is resolved by hand: a plain id is a component when it has
+-- jecs.Component; a pair takes its data from the relation, or from the
+-- target when the relation is a tag
+local function IS_COMPONENT(world: World, id: Component): boolean
+	if IS_PAIR(id) then
+		local relation = jecs.pair_first(world, id)
+		if world:has(relation, ECS_COMPONENT) then
+			return true
+		end
+		local target = jecs.pair_second(world, id)
+		return world:has(target, ECS_COMPONENT)
+	end
+	return world:has(id, ECS_COMPONENT)
 end
 
 local function HOOK_ADDED(world: World, id: Component, callback: (e: Entity, id: Component, value: any) -> ()): () -> ()

package/out/replecs/cursor.luau

@@ -0,0 +1,268 @@
+export type Cursor = {
+	offset: number,
+	buffer: buffer,
+}
+
+local cursor = {}
+
+function cursor.new(): Cursor
+	return {
+		buffer = buffer.create(100),
+		offset = 0,
+	}
+end
+
+function cursor.from(buf: buffer): Cursor
+	return {
+		buffer = buf,
+		offset = buffer.len(buf),
+	}
+end
+
+function cursor.from_offset(buf: buffer, offset: number): Cursor
+	return {
+		buffer = buf,
+		offset = offset,
+	}
+end
+
+function cursor.tryalloc(c: Cursor, bytes: number)
+	local buf = c.buffer
+	local offset = c.offset
+	local len = buffer.len(buf)
+
+	if len < offset + bytes then
+		local exponent = math.ceil(math.log((bytes + offset) / len, 1.5))
+		local new_len = math.floor(len * 1.5 ^ exponent)
+		if new_len < offset + bytes then
+			new_len = offset + bytes
+		end
+		local new = buffer.create(new_len)
+		buffer.copy(new, 0, buf, 0)
+		c.buffer = new
+	end
+end
+
+function cursor.write_buffer(c: Cursor, buf: buffer, start: number?, count: number?)
+	if start == nil and count == nil then
+		cursor.tryalloc(c, buffer.len(buf))
+		buffer.copy(c.buffer, c.offset, buf, 0, buffer.len(buf))
+		c.offset += buffer.len(buf)
+	else
+		local len = buffer.len(buf)
+		local available = len - (start or 0)
+		local write_count = count and math.min(available, count) or available
+
+		cursor.tryalloc(c, write_count)
+		buffer.copy(c.buffer, c.offset, buf, start or 0, write_count)
+		c.offset += write_count
+	end
+end
+
+function cursor.print(c: Cursor)
+	local bytes: { any } = { string.byte(buffer.tostring(c.buffer), 1, -1) }
+	local offset = 7
+	for i = 1, c.offset do
+		local byte = bytes[i] :: number
+		local digits = if byte == 0 then 1 else math.ceil(math.log10(1 + byte))
+		offset += digits + 1
+	end
+
+	local last_byte = bytes[c.offset + 1]
+	if last_byte then
+		local lastDigits = if last_byte == 0 then 1 else math.ceil(math.log10(1 + last_byte))
+		offset += lastDigits // 2
+	end
+	bytes[c.offset + 1] = `[{bytes[c.offset + 1] :: number}]` :: any
+
+	if #bytes == 0 or c.offset == buffer.len(c.buffer) then
+		table.insert(bytes, " ")
+	end
+
+	return `Pos: {c.offset} / {buffer.len(c.buffer)}\nBuf: \{ {table.concat(bytes, " ")} \}`
+end
+
+function cursor.writeu8(c: Cursor, value: number)
+	cursor.tryalloc(c, 1)
+	buffer.writeu8(c.buffer, c.offset, value)
+	c.offset += 1
+end
+
+function cursor.writeu16(c: Cursor, value: number)
+	cursor.tryalloc(c, 2)
+	buffer.writeu16(c.buffer, c.offset, value)
+	c.offset += 2
+end
+function cursor.writeu24(c: Cursor, value: number)
+	cursor.tryalloc(c, 3)
+	buffer.writeu8(c.buffer, c.offset, value)
+	buffer.writeu16(c.buffer, c.offset + 1, value // 256)
+	c.offset += 3
+end
+
+function cursor.writeu32(c: Cursor, value: number)
+	cursor.tryalloc(c, 4)
+	buffer.writeu32(c.buffer, c.offset, value :: any)
+	c.offset += 4
+end
+
+function cursor.writeu40(c: Cursor, value: number)
+	cursor.tryalloc(c, 5)
+	buffer.writeu8(c.buffer, c.offset, value)
+	buffer.writeu32(c.buffer, c.offset + 1, value // 256)
+	c.offset += 5
+end
+
+function cursor.writei8(c: Cursor, value: number)
+	cursor.tryalloc(c, 1)
+	buffer.writei8(c.buffer, c.offset, value)
+	c.offset += 1
+end
+
+function cursor.writei16(c: Cursor, value: number)
+	cursor.tryalloc(c, 2)
+	buffer.writei16(c.buffer, c.offset, value)
+	c.offset += 2
+end
+
+function cursor.writei32(c: Cursor, value: number)
+	cursor.tryalloc(c, 4)
+	buffer.writeu32(c.buffer, c.offset, value :: any)
+	c.offset += 4
+end
+
+function cursor.write_span(c: Cursor, value: number, span: number)
+	if span <= 0xFF then
+		cursor.writeu8(c, value)
+	elseif span <= 0xFFFF then
+		cursor.writeu16(c, value)
+	elseif span <= 0xFFFFFF then
+		cursor.writeu24(c, value)
+	elseif span <= 0xFFFFFFFF then
+		cursor.writeu32(c, value)
+	else
+		error "span too large"
+	end
+end
+
+function cursor.read_buffer(c: Cursor, len: number)
+	local retrieved = buffer.create(len)
+	buffer.copy(retrieved, 0, c.buffer, c.offset - len, len)
+	c.offset -= len
+	return retrieved
+end
+
+function cursor.readu8(c: Cursor): number
+	c.offset -= 1
+	return buffer.readu8(c.buffer, c.offset)
+end
+
+function cursor.readu16(c: Cursor): number
+	c.offset -= 2
+	return buffer.readu16(c.buffer, c.offset)
+end
+
+function cursor.readu24(c: Cursor): number
+	c.offset -= 3
+	local one = buffer.readu8(c.buffer, c.offset)
+	local two = buffer.readu16(c.buffer, c.offset + 1)
+	return one + two * 256
+end
+
+function cursor.readu32(c: Cursor): number
+	c.offset -= 4
+	return buffer.readu32(c.buffer, c.offset)
+end
+
+function cursor.readu40(c: Cursor): number
+	c.offset -= 5
+	local one = buffer.readu8(c.buffer, c.offset)
+	local two = buffer.readu32(c.buffer, c.offset + 1)
+	return one + two * 256
+end
+
+function cursor.read_span(c: Cursor, span: number): number
+	if span <= 0xFF then
+		return cursor.readu8(c)
+	elseif span <= 0xFFFF then
+		return cursor.readu16(c)
+	elseif span <= 0xFFFFFF then
+		return cursor.readu24(c)
+	elseif span <= 0xFFFFFFFF then
+		return cursor.readu32(c)
+	else
+		error "span too large"
+	end
+end
+
+function cursor.readi8(c: Cursor): number
+	c.offset -= 1
+	return buffer.readi8(c.buffer, c.offset)
+end
+
+function cursor.readi16(c: Cursor): number
+	c.offset -= 2
+	return buffer.readi16(c.buffer, c.offset)
+end
+function cursor.readi32(c: Cursor): number
+	c.offset -= 4
+	return buffer.readi32(c.buffer, c.offset)
+end
+
+function cursor.write_vlq(c: Cursor, value: number)
+	local x0 = value // 1% 128
+	local x1 = value // 128% 128
+	local x2 = value // 16384% 128
+	local x3 = value // 2097152% 128
+
+	if x3 ~= 0 then
+		cursor.tryalloc(c, 4)
+		cursor.writeu32(c, x0 * 16777216+ x1 * 65536+ x2 * 256 + x3 + 128)
+	elseif x2 ~= 0 then
+		cursor.tryalloc(c, 3)
+		cursor.writeu24(c, x0 * 65536+ x1 * 256 + x2 + 128)
+	elseif x1 ~= 0 then
+		cursor.tryalloc(c, 2)
+		cursor.writeu16(c, x0 * 256 + x1 + 128)
+	else
+		cursor.tryalloc(c, 1)
+		cursor.writeu8(c, x0 + 128)
+	end
+end
+
+function cursor.read_vlq(c: Cursor): number
+	local b = cursor.readu8(c)
+	if b >= 128 then
+		return b - 128
+	end
+	local x = b
+
+	b = cursor.readu8(c)
+	if b >= 128 then
+		return x + (b - 128) * 128
+	end
+	x += b * 128
+
+	b = cursor.readu8(c)
+	if b >= 128 then
+		return x + (b - 128) * 16384	
+end
+	x += b * 16384
+	
+b = cursor.readu8(c)
+	if b >= 128 then
+		return x + (b - 128) * 2097152	
+end
+	x += b * 2097152
+	
+error "vlq length too large"
+end
+
+function cursor.close(c: Cursor): buffer
+	local final = buffer.create(c.offset)
+	buffer.copy(final, 0, c.buffer, 0, c.offset)
+	c.buffer = final
+	return final
+end
+
+return cursor

package/out/replecs/handshake.luau

@@ -0,0 +1,108 @@
+local types = require (script.Parent:WaitForChild('types'))
+local common = require (script.Parent:WaitForChild('common'))
+
+type Component = common.Component
+type Entity = common.Entity
+type World = common.World
+
+local handshake = {}
+
+function handshake.generate_handshake(shared: types.Shared): types.HandshakeInfo
+	local component_to_name: { [Entity]: string } = {}
+	local handshake: types.HandshakeInfo = {
+		components = {},
+		custom_ids = {},
+		serdes = {},
+	}
+
+	for component_name, component in shared.components.lookup do
+		handshake.components[component_name] = true
+		component_to_name[component] = component_name
+	end
+
+	for custom_id in shared.custom_ids.lookup do
+		handshake.custom_ids[custom_id] = true
+	end
+
+	for component, serdes in shared.serdes do
+		local name = component_to_name[component]
+		if not name then
+			continue
+		end
+
+		handshake.serdes[name] = {
+			includes_variants = serdes.includes_variants,
+			bytespan = serdes.bytespan,
+		}
+	end
+
+	return handshake
+end
+
+function handshake.verify_handshake(
+	shared: types.Shared,
+	handshake: types.HandshakeInfo,
+	handshake_side: string,
+	verify_side: string
+): (boolean, string?)
+	local component_to_name: { [Entity]: string } = {}
+
+	for component_name in handshake.components do
+		if not shared.components.lookup[component_name] then
+			return false, `missing shared component "{component_name}" in {verify_side}`
+		end
+	end
+	for component_name, component in shared.components.lookup do
+		if not handshake.components[component_name] then
+			return false, `missing shared component "{component_name}" in {handshake_side}`
+		end
+		component_to_name[component] = component_name
+	end
+
+	for custom_id in handshake.custom_ids do
+		if not shared.custom_ids.lookup[custom_id] then
+			return false, `missing custom id "{custom_id}" in {verify_side}`
+		end
+	end
+	for custom_id in shared.custom_ids.lookup do
+		if not handshake.custom_ids[custom_id] then
+			return false, `missing custom id "{custom_id}" in {handshake_side}`
+		end
+	end
+
+	for component_name, serdes_info in handshake.serdes do
+		local component = shared.components.lookup[component_name]
+		if not component then
+			common.log_warn(`{handshake_side} registered a serdes for "{component_name}" that {verify_side} doesn't have`)
+			continue
+		end
+
+		local serdes = shared.serdes[component]
+		if not serdes then
+			return false, `missing serdes for component "{component_name}" in {verify_side}`
+		end
+
+		if (serdes_info.includes_variants or false) ~= (serdes.includes_variants or false) then
+			return false,
+				`mismatched includes_variants for component "{component_name}": ({serdes_info.includes_variants} ~= {serdes.includes_variants})`
+		end
+		if serdes_info.bytespan ~= serdes.bytespan then
+			return false,
+				`mismatched bytespan for component "{component_name}": ({serdes_info.bytespan} ~= {serdes.bytespan})`
+		end
+	end
+	for component in shared.serdes do
+		local component_name = component_to_name[component]
+		if not component_name then
+			continue
+		end
+
+		if not handshake.serdes[component_name] then
+			common.log_warn(`{verify_side} registered a serdes for "{component_name}" that {handshake_side} doesn't have`)
+		end
+	end
+
+	return true, nil
+end
+
+return handshake

package/out/replecs/init.luau

@@ -30,11 +30,17 @@ export type ReplecsLib = {
 
 	set_serdes: <T>(self: ReplecsLib, id: Component<T>, serdes: types.Serdes<T>) -> (),
 	remove_serdes: (self: ReplecsLib, id: Component) -> (),
+	set_preprocessor: <B, A>(self: ReplecsLib, id: Component<B>, preprocessor: types.Preprocessor<B, A>) -> (),
+	remove_preprocessor: (self: ReplecsLib, id: Component) -> (),
+	set_delta_serializer: <T, D>(self: ReplecsLib, id: Component<T>, delta: types.DeltaSerializer<T, D>) -> (),
+	remove_delta_serializer: (self: ReplecsLib, id: Component) -> (),
 }
 
 type Replecs = types.Components & {
 	__index: any,
 	VERSION: string,
+	MAX_CLIENTS: number,
+
 	create: (world: World?) -> ReplecsLib,
 
 	create_server: (world: World?) -> Server,
@@ -44,6 +50,7 @@ type Replecs = types.Components & {
 
 local replecs = {}
 replecs.VERSION = VERSION
+replecs.MAX_CLIENTS = 128
 replecs.__index = replecs
 
 local PREREGISTRATION = common.preregistration
@@ -54,13 +61,12 @@ if PREREGISTRATION then
 	utils.add_component_names(components, common.add_preregistered_name)
 
 	jecs.meta(components.custom, jecs.Exclusive)
-	jecs.meta(components.global, jecs.Exclusive)
 end
 
-local COMPONENTS = if PREREGISTRATION then replecs :: Replecs else nil
+local COMPONENTS: Replecs = if PREREGISTRATION then replecs else nil :: any
 
 function replecs.create_server(world: World?): Server
-	return server.create(world, COMPONENTS)
+	return server.create(world, COMPONENTS, replecs.MAX_CLIENTS)
 end
 
 function replecs.create_client(world: World?): Client
@@ -68,25 +74,27 @@ function replecs.create_client(world: World?): Client
 end
 
 function replecs.create(world: World?): ReplecsLib
-	assert(game, "This is a Roblox specific function")
+	assert(
+		game,
+		"replecs.create() is only for roblox, call create_client or create_server manually depending on your setup"
+	)
+
 	local RunService = game:GetService "RunService"
 	local self = {} :: ReplecsLib
 
-	if COMPONENTS then
-		self.components = COMPONENTS
-	elseif world then
-		self.components = utils.create_components(utils.tag_factory(world), utils.component_factory(world))
-		utils.add_component_names(self.components, function(component, name)
-			common.add_name(world, component, name)
-		end)
-	end
+	-- without preregistration the components come from the world: shared by
+	-- both sides when it is known here, else created by whichever inits first
+	local components = COMPONENTS or (if world then utils.create_world_components(world) else nil) :: any
 
 	if RunService:IsServer() then
-		self.server = server.create(world, self.components)
+		self.server = server.create(world, components, replecs.MAX_CLIENTS)
+		components = self.server.components
 	end
 	if RunService:IsClient() then
-		self.client = client.create(world, self.components)
+		self.client = client.create(world, components)
+		components = self.client.components
 	end
+	self.components = components
 
 	return setmetatable(self, replecs) :: any
 end
@@ -131,4 +139,40 @@ function replecs.remove_serdes(lib: ReplecsLib, id: Component)
 	end
 end
 
-return replecs :: Replecs
+function replecs.set_preprocessor(lib: ReplecsLib, id: Component, preprocessor: types.Preprocessor)
+	if lib.server then
+		lib.server:set_preprocessor(id, preprocessor)
+	end
+	if lib.client then
+		lib.client:set_preprocessor(id, preprocessor)
+	end
+end
+
+function replecs.remove_preprocessor(lib: ReplecsLib, id: Component)
+	if lib.server then
+		lib.server:remove_preprocessor(id)
+	end
+	if lib.client then
+		lib.client:remove_preprocessor(id)
+	end
+end
+
+function replecs.set_delta_serializer(lib: ReplecsLib, id: Component, delta_serializer: types.DeltaSerializer)
+	if lib.server then
+		lib.server:set_delta_serializer(id, delta_serializer)
+	end
+	if lib.client then
+		lib.client:set_delta_serializer(id, delta_serializer)
+	end
+end
+
+function replecs.remove_delta_serializer(lib: ReplecsLib, id: Component)
+	if lib.server then
+		lib.server:remove_delta_serializer(id)
+	end
+	if lib.client then
+		lib.client:remove_delta_serializer(id)
+	end
+end
+
+return (replecs :: any) :: Replecs