How do you go about creating an Event for an object?
For instance, a Part has the events Touched, TouchEnded, etc:
How do you go about creating your own?
For example, I’ve written a DoubleJump function which I want to be referenced under every character:
character.DoubleJumped:Connect(function()
--my stuff
end)
or
character.DoubleJumped:Wait()
Bindables? I think that’s the closest you can get
Bindables appears to be my best bet if there’s no alternative, however I would like to directly reference the event from the Object. To do this, I could place a Bindable event within the object, but this would surely be inefficient to do for lots and lots of parts for example?
Yeah, it would. It would also mean that you would have to add the .Event after every time you reference the result. I don’t think this is a feature on roblox (To my knowledge at least), but I think it would be a good idea to suggest it.
You can’t create an event under an object, but you could use ModuleScripts to make custom events if you want, or just use bindable events.
How can I achieve this with a module script? Can you give an example please?
I published a module which does something like events.
How to use:
local event = require(script.Event) -- get the event
-- using :Connect()
local connection = event:Connect(print,1)
-- connects the function print to the event with default argument 1
event:Fire(2)
-- fires the event, passing the arguments to all the connected functions
--output:
-- 1 2
-- prints 1 because its the default argument passed through in :Connect()
-- prints 2 because it was passed through in :Fire()
connection:Disconnect()
event:Fire(3)
-- prints nothing because the connection was disconnected
-- using :Wait()
local coro = coroutine.create(function()
print(event:Wait()) -- yields and will print out whats returned
end)
coroutine.resume(coro)
event:Fire("hello")
-- prints hello because calling Fire resumes all threads yielded with :Wait()
-- the return of :Wait() is whatever was passed through in the :Fire() which resumed it
uhhhh i think im gonna stick with bindable events and functions
There are many ways you could get close to that, but currently we can not set custom events to objects in that way.
What I would do is wrap the humanoid inside a table so that you can use the event like a normal event, and set its __index and __newindex to the humanoid:
--whenever character/humanoid is added:
local DoubleJumpEvent = Instance.new("BindableEvent")
local Humanoid = {
DoubleJumped = DoubleJumpEvent.Event
}
setmetatable(Humanoid, {
__index = -- humanoid here,
__newindex = -- humanoid here
})
--whenever character double jumps:
DoubleJumpEvent:Fire([[data]])
--whenever you want to connect to the event:
Humanoid.DoubleJumped:Connect(Function)
--You can still treat it like a normal humanoid!
Humanoid.Jump = true
Humanoid.WalkSpeed = 40
It would probably be more useful to set this up in a module script so other scripts can get it:
local module = {
Stored = {}
}
function module.new(humanoidInstance)
local DoubleJumpEvent = Instance.new("BindableEvent")
--connect how this humanoid will detect double jumping
--this can also be done outside of the script
local Humanoid = setmetatable({
DoubleJumped = DoubleJumpEvent.Event
},{__index = humanoidInstance, __newindex = humanoidInstance})
module.Stored[humanoidInstance] = Humanoid
return Humanoid, DoubleJumpEvent
end
function module.get(humanoidInstance)
return module.Stored[humanoidInstance] or module.new(humanoidInstance)
end
return module
Actually I was scrubbing on my files of an old project to open source and this probably can help you
(It does not rely on BindableEvents, some testing I did some time ago suggests that it performs better than spamming BindableEvents).
local Event = { -- recreate the RBXScriptSignal instance to be applied on custom gui objects
new = function()
local signalAPI = {
FunctionConnectionQueue = {}, -- internal usage by the module to manage connected functions
WaitLink = {WaitCount = 0, CanFlush = false, Args = nil}, -- internal usage by the module to manage yielding threads
Connect = function(event, f) -- adds a function to the queue that is fired when the event happens
local ScriptConnection = {Connected = true, Listener = f, Disconnect = function(connection) -- recreates the RBXScriptConnection instance
connection.Connected = false
end}
table.insert(event.FunctionConnectionQueue, ScriptConnection)
return ScriptConnection
end,
Wait = function(event) -- yields the script until the event is fired
event.WaitLink.WaitCount = event.WaitLink.WaitCount + 1
repeat
wait()
until event.WaitLink.CanFlush
event.WaitLink.WaitCount = event.WaitLink.WaitCount - 1
return unpack(event.WaitLink.Args)
end,
Fire = function(event, ...) -- internal usage by the module that makes the magic happen
local packedArgs = {...}
-- flush all :Wait() calls
event.WaitLink.Args = packedArgs
event.WaitLink.CanFlush = true
coroutine.resume(coroutine.create(function()
repeat
wait()
until event.WaitLink.WaitCount == 0 -- revoke the flush permission when all :Wait() calls have been returned
event.WaitLink.CanFlush = false
end))
for i = #(event.FunctionConnectionQueue), 1, -1 do
-- RBXScriptSignal fires functions in reverse order they were connected, so do I
local connection = event.FunctionConnectionQueue[i]
if connection.Connected then
coroutine.resume(coroutine.create(function()
connection.Listener(unpack(packedArgs))
end))
end
end
end
}
return signalAPI
end
}
return Event
Say you have your character custom object (probably defined as a table like this):
character = {
Speed = 150,
Sleep = 1,
--etc
}
All you need to do now is to require the module and declare an Event.new(), à là Roblox:
You only need to require the module to make new events, you don’t need it to manipulate (connect to, wait, fire) them!
local Event = require(--[[ path to module ]])
character = {
Speed = 150,
Sleep = 1,
DoubleJumped = Event.new()
}
And then proceed as always. On another script:
local connection = character.DoubleJump:Connect(function(arg1, arg2, arg3)
print(arg1),
character.Speed = arg2 + arg3
)
warn(character.DoubleJump:Wait())
connection:Disconnect()
-- Other script
character.DoubleJump:Fire(1337, 13, 15)
I have a few questions about your script.
Firstly,
In the :Wait(), why are you using a repeat wait() loop instead of just resuming the threads when :Fire() is called?
So for example, in that DoubleJump:Wait() it would mean that the thread isn’t resumed right away after its fired. (aka latency)
Secondly,
Even after an event is disconnected, your script makes it stick around in memory until the main signal that you get with the .new() function is garbage collected. Is there a reason to keep it in memory?
Lastly,
Ignoring how even after disconnecting an event it still sticks around in memory, whenever you call :Fire() it still loops through already disconnected functions (but doesn’t call), is there a reason for this?
The sad part about this is that without ModuleScripts or Bindable/Remote objects, this is (nigh) impossible to do. The metatables of Roblox instances are locked (and for good reason), so we can’t exactly wrap our own methods around those objects.
I’ll just make some bindable instances inside my objects and fire them in my functions when necessary.
Accidentally clicked on reply to you, soz
Okay now that my mind is clearer this makes a lot of sense, and I love it!!!111!!
Wouldn’t it still work if I removed the Stored table and only returned the Humanoid table? What problems could arise from doing it this way?
Also why would I need module.new? What does it do?
If you’re trying to see when someone jumps twice in a row, you should be able to just use the .Changed event in combination with tick. Here’s an example.
local lastJump = 0
character.Humanoid.Changed:Connect(function(prop)
if (prop == ‘Jump’) and (tick() - lastJump)<0.9 then
print(“Double jump!”)
end
lastJump = tick()
end)
(not sure how to make it show as code)
The only problem with not using the stored table is that other scripts wouldn’t be able to access that humanoid’s event, only the one that created the humanoid, and there wouldn’t really be a way around it without retrieving it from module.
And module.new returns the new humanoid with the DoubleJumped event added. Since this technically makes it a class, putting it into an object-oriented format makes sense.
TL; DR: Blame 15 year old me.
This script was made in a project that I attempted to make back in 2017. Knowing what I know now, I’d probably detect the issues you’re mentioning (#DontFixWhatsNotBroken)
But alas,
Fair Enough™, but as I didn’t know you could pause a script like that! The more you know… (because I thought the main thread wasn’t a coroutine 
) - therefore I had to use what I knew, I guess.
- the connection should also be trashed manually.
Event.new() won’t usually be GC’ed unless you GC it’s parent.It was an oversight 
- upon disconnecting the event should have been removed. It never caused issues to me because probably I didn’t use this at a massive scale.
So when you require the module, you don’t get something you can use to make events, but an event itself. However, given how modules work, that means you cannot for example have two separate events without having two clones of the same model. Take for example this:
local e1 = require(script.Event)
local e2 = require(script.Event)
local c = e1:Connect(function(x)
print("Recieved from 1:", x)
end)
print("Sending from 2: ABCDEF")
e2:Fire("ABCDEF")
Sending from 2: ABCDEF
Recieved from 1: ABCDEF
You would need to clone the module for this to properly work, which I doubt it’s a very good idea.
I originally made this module for a game which I needed to pass a function through, so i made a custom event, but it would never be cloned because it was just a module script under ServerStorage.
Originally (before i remove the .new() )
--module script one
-- the code of the event
--module script two
require(script.Parent.Event).new()
After
-- module script one
-- the code for the event
So basically when I made it was removing an unnecessary module script. (atleast for me)