For example lets say I have
local CharData = {
XP = 100
Level = 100
}
how would I detect if the XP value is changed so that I could level up the character?? I’ve been looking everywhere and can’t quite find the solution. I heard about meta tables but I am not sure how to use it to make events or triggers.
Create a bindable/remote event and every time you update data in the table, fire the event. That’s the only way of doing it with tables, but unfortunately I don’t have any experience with metatables.
Wrap it in a metatable and use the __index and __newindex methods to rawset the value on the real table. Fire a bindable event with no parent.
You could make your own method for creating and hooking to these bindable events, similar to GetPropertyChangedSignal method on Instances.
This may not be the best way of doing it but give it a try 
local Stats = {}
local Meta = {
__call = function(...)
print("Value changed")
rawset(...)
end
}
setmetatable(Stats,Meta)
print(Stats.Level)
Stats("Level", 110)
print(Stats.Level)
Stats("Level", 100)
print(Stats.Level)
Adding onto this, since it was a bit unclear to me, you would need two tables. One would store the “actual” table values, and the other would just be an interface you use to interact with the internal table. Here’s a quick code sample to show what I mean:
local internal, interface, events = {}, {}, {}
-- internal table, table you interact with, and a table of getpropertychangedsignal events
local changedEvent = Instance.new("BindableEvent")
internal.Changed = changedEvent.Event -- make interface.Changed be the bindable's event
function internal:GetPropertyChangedSignal(property) -- set up an event to fire for that property
local propertyEvent = Instance.new("BindableEvent")
events[property] = events[property] or {} -- if there's no table of connected functions yet, make one
table.insert(events[property], propertyEvent)
return propertyEvent.Event
end
setmetatable(interface, {__index = function(self, index) -- when interface is indexxed, grab from internal instead
return internal[index]
end, __newindex = function(self, index, value) -- when interface has something set, fire the event and set it under internal
internal[index] = value
changedEvent:Fire(index)
if events[index] then -- events is for getpropertychangedsignal
for i, v in ipairs(events[index]) do
v:Fire(value)
end
end
end})
interface.Changed:Connect(print)
interface:GetPropertyChangedSignal("Name"):Connect(print)
interface.Archivable = false --> Archivable
interface.Name = "wow!" --> Name, wow!
I attempted to test this using a pseudo-instance, but I’m not able to test if it works in Roblox Lua.
(If this helped, mark Ban’s post as the solution since it was his suggestion. I’m just trying to make it more clear on how that solution would look, implementation-wise.)
Here’s an idea; however its inefficient.
Store the table
Create a coroutine
Inside the coroutine you create a new variable yet same to the table
Every second or so, coroutine checks if the variable and the table are different, if so then it signals that it changed and then changes the variable to be the new table which prevents multiple signals
I check did a player reach new level every time I add XP to the player like this:
function PlayerDataApi.addXP(player, xp)
local dataValue = playerDataFolder:FindFirstChild("Data_"..tostring(player.UserId))
if dataValue ~= nil then
local data = HttpService:JSONDecode(dataValue.Value)
data.XpAmount = data.XpAmount + xp
if data.XpAmount == Levels.getXpRequired(data.Level + 1) then
data.XpAmount = 0
data.Level = data.Level + 1
elseif data.XpAmount > Levels.getXpRequired(data.Level + 1) then
data.XpAmount = data.XpAmount - Levels.getXpRequired(data.Level + 1)
data.Level = data.Level + 1
end
dataValue.Value = HttpService:JSONEncode(data)
end
end
(That code is in a ModuleScript and I always use that module script to add XP to players)
Some of the replies here suggest using metatables. This is not the best solution for you.
In your case, remember that the only time that the XP value in the table will change is when you change it from somewhere in your codebase. This means that you can avoid all of the complicated, unreadable, and messy metatable code. Instead, you should create a function that is used for setting/updating values in CharData. That function can then trigger any code that you want to respond to XP changes, for example.
local function setXP(charData, newXP)
charData.XP = newXP
-- anything you want to happen when XP changes
end
Whenever you change XP, you call this function instead of setting charData.XP directly.