cluaupp 0.1.0

package/runtime/Chrono/_impl/Server/EntityGrid.luau

@@ -0,0 +1,299 @@
+--!native
+const Players = game:GetService("Players")
+
+const RunService = game:GetService("RunService")
+
+const Events = require(script.Parent.Parent.Shared.Events)
+const Config = require(script.Parent.Parent.Shared.Config)
+const ReplicationRules = require(script.Parent.Parent.Shared.ReplicationRules)
+const Stats = require(script.Parent.Parent.Shared.Stats)
+--[[
+	We just need to track entities with players near them
+
+	Track how far an entity is from a player
+	Fast query to get entities near a player
+	Far away entities could be checked less frequently
+
+	Ideas:
+	   1. give each player their own hashgird that stores other npcs
+	      - expensive so no
+	   2. idk-
+
+	cause when we do like um
+	for i,entity in queryEntitiesNear(location,100) -- this range is constant
+
+	but for far away entities we have to query again
+
+	maybe have two grids, one for close and one for far?
+	actually maybe just do
+   player:{
+		closeEntities = {},
+		farEntities = {},
+   }
+	changed to
+	player:{
+		normalEntities = {},
+		halfTick = {},
+		lowTick = {},
+   }
+]]
+for id, entity in { "ALL_ENTITIES" } do
+	--[[
+	--we could now give entities a proxy of how far they are for removal
+	--we could do
+		EntityConfig: {
+			Normal: 100,
+			HalfTick: 200,
+			LowTick: 300,
+			--don't need a removal one since we can just not replicate it
+		}
+	--loop thru players and get range
+	--insert into the players close and far table
+
+
+	-- Changed it so the ticker system keeps track of it now
+	]]
+end
+--[[
+	-- the old has grid had a system where it was
+	local UPDATE_INTERVAL = 2
+	so there really wasn't a point to query again until it updated
+	but ig we still need to check for when an npc was removed from proxy
+	could create another table to store removed entities
+
+]]
+
+const Shared = script.Parent.Parent.Shared
+const Types = require(Shared.Types)
+const Holder = require(Shared.Holder)
+const Ticker = require(Shared.Ticker)
+const Entity = require(Shared.Entity)
+const Signal = require(Shared.Signal)
+
+const SetTickMode = Entity._SetTickMode
+
+type Entity = Types.Entity
+
+local UPDATE_INTERVAL = 0.1
+local MAX_TIME_PER_UPDATE = 0.0005
+
+local lastUpdate = 0
+
+local FULL_TICKED = 0
+local HALF_TICKED = 0
+local UN_TICKED = 0
+
+type PlayerEntityHolder = Types.PlayerEntityHolder
+
+const entities = Holder.idMap
+const playerTablePositionPair: { [PlayerEntityHolder]: vector } = {}
+const playerToHolder: { [Player]: PlayerEntityHolder } = {}
+
+const function Check(entity: Entity)
+	const part = Entity.GetPrimaryPart(entity)
+	const cframe = part and part.CFrame or entity.latestCFrame
+	if not cframe or entity.destroyed then
+		return
+	end
+	if entity.id < 1 then
+		warn(entity, " has invalid id, cannot check for proximity")
+		return
+	end
+	const position: vector = cframe.Position :: any
+	const entityConfig = entity.entityConfig
+	local hasNormalTickers = false
+	local hasHalfTickers = false
+	const halfTickDistance = entityConfig.HALF_TICK_DISTANCE or math.huge
+	const normalTickDistance = entityConfig.NORMAL_TICK_DISTANCE or math.huge
+	const networkOwner = entity.networkOwner
+	const ownedHolder = networkOwner and playerToHolder[networkOwner]
+
+	const isLocked = entity._lockedCFReplication
+	const isNotNative = isLocked or entity.modelReplicationMode ~= "NATIVE"
+	for holder, playerPos in playerTablePositionPair do
+		const viewer = holder.PLAYER
+		const allowed = ReplicationRules.Allows(entity, viewer)
+		if not allowed then
+			continue
+		end
+
+		const distance = vector.magnitude(position - playerPos)
+
+		if distance > halfTickDistance and isNotNative then
+			if holder == ownedHolder then
+				table.insert(holder._TEMP_NORMAL, entity)
+			end
+			continue
+		end
+
+		if distance <= normalTickDistance then
+			hasNormalTickers = true
+			table.insert(holder._TEMP_NORMAL, entity)
+		else
+			hasHalfTickers = true
+			table.insert(holder._TEMP_HALF, entity)
+		end
+	end
+
+	const configTicker = entityConfig.TICKER
+	if not configTicker then
+		return
+	end
+
+	const currentTicker = entity._ticker
+	if hasHalfTickers and not hasNormalTickers then
+		if entity.isHalfTicked == false then
+			--warn("Entity is now half ticked", entity.id)
+		end
+		SetTickMode(entity, true)
+		HALF_TICKED += 1
+	elseif hasNormalTickers then
+		if entity.isHalfTicked then
+			--warn("Entity is normal ticked", entity.id)
+		end
+		SetTickMode(entity, false)
+		FULL_TICKED += 1
+	else
+		UN_TICKED += 1
+	end
+	if (hasNormalTickers or hasHalfTickers) and entity._ticker ~= configTicker then
+		Ticker.move(entity, configTicker)
+		--warn("Adding entity to ticker", entity.id)
+	elseif not (hasNormalTickers or hasHalfTickers) and currentTicker then
+		SetTickMode(entity, nil)
+		--warn("Removing entity from ticker", entity.id,currentTicker)
+		Ticker.Remove(currentTicker, entity)
+	end
+end
+
+local yielded: thread? = nil
+local totalTime = 0
+const function DoLoop()
+	totalTime = 0
+	FULL_TICKED = 0
+	HALF_TICKED = 0
+	UN_TICKED = 0
+	for holder, _ in playerTablePositionPair do
+		table.clear(holder._TEMP_HALF)
+		table.clear(holder._TEMP_NORMAL)
+	end
+	debug.profilebegin("EntityGrid.Update")
+	local count = 0
+	local start = os.clock()
+	local sections = 1
+	for _, entity in entities do
+		debug.profilebegin(`Check One`)
+		Check(entity)
+		count += 1
+		debug.profileend()
+		if os.clock() - start > MAX_TIME_PER_UPDATE then
+			sections += 1
+			debug.profileend()
+			totalTime += os.clock() - start
+			yielded = coroutine.running()
+			coroutine.yield()
+			yielded = nil
+			start = os.clock()
+			debug.profilebegin("EntityGrid.ResumeUpdate")
+		end
+	end
+	debug.profileend()
+	totalTime += os.clock() - start
+	Stats.SERVER.GRID_UPDATE_SECTIONS = sections
+	Stats.SERVER.ENTITY_GRID_UPDATE_TIME_MS = totalTime * 1000
+	Stats.SERVER.NUMBER_OF_ENTITIES = count
+	Stats.SERVER.ENTITIES_FULL_TICKED = FULL_TICKED
+	Stats.SERVER.ENTITIES_HALF_TICKED = HALF_TICKED
+	Stats.SERVER.NON_TICKED = UN_TICKED
+
+	local debugPlayers = {}
+
+	for _, holder in playerToHolder do
+		const tempNormal = holder._TEMP_NORMAL
+		const tempHalf = holder._TEMP_HALF
+		table.clear(holder.HALF)
+		table.clear(holder.NORMAL)
+		debugPlayers[holder.PLAYER.Name] = {
+			HALF = {},
+			NORMAL = {},
+		}
+		for _, entity in tempNormal do
+			table.insert(debugPlayers[holder.PLAYER.Name].NORMAL, entity.id)
+			table.insert(holder.NORMAL, entity)
+		end
+		for _, entity in tempHalf do
+			table.insert(debugPlayers[holder.PLAYER.Name].HALF, entity.id)
+			table.insert(holder.HALF, entity)
+		end
+	end
+	Stats.SERVER.GRID_STATS = debugPlayers
+end
+
+-- this might be able to be optimized more later
+const function Update()
+	if yielded then
+		task.spawn(yielded)
+		return
+	end
+	if os.clock() - lastUpdate < UPDATE_INTERVAL then
+		return
+	end
+	UPDATE_INTERVAL = Config._GetConfig("GRID_UPDATE_INTERVAL") or UPDATE_INTERVAL
+	MAX_TIME_PER_UPDATE = Config._GetConfig("GRID_MAX_UPDATE_TIME") or MAX_TIME_PER_UPDATE
+
+	lastUpdate = os.clock()
+	task.spawn(DoLoop)
+end
+
+const function UpdatePlayerPosition(player: Player, position: vector)
+	const holder = playerToHolder[player]
+	if not holder then
+		return
+	end
+	playerTablePositionPair[holder] = position
+end
+
+const function GetEntityHolder(Player: Player): PlayerEntityHolder?
+	return playerToHolder[Player]
+end
+
+const function PlayerAdded(player: Player)
+	if playerToHolder[player] then
+		return
+	end
+	const t = {
+		PLAYER = player,
+		HALF = {},
+		NORMAL = {},
+		REPLICATED = {},
+		_TEMP_HALF = {},
+		_TEMP_NORMAL = {},
+		EntityAdded = Signal.new(),
+		EntityRemoving = Signal.new(),
+	}
+	playerToHolder[player] = t
+	playerTablePositionPair[t] = vector.zero
+
+	Events._Signals.PlayerLoaded:Fire(player)
+end
+if RunService:IsServer() then
+	Shared.Remotes.ClientLoaded.OnServerEvent:Connect(PlayerAdded)
+
+	Players.PlayerRemoving:Connect(function(player: Player)
+		const holder = playerToHolder[player]
+		if not holder then
+			return
+		end
+		holder.EntityAdded:DisconnectAll()
+		holder.EntityRemoving:DisconnectAll()
+		playerTablePositionPair[holder] = nil
+		playerToHolder[player] = nil
+	end)
+end
+-- Players.PlayerAdded:Connect(PlayerAdded)
+
+return {
+	Update = Update,
+	UpdatePlayerPosition = UpdatePlayerPosition,
+	GetEntityHolder = GetEntityHolder,
+}

package/runtime/Chrono/_impl/Server/Player.luau

@@ -0,0 +1,141 @@
+--!native
+const Players = game:GetService("Players")
+
+const RunService = game:GetService("RunService")
+
+const Warn = require(script.Parent.Parent.Shared.Warn)
+const Config = require(script.Parent.Parent.Shared.Config)
+const Entity = require(script.Parent.Parent.Shared.Entity)
+const Holder = require(script.Parent.Parent.Shared.Holder)
+const Types = require(script.Parent.Parent.Shared.Types)
+
+const playerEntities = Holder._playerChars
+
+const function RegisterPlayer(
+	player: Player,
+	character: Model,
+	configuration: {
+		config: string?,
+		modelRepMode: Types.MODEL_REPLICATION_MODE?,
+	}
+): Types.Entity
+	const entity = playerEntities[player]
+
+	if entity then
+		Entity.Destroy(entity)
+	end
+
+	const config = configuration.config or "PLAYER"
+	local modelRepMode: Types.MODEL_REPLICATION_MODE? = configuration.modelRepMode
+	const configData = Config._EntityConfigs[config] or {} :: any
+	modelRepMode = modelRepMode or configData.MODEL_REPLICATION_MODE
+	character.Archivable = true
+
+	const humanoid = character:FindFirstChildWhichIsA("Humanoid")
+	const hrp = character:FindFirstChild("HumanoidRootPart")
+	if humanoid and hrp then
+		const rigType = humanoid.RigType
+		if rigType == Enum.HumanoidRigType.R6 and character.PrimaryPart == character:FindFirstChild("Head") then
+			Config.SetModelPrimaryForChrono(character, "HumanoidRootPart")
+		end
+	end
+
+	const newEntity = Entity.new(config, character, modelRepMode :: any)
+
+	Holder.SetAsCharacter(player, newEntity)
+	Entity.SetNetworkOwner(newEntity, player)
+
+	-- task.delay(7, function()
+	-- 	Entity.SetModel(newEntity, character, "NATIVE", true)
+	-- 	task.wait(5)
+	-- 	Entity.SetModel(newEntity, character, "CUSTOM", true)
+	-- end)
+
+	return newEntity
+end
+
+const function UnregisterPlayer(player: Player)
+	const entity = playerEntities[player]
+	if entity then
+		Entity.Destroy(entity)
+	end
+end
+
+const function OnCharacterAdded(character: Model, player: Player)
+	task.wait(0.1)
+	RegisterPlayer(player, character, {
+		config = "PLAYER",
+	})
+end
+
+const function OnPlayerAdded(player: Player)
+	const connection = player.CharacterAdded:Connect(function(character: Model)
+		OnCharacterAdded(character, player)
+	end)
+	if player.Character then
+		OnCharacterAdded(player.Character, player)
+	end
+	local connection2
+	connection2 = player.AncestryChanged:Connect(function()
+		if not player:IsDescendantOf(game) then
+			connection:Disconnect()
+			connection2:Disconnect()
+		end
+	end)
+end
+
+Config._WaitForLock(function()
+	if not RunService:IsServer() then
+		return
+	end
+	if Config._GetConfig("PLAYER_REPLICATION") ~= "AUTOMATIC" then
+		Warn.low("automatic player replication is disabled")
+		return
+	end
+	const deathRemote = script.Parent.Parent.Shared.Remotes.Death
+	const ReplicateMode: "NONE" | "PLAYER_ENTITIES" | "PLAYER_CHARACTERS" = Config._GetConfig("REPLICATE_DEATHS")
+	deathRemote.OnServerEvent:Connect(function(plr, id)
+		if ReplicateMode == "NONE" then
+			return
+		end
+		const entity = Holder.GetEntityFromId(id)
+		if not entity then
+			return
+		end
+
+		if entity.networkOwner ~= plr then
+			return
+		end
+		if ReplicateMode == "PLAYER_CHARACTERS" and not entity._player then
+			return
+		end
+
+		const model = entity.model
+		if model then
+			const humanoid: Humanoid? = model:FindFirstChildWhichIsA("Humanoid")
+			task.wait()
+			if humanoid and humanoid:GetState() ~= Enum.HumanoidStateType.Dead then
+				humanoid.Health = 0
+				task.delay(0, function()
+					if humanoid:GetState() ~= Enum.HumanoidStateType.Dead then
+						humanoid.Health = 0
+						humanoid.Health = 10
+						humanoid.Health = 0
+					end
+				end)
+			end
+		end
+		deathRemote:FireAllClients(id)
+	end)
+	Players.PlayerAdded:Connect(OnPlayerAdded)
+	Players.PlayerRemoving:Connect(UnregisterPlayer)
+
+	for _, player in Players:GetPlayers() do
+		OnPlayerAdded(player)
+	end
+end)
+
+return {
+	RegisterPlayer = RegisterPlayer,
+	UnregisterPlayer = UnregisterPlayer,
+}

package/runtime/Chrono/_impl/Server/Receiver.luau

@@ -0,0 +1,287 @@
+const RunService = game:GetService("RunService")
+const Players = game:GetService("Players")
+const Receiver = {}
+
+const MiddleMans = {}
+local SortedMiddleMans = {}
+const Shared = script.Parent.Parent.Shared
+const Ticker = require(Shared.Ticker)
+const InterpolationMath = require(Shared.InterpolationMath)
+const Warn = require(Shared.Warn)
+const ServerClock = require(script.Parent.ServerClock)
+const Types = require(Shared.Types)
+const Holder = require(Shared.Holder)
+const Entity = require(Shared.Entity)
+const Config = require(Shared.Config)
+const ClockUnwrap = require(Shared.ClockUnwrap)
+const Stats = require(Shared.Stats).SERVER
+
+const ClientClockWrap: ClockUnwrap.Store = {}
+local BASE_MAX_TOTAL_BYTES_PER_FRAME_PER_PLAYER = 300
+
+Config._WaitForLock(function()
+	BASE_MAX_TOTAL_BYTES_PER_FRAME_PER_PLAYER = Config._GetConfig("MAX_TOTAL_BYTES_PER_FRAME_PER_PLAYER")
+end)
+
+local BytesReceived = 0
+
+const UnreliableEvent = Shared.Remotes.Replicate
+const SafeReplicateEvent = Shared.Remotes.SafeReplicate
+
+const FULL_BYTES = 4 * 3 + 2 * 3
+const YAW_BYTES = 4 * 3 + 2
+const BASE_TELEPORT_TIME_THRESHOLD = 0.5
+
+const function FireMiddleMans(player: Player, entity: Types.Entity, cframe: CFrame, arriveTime: number): boolean
+	if #SortedMiddleMans == 0 then
+		return false
+	end
+	debug.profilebegin("FireMiddleMans")
+	for _, mmData: any in SortedMiddleMans do
+		const block = mmData.func(player, entity, cframe, arriveTime)
+		if block then
+			return true
+		end
+	end
+	debug.profileend()
+	return false
+end
+const function UnmapRotation(x: number): number
+	return (x / 65535) * (2 * math.pi) - math.pi
+end
+const function DeserializeFull(b: buffer, index: number): CFrame
+	const x = buffer.readf32(b, index)
+	index += 4
+	const y = buffer.readf32(b, index)
+	index += 4
+	const z = buffer.readf32(b, index)
+	index += 4
+	const rx = UnmapRotation(buffer.readu16(b, index))
+	index += 2
+	const ry = UnmapRotation(buffer.readu16(b, index))
+	index += 2
+	const rz = UnmapRotation(buffer.readu16(b, index))
+	index += 2
+	return CFrame.new(x, y, z) * CFrame.fromOrientation(rx, ry, rz)
+end
+
+const function DeserializeYaw(b: buffer, index: number): CFrame
+	const x = buffer.readf32(b, index)
+	index += 4
+	const y = buffer.readf32(b, index)
+	index += 4
+	const z = buffer.readf32(b, index)
+	index += 4
+	const ry = UnmapRotation(buffer.readu16(b, index))
+	index += 2
+	return CFrame.new(x, y, z) * CFrame.fromOrientation(0, ry, 0)
+end
+
+const function DeserializeEntityPacket(b: buffer, index: number): (number, CFrame, number, boolean)
+	const id = buffer.readu16(b, index)
+	index += 2
+	const packed = buffer.readu8(b, index)
+	index += 1
+	const isFull = bit32.band(packed, 1) == 1
+	const isTeleport = bit32.band(packed, 4) == 4
+
+	local cframe: CFrame
+	if isFull then
+		cframe = DeserializeFull(b, index)
+		index += FULL_BYTES
+	else
+		cframe = DeserializeYaw(b, index)
+		index += YAW_BYTES
+	end
+
+	return id, cframe, index, isTeleport
+end
+
+const function CalculateMaxThroughputForPlayer(player: Player): number
+	local numberOfEntities = 0
+	for _ in Holder._clientOwned[player] or {} do
+		numberOfEntities += 1
+	end
+	return BASE_MAX_TOTAL_BYTES_PER_FRAME_PER_PLAYER + numberOfEntities * (FULL_BYTES + 3)
+end
+
+const function HandleEntity(
+	player: Player,
+	id: number,
+	serverClock: number,
+	clientClock: number,
+	cframe: CFrame,
+	copyB: buffer,
+	isTeleport: boolean
+)
+	const entity = Holder.GetEntityFromId(id)
+	if not entity or entity.networkOwner ~= player then
+		return
+	end
+
+	const teleportTime = entity._teleport
+	const ping = math.max(player:GetNetworkPing(), 0) + 0.05
+
+	const withinTeleportThreshold = teleportTime and os.clock() - teleportTime < (BASE_TELEPORT_TIME_THRESHOLD + ping)
+	if isTeleport then
+		if withinTeleportThreshold then
+			entity._teleport = nil
+		else
+			const packed = buffer.readu8(copyB, 2)
+			buffer.writeu8(copyB, 2, bit32.band(packed, bit32.bnot(4)))
+		end
+	elseif withinTeleportThreshold then
+		return
+	end
+
+	if entity.lastClientClock and clientClock < entity.lastClientClock then
+		return
+	end
+
+	debug.profilebegin("HandleEntity.FireMiddleMans")
+	if FireMiddleMans(player, entity, cframe, serverClock) then
+		debug.profileend()
+		return
+	end
+	debug.profileend()
+	local velocity = nil
+	if Config.FLAGS.SERVER_VELOCITY_FIX and entity.snapshot then
+		const latest = entity.snapshot:GetLatest()
+		const lastClientClock = entity.lastClientClock or clientClock
+		local tickrate = entity.entityConfig.TICK_RATE
+		if entity.isHalfTicked then
+			tickrate = tickrate * 2
+		end
+		if latest then
+			velocity = InterpolationMath.CalculateVelocity(
+				latest.value.Position,
+				lastClientClock,
+				cframe.Position,
+				clientClock,
+				tickrate
+			)
+		end
+	end
+	if Entity.Push(entity, serverClock, cframe, velocity) then
+		entity.arriveFrame = Ticker.GetGlobalTick()
+
+		entity.lastClientClock = clientClock
+		entity.cframeBuffer = copyB
+		if entity.modelReplicationMode == "NATIVE" and not entity._lockedCFReplication then
+			return
+		end
+		Entity._SetPartCFrame(entity, cframe)
+	end
+end
+
+const TotalBytes = {}
+const function OnReceive(player: Player, data: buffer)
+	if not data then
+		return
+	end
+	TotalBytes[player] = (TotalBytes[player] or 0) + buffer.len(data)
+	BytesReceived += buffer.len(data)
+	const maxBytes = CalculateMaxThroughputForPlayer(player)
+	if TotalBytes[player] > maxBytes then
+		Warn.medium("Player", player.Name, "exceeded max bytes per frame:", TotalBytes[player], "max:", maxBytes)
+		return
+	end
+	debug.profilebegin("Receiver.OnReceive")
+	local index = 0
+	const clientClock = ClockUnwrap.unwrapFor(ClientClockWrap, player, buffer.readu32(data, index))
+	index += 4
+	const serverClock = os.clock()
+	const dataLength = buffer.len(data)
+
+	ServerClock.Store(player, clientClock)
+
+	while index < dataLength do
+		const id, cframe, newIndex, isTeleport = DeserializeEntityPacket(data, index)
+		const copy = buffer.create(newIndex - index)
+		buffer.copy(copy, 0, data, index, newIndex - index)
+		index = newIndex
+		HandleEntity(player, id, serverClock, clientClock, cframe, copy, isTeleport)
+	end
+	debug.profileend()
+end
+
+--[=[
+	Registers a middle man function that can intercept incoming entity updates.
+
+	@param name The unique name of the middle man
+	@param priority The priority of the middle man ( higher priority runs first )
+	@param func The function to call. Should return true to block the update, else allow it.
+]=]
+function Receiver.RegisterMiddleMan(
+	name: string,
+	priority: number,
+	func: (
+		player: Player,
+		entity: Types.Entity,
+		cframe: CFrame,
+		arriveTime: number
+	) -> boolean
+)
+	MiddleMans[name] = { priority = priority, func = func }
+	SortedMiddleMans = {}
+	for mm, data in MiddleMans do
+		table.insert(SortedMiddleMans, data)
+	end
+	table.sort(SortedMiddleMans, function(a, b)
+		return a.priority > b.priority
+	end)
+end
+
+--[=[
+	Unregisters a middle man function.
+	@param name The unique name of the middle man
+]=]
+function Receiver.UnregisterMiddleMan(name: string)
+	MiddleMans[name] = nil
+	SortedMiddleMans = {}
+	for mm, data in MiddleMans do
+		table.insert(SortedMiddleMans, data)
+	end
+	table.sort(SortedMiddleMans, function(a, b)
+		return a.priority > b.priority
+	end)
+end
+
+if RunService:IsServer() then
+	local lastByteCheckTime = 0
+	RunService.Heartbeat:Connect(function(a0: number)
+		table.clear(TotalBytes)
+
+		if os.clock() - lastByteCheckTime > 1 then
+			Stats.BYTES_RECEIVED_PER_SEC = BytesReceived
+			BytesReceived = 0
+			lastByteCheckTime = os.clock()
+		end
+	end)
+	UnreliableEvent.OnServerEvent:Connect(OnReceive)
+	SafeReplicateEvent.OnServerEvent:Connect(OnReceive)
+
+	Shared.Remotes.ClientHeartbeat.OnServerEvent:Connect(function(player: Player, seconds: number)
+		if type(seconds) ~= "number" then
+			return
+		end
+		const clientClock = ClockUnwrap.seatFullFor(ClientClockWrap, player, seconds)
+		ServerClock.Store(player, clientClock)
+	end)
+
+	Players.PlayerRemoving:Connect(function(player)
+		ClientClockWrap[player] = nil
+	end)
+end
+
+function Receiver._GetClientClockRaws(): { { player: Player, raw: number, offset: number } }
+	const out = {}
+	for player, state in ClientClockWrap do
+		if state.lastRaw then
+			table.insert(out, { player = player, raw = state.lastRaw, offset = state.offset })
+		end
+	end
+	return out
+end
+
+return Receiver