Hello, my name is Ideal, i’m scripter in Roblox for over 7 years now, and i wanted to share my knowledge
I’ve made advanced scripting tutorial to share more concept based techniques you can use to improve your code, in this tutorial i want to explain how to use them properly to gain maximum performance for minimal work
Previous Tutorial: Advanced Scripting Tutorial
As usual, i’ll edit this tutorial to make writing it easy and to expand it later on
1. Optimization - Tips
In the first tutorial, you’ll learn about basic optimization concepts and find out about some tips
There are 3 main fields in scripting where program resources are used, each field have techniques bound to it and might or might not cause problems depending on your game
What are those fields?
Those are stress, usage and storage
-
Stress tells us how often our code is ran
-
Usage tells us how memory intensive is our code
-
Storage means how much memory our code allocates/uses
Most of the time, one of those cause large performance issues and need to be optimized, it’s pretty much game dependant, but i’ll give you some tips on how to optimize them
1. Stress
Because stress is how frequent our code runs, we need to reduce this time, first of all we need to ask if we really need something to run very often
Example:
local function onHeartbeat(DeltaTime: number)
--/ Code that calculates path to a player for NPC
end
RunService.Heartbeat:Connect(onHeartbeat)
It will lag if there is a lot of NPCs
Because if there will be more than few NPCs, we’ll probably experience some performance issue, but really do we need to perform check every frame?
If we checked each 5 frames, or each 0.083 seconds it will be the same, because player can’t move so fast and NPC will still chase our player
local WaitTime = 0.083
local AccumulatedTime = 0
local function onHeartbeat(DeltaTime: number)
AccumulatedTime += DeltaTime
if AccumulatedTime >= WaitTime then
--/ Calculate path
AccumulatedTime -= WaitTime
end
end
This simple time accumulator allowed us to reduce calculations by 5x
But they’ll be performed each frame and cause lag
This is why we can use another technique, which is spreading code over frames
local RandomWaitFactor = 0.032 --/ 2 Frames
local function onHeartbeat(DeltaTime: number)
AccumulatedTime += DeltaTime
local ActualWaitTime = WaitTime + Random.new():NextInteger((-RandomWaitFactor, RandomWaitFactor))
if AccumulatedTime >= ActualWaitTime then
--/ Calculate path
AccumulatedTime -= ActualWaitTime
end
end
So now it can run faster or slower?
Because it’s random factor each time, it might be slower of faster by few frames, but 0.032 seconds is 2 frames, which is practically invisible difference, but for a program, it’s a matter of doing 200 calculations in one frame, or only 40 x 5 in 5 frames
2. Usage
This one i sadly cannot help much, because it’s very dependant on your game, but here are few tips:
- Use more performant methoods if possible, do research
- Try to avoid deprecated features as they are usually slower
- If you don’t need something, then don’t use it!
Example:
--/ We want to get player from character
local Distance = (Player.Character.PrimaryPart.Position - Target).Magnitude
--/ But there is 2x faster methood
local Distance = Player:GetDistanceFromCharacter(Target)
3. Storage
Here as well i can’t reccomend much, but the best option is to use reference over copying values, and also destroying things we don’t need anymore
General Tips:
- Disconnect connections
- Destroy instances
- Nulify table indexes if not needed
- Use references instead of copy
- Don’t create large amounts of new things that take place like tables, OOP objects, functions or threads
After this short tutorial you should watch for those sections when optimizing, remember to always research and experiment to get the best results, and never over-do this, most of the time optimization isn’t required at all!
Thanks for reading, have a nice day, bye!
2. Binary Optimizations
In the second tutorial, you’ll learn about binary optimizations and when to use them
Binary optimizations is process of reducing size of data we use, each value, from simple variable to a large table have it’s size, this mean they take space in memory and might be slower to work with on computer level
So like if something have a lot of bytes it’s bad?
Depends, in Roblox there is so much space, that if you don’t create thousands upon thousands of objects or store giant amounts of data, you don’t need to worry about it
But storage isn’t the only place where this matter, there are also requests and communication between computers
Note: Server is a computer too
First of all, we need to understand why this size matter in requests, see there are two electronic components that explain everything
Multiplexer is device that converts parrarel signal into serial signal
Demultiplexer is device that converts serial signal into parrarel signal
It’s Roblox, not electronics, why do we need to know this?*
In short terms, this is how parrarel signal looks like:
0
0
1
1
0
1
0
And this is how serial signal looks like:
0101100
Note: We read binary numbers from back!
Soooo?
In computers, there are parrarel cables, which contain n wires, for instance 32-bit system have 32 wires, and 64-bit system have 64
It’s a lot faster to send signals through parrarel cables, but it’s also expensive if we wanted to use them on long ranges, this is why internet operates on serial ones
Imagine those cables as a highway and each bit as a car, the more wires, the more highway lanes is there, thus cars can move faster and don’t block the road
Now imagine that there is only one wire, the more cars, the longer it takes for all of them to reach destination
If all data in computers is stored as bytes, and each byte is 8 bits
Oh! In order to make the game work faster, we use less bits
Because everything that needs to be sent through network, this mean some API calls and Remote Events, we can reduce the load they need to carry, thus increasing performance
IMPORTANT NOTE: THIS RULE ALSO APPLY TO LUAU INTERPRETED SCRIPTS, FUNCTION CALLS AND OTHER METHOODS CAN BENEFIT FROM THIS
But how to do that in Roblox?
To do this in Roblox, we can use 4 features:
- Bit32 library
- Buffers
- Strings
- Vector3Int16
They all have pros and cons, but what you really should aim for most of the time is use of buffers, and for more advanced work with numbers buffers + bit32
Better explanation of bit operations: How we reduced bandwidth usage by 60x in Astro Force (Roblox RTS)
Let’s try to create basic compression for ItemID and ItemAmount, for inventory system
local function CompressItemData(ItemID: number, ItemAmount: number): buffer
local Compressed = buffer.create(3)
end
We’ll create 3 bytes buffer, there wouldn’t be more than 255 IDs and item amount shouldn’t exceed 64000
local function CompressItemData(ItemID: number, ItemAmount: number): buffer
local Compressed = buffer.create(3) --/ Creating 3 bytes buffer
buffer.writei8(Compressed, 0, ItemID)
buffer.writei16(Compressed, 1, ItemAmount)
return Compressed
end
Ok, we need to retrieve this value from buffer after sending it through remote
local function onClientEvent(ItemData: buffer)
local ItemID = buffer.readi8(ItemData, 0)
local ItemAmount = buffer.readi16(ItemData, 1)
print(ItemID, ItemAmount)
end
Test:
local Data = CompressItemData(1, 450)
Remote:FireClient(Player, Data)
print(ItemID, ItemAmount) -> 1, 450
Why we can’t send normal number?
Normal numbers in Roblox are 64 bits Integers, this mean that sending both ID and Amount would take 20 bytes! 8 bytes per number * 2 + 2 bytes for type * 2
with buffer, it will take only 5 bytes, that’s 5x less
Other popular methood is bit-packing, it’s turning 2 numbers into one, and then turning the result back into two numbers
It must be hard
In order to pack two numbers, you need to understand how binary numbers work in general, but in simpliest terms, they are made up from 1s and 0s, rows of them, and if we place 1 row at the end of another, we will create brand new binary number
Example:
0b0001 --/ 1 in binary
0b0011 --/ 3 in binary
0b00010011 --/ 19 in binary
How to do it in Roblox then?
Here comes bit32 library that allows us to perform binary operations
local A = 5
local B = 2
--[[
A = 0b000_111,
B = 0b111_000
]]
local Packed = bit32.bor(A, bit32.lshift(B, 3))
print(Packed) --> 53
What we did, is we added A and B with bits shifted to the left, this mean that we added 3 zeros to B at the right side
B = 0b011_000
If you know how OR operator works, there is a table:
0 + 0 = 0
0 + 1 = 1
1 + 0 = 1
1 + 1 = 1
This is how A + B looks like:
0b011_000
0b000_101 +
---------
0b011_101
To decompress it, the thing we need to do is read rows of bits we added, we know that each row is 3 bits
local A = bit32.extract(Packed, 0, 3) --/ Extract 3 bits from index 0
local B = bit32.extract(Packed, 3, 3) --/ Extract 3 bits from index 3
print(A, B) --> 5, 2
This way you can turn two 3bit integers into one 6bit integer
But it doesn’t give us any advantage…
It does, what if we only needed 2 bits of one number and 6 bits of another, if we used only buffers, we had to store two 8bit integers, but if we used bit packing + buffer we reduced this size by half
Note: Remember that maximum value the number can hold is (2 ^ bits - 1)
Note: Remember that each string’s character is 1 byte per UTF-8, this makes sending large strings in requests inefficient
As you can see, you can optimize your game pretty easily, by knowing these things you can reduce requests size few times, making it very effective
Thanks for reading, have a nice day, bye!
3. Grids
In the third tutorial you’ll learn about grids
Grid is collection of 2D or 3D cells that holds some data, they are usually presented as a table with Rows * Cells and Collumns * Cells
Grid allows us to store data, but also optimize distance math, such as magnitude checks or area effects
To make basic grid, we need to make nested for loop
local Grid = {}
for y = 1, 10 do
for x = 1, 10 do
local Index = x + (10 * y) - 1 --/ for each Y there will be 10 X
Grid[Index] = {x = x, y = y}
end
end
Index is number that represent which cell we are in, because we start counting from 1, we had to subtract 1, otherwise the index will be 1 position off
So it’s like square divided into smaller squares?
Grid is mostly in the shape of square, although we can change number of rows and collumns to turn it into rectangle
How to find index based off position then?
To find index based off position, we need to know 2 things: cell size and current position
local X = 3
local Y = 12
local CellSize = 4
local x = math.floor(X / CellSize)
local y = math.floor(Y / CellSize)
print(x, y) --> 0, 3
Ok, but what if we want relative position?
To get relative position, it’s simpliest thing to do, we need to subtract our relative point’s position
local X = 8
local RelativeX = 5
local x = math.floor((X - RelativeX) / CellSize)
print(x) --> 0
Where can we use our grid?
It’s mosty used to optimize distance checks, as you remember you can get index knowing only position and cell size, this mean that if you could get, let’s say 9 cells around NPC to see if there are targets rather than checking through hundreds of objects, it would be always better
Another thing grids might be used for is making block placement systems or tile systems for your game
Grids are simple, but also powerfull thing you can use to improve your game
Thanks for reading, have a nice day, bye!
4.
This text will be hidden
5.
This text will be hidden
6.
This text will be hidden
7.
This text will be hidden