cluaupp 1.0.0 → 1.4.0

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

@@ -1,299 +0,0 @@
---!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

@@ -1,141 +0,0 @@
---!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

@@ -1,287 +0,0 @@
-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