Docs upgrades & optimization

Author: ffrostfall

dev/client/clientTests.client.luau

@@ -1,10 +1,12 @@
+--!native
+--!optimize 2
 local ReplicatedStorage = game:GetService("ReplicatedStorage")
 
 local testPackets = require(ReplicatedStorage.shared.testPackets)
 
-ReplicatedStorage.RemoteEvent.OnClientEvent:Connect(function()
-	--print(data)
-end)
+--ReplicatedStorage.RemoteEvent.OnClientEvent:Connect(function()
+--print(data)
+--end)
 
 testPackets.myPacket.listen(function()
 	--print("Confirming server -> client")

dev/server/serverTests.server.luau

@@ -19,7 +19,7 @@ local testPackets = require(ReplicatedStorage.shared.testPackets)
 }]]
 
 local out = {}
-for _ = 1, 1000 do
+for _ = 1, 100 do
 	table.insert(out, {
 		a = 5,
 		b = 4,

docs/api/dataTypes/Primitives.md

@@ -7,10 +7,12 @@
 ByteNet provides a large amount of "primitive" types for you to build more complex types that suit your game. Since primitive types don't need any parameters, you can just access them like the following: `ByteNet.<typename>`. For building more complex data structures, go look at the <a href="../Specials">Specials page.</a>
 
 ---
-## Supported generic types
+## Supported general types
 - `string`: String
 - `buff`: Buffer
 - `bool`: Boolean
+- `nothing`: Nothing
+- `unknown`: Any type
 ---
 ## Supported number types
 - `uint8`: Unsigned 8-bit integer
@@ -26,4 +28,5 @@ ByteNet provides a large amount of "primitive" types for you to build more compl
 - `cframe`: CoordinateFrame
 - `vec2`: Vector2
 - `vec3`: Vector3
+- `inst`: Instance
 ---

docs/api/dataTypes/Specials.md

@@ -9,30 +9,47 @@ Special types are how complex packet types are made. They can take in nearly any
 Special types always take *parameters*. You have to call them: `ByteNet.<type name>(<any primitive type>)`.
 
 !!!danger
-	### There are drawbacks to using these!
-
 	- Using these types incurs 1-2 bytes of overhead due to the dynamic nature.
 	- They take drastically more time to parse
 	- They are heavier on memory usage, as a new closure is created each time. You will never have to worry about this unless you have dozens of packets, though.
 
 ---
 
+## Structs
+Structs let you send structured data in the form of dictionaries. The fields are optimized away, so they don't take any bandwidth. Structs are how you'll be sending most of your data likely: they are the best for organization, and they let you do really interesting things. For example:
+```lua title="chunkPackets.luau"
+return ByteNet.defineNamespace("chunks", function()
+	local chunkData = ByteNet.struct({
+		biome = ByteNet.uint8,
+		seed = ByteNet.int32,
+	})
+
+	return {
+		sendChunks = ByteNet.definePacket({
+			value = ByteNet.array(chunkData)
+		})
+	}
+end)
+```
+
 ## Optionals
 Optional types are a cool name for the concept of "This doesn't have to exist". It's good for optional parameters: for example if some invoked function were to fail, you might want to send back a blank copy to indicate that something is wrong.
 
 ```lua title="packets.luau"
-return {
-	myCoolPacket = ByteNet.definePacket({
-		structure = {
-			-- An "optional" type takes in a parameter.
-			-- This can be anything! You can even have optional arrays.
-			helloWorldString = ByteNet.optional(ByteNet.string)
-
-			-- This works!
-			eachCharacter = ByteNet.optional(ByteNet.array(ByteNet.string))
-		},
-	})
-}
+return ByteNet.defineNamespace("chunks", function()
+	return {
+		myCoolPacket = ByteNet.definePacket({
+			value = ByteNet.struct({
+				-- An "optional" type takes in a parameter.
+				-- This can be anything! You can even have optional arrays.
+				helloWorldString = ByteNet.optional(ByteNet.string)
+
+				-- This works!
+				eachCharacter = ByteNet.optional(ByteNet.array(ByteNet.string))
+			}),
+		})
+	}
+end)
 ```
 You really don't have to think about using optional types. You just send it!
 ```lua title="server.luau"
@@ -41,7 +58,7 @@ local packets = require(path.to.packets)
 local randomlyStringOrNil = 
 	if math.random(1, 2) == 1 then "Hello, world!" else nil
 
-packets.myCoolPacket:sendToAll({
+packets.myCoolPacket.sendToAll({
 	helloWorldString = randomlyAppearingString,
 
 	-- Note that even if we don't put the "eachCharacter" field here,
@@ -57,22 +74,22 @@ Arrays are fairly self explanatory. They're just plain old arrays. However, it's
 There is a 2 byte overhead to sending an array in ByteNet. This is because these 2 bytes are an unsigned 16-bit integer, which stores the array length. As a side effect, arrays sent through ByteNet have a max length of **2^16**, which is equal to **65,536**. It's likely that in the future, you will be able to reduce the overhead to 1 byte through configuration, in turn reducing the max length of the array.
 
 ```lua title="packets.luau"
-return {
-	myCoolPacket = ByteNet.definePacket({
-		structure = {
-			myArray = ByteNet.array(ByteNet.bool)
-		},
-	})
+return ByteNet.defineNamespace("example", function()
+	return {
+		myCoolPacket = ByteNet.definePacket({
+			value = ByteNet.array(ByteNet.bool),
+		})
+	}
 }
 ```
 
 ```lua title="server.luau"
 local packets = require(path.to.packets)
 
-packets.myCoolPacket:sendToAll({
+packets.myCoolPacket.sendToAll({
 	-- Important to note that mixed arrays/arrays with holes
 	-- shouldn't be sent through.
-	myArray = { true, false, true }
+	true, false, true
 })
 ```
 
@@ -84,25 +101,23 @@ Maps are by far the most powerful "special" type in ByteNet. They let you send,
 Like arrays, maps have a 2-byte overhead to store the length of the map. This is done by iterating over the map using <a href="https://devforum.roblox.com/t/luau-recap-may-2022/1818869">generic iteration</a> and increasing a variable by 1 for every key-value pair. This, once again, means that there is a **2^16** (which equals to **65,536**) cap to the number of elements in the map.
 
 ```lua title="packets.luau"
-return {
-	myCoolPacket = ByteNet.definePacket({
-		structure = {
+return ByteNet.defineNamespace("example", function()
+	return {
+		people = ByteNet.definePacket({
 			-- [name] = age
-			people = ByteNet.map(ByteNet.string, ByteNet.uint16)
-		},
-	})
-}
+			value = ByteNet.map(ByteNet.string, ByteNet.uint8)
+		})
+	}
+end)
 ```
 
 ```lua title="server.luau"
 local packets = require(path.to.packets)
 
-packets.myCoolPacket:sendToAll({
-	people = {
-		john = 21,
-		jane = 24,
-		dave = 26,
-		you = 162,
-	}
+packets.myCoolPacket.sendToAll({
+	john = 21,
+	jane = 24,
+	dave = 26,
+	you = 162,
 })
 ```

docs/css/code.css docs/api/functions/defineNamespace.mddocs/css/code.css renamed to docs/api/functions/defineNamespace.md

@@ -12,22 +12,20 @@ ByteNet's purpose as a library is to provide a way to structure your data, and s
 ---
 
 ## Okay, where do I start?
-I highly recommended storing all of your packets in a single, shared module, and then using a dictionary to access the individual packets. Not only does this make using ByteNet a breeze, it also gives you a better form of typechecking.
-
-The keys of your packet determine the ID it gets. The server and the client sharing this key is essential: that's the core of how ByteNet works. Unfortunately, this means you cannot have duplicate contents of packets. **This may change in the future.**
-
-Enough of how it works, let's start off with making a basic packet:
+Enough of how it works, let's start off with making a basic packet. We will also need to create a namespace:
 ```lua title="packets.luau"
 local ByteNet = require(path.to.bytenet)
 
-return {
-	printSomething = ByteNet.definePacket({
-		-- This structure field is very important!
-		structure = {
-			message = ByteNet.string,
-		}
-	})
-}
+return ByteNet.defineNamespace("messaging", function()
+	return {
+		printSomething = ByteNet.definePacket({
+		-- This value field is very important!
+			value = ByteNet.struct({
+				message = ByteNet.string,
+			})
+		})
+	}
+end)
 ```
 
 ---
@@ -44,32 +42,32 @@ On the client, there is only one, because you can only send data to the server:
 
 - `send`
 
-These functions *must* obey your structure created in `definePacket`, and if you have strict typing on, an error will be raised if the types do not match.
+Any data passed through these functions *must* obey your structure created in `definePacket`, and if you have strict typing on, an error will be raised if the types do not match.
 
 *code examples*
 ```lua title="client.luau"
 -- Sending to server
-packets.myPacket:send({
+packets.myPacket.send({
 	message = "Hello, world!"
 })
 ```
 ```lua title="server.luau"
 -- Sending to all players
-packets.myPacket:sendToAll({
+packets.myPacket.sendToAll({
 	message = "Hello, players!"
 })
 
 -- Sending to an individual player
 local someArbitraryPlayer = Players.You
 
-packets.myPacket:sendTo({
+packets.myPacket.sendTo({
 	message = "Hello, random player!"
 }, someArbitraryPlayer)
 
 -- Sending to all except a certain player
 local someArbitraryPlayer = Players.You
 
-packets.myPacket:sendToAllExcept({
+packets.myPacket.sendToAllExcept({
 	message = "Hello, everyone except one person!"
 })
 ```
@@ -80,12 +78,12 @@ You can use the `listen` method to listen for when a packet is received.
 
 *code examples*
 ```lua title="server.luau"
-packets.myPacket:listen(function(data, player)
+packets.myPacket.listen(function(data, player)
 	print(`{player.UserId} says { data.message }`)
 end)
 ```
 ```lua title="client.luau"
-packets.myPacket:listen(function(data)
+packets.myPacket.listen(function(data)
 	print(`server says { data.message }`)
 end)
 ```