hardy coyote
The two images are the only things im using. As you can see i have recursion in the burn script and yes ik it will crash my game but it ment to convey what im trying to do.
I want to turn off the state before adding a new one. Reason for this is it will give the illusion that the time for burn is resetting. And It turns off old burn because the while loop checks if the burn state is still even a thing, and if it not it breaks.
So yeah
iron gorge
The two images are the only things im using. As you can see i have recursion in ...
use indices
smh
hardy coyote
@silent surge
silent surge
z
hardy coyote
y
silent surge
lemme read
silent surge
yea
iron gorge
Tier 2
hardy coyote
because
silent surge
it will be hardcoded as fuck
iron gorge
and doesnt matter
yo aint no way
silent surge
and doesnt matter
bro
hardy coyote
I DIDNT ASK FOR OPTIMISAIOTNS 
hardy coyote
wdym
iron gorge
its not that hard to make a variable
hardy coyote
my casing is fine
iron gorge
no its not bro 😭
silent surge
bro
hardy coyote
im not making it a constant or pascal case or whatever
silent surge
u can just use somethingl ike this
hardy coyote
can we get to the actual point
silent surge
local bool, bool1 = true, false
iron gorge
also these long spaces are pmo
silent surge
ong
hardy coyote
also these long spaces are pmo
i cant read without them
iron gorge
i cant read without them
are you dyslexic
hardy coyote
no
iron gorge
then get rid of them
hardy coyote
no
hardy coyote
yes but it makes it look messy imo
hardy coyote
i said imo
hardy coyote
they just there i forget to remove them
silent surge
oh i just do typeof(module) for the functions
what did typeof do
iron gorge
no i mean like this
silent surge
no i mean like this
oh
hardy coyote
whats ::
silent surge
yea
hardy coyote
this is what i ment for in depth scripting, no one ever shows me ts
iron gorge
yes
dense mulch
does a good morning hello become hi?
because
if task.wait
then
workspace:GetParent():GetParent():GetParent()
silent surge
does a good morning hello become hi?
yesnt
silent surge
what does gng mean
hardy coyote
what does gng mean
Gang
@ivory flame i know you read scripting help a lot so js asking if u could
appreciate it
hardy coyote
dont ping my man pyro
2 guys say they will help me then end up just flaming my work
like what do u want me to do
😢
velvet plank
Boiii
ivory flame
Amateur line compression lua Advance=function(self:BufferIStream_C,v:number) self.Cursor+=v if self.Cursor>buffer.len(self.Nug) then self:Flush() end end; writestring1=function(self:BufferIStream_C,v:string) local len=string.len(v) self:Alloc(len+1) buffer.writeu8(self.Nug,self.Cursor,len) buffer.writestring(self.Nug,self.Cursor+1,v) self.Cursor+=1+len end; writestring2=function(self:BufferIStream_C,v:string) local len=string.len(v) self:Alloc(len+2) buffer.writeu16(self.Nug,self.Cursor,len) buffer.writestring(self.Nug,self.Cursor+2,v) self.Cursor+=2+len end; Flush=function(self:BufferIStream_C,len:number?) local nugbuf=buffer.create(self.Cursor) buffer.copy(nugbuf,0,self.Nug,0,self.Cursor) table.insert(self.Nuggets,nugbuf) self.Nug=buffer.create(len or NUGGET_SIZE) self.TotalSize+=self.Cursor self.Cursor=0 end; writebuffer8=function(self:BufferIStream_C,v:buffer) self:Alloc(buffer.len(v)) buffer.copy(self.Nug,self.Cursor,v) self.Cursor+=buffer.len(v) end;
ivory flame
The two images are the only things im using. As you can see i have recursion in ...
so the problem here is very simple. you're trying to refresh the state by removing it and re-adding it. you done fucked up long before you got to that point.
to fix it you need to make your abstraction better, i'd suggest adding some kind of State.OnTick method that is auto connected/disconnected with the state, this way you can have that while true loop running and you never have to actually disconnect it, instead you can just update its state and it will continue ticking with new values.
hardy coyote
to fix it you need to make your abstraction better, i'd suggest adding some kind...
the answer i got from immortal white was similar to this
instead of resetting i refresh it
hardy coyote
to fix it you need to make your abstraction better, i'd suggest adding some kind...
yeah the only problem i saw there was whenever we add a new state, it opens a new function, so i had no idea how to refresh the old one
still dk how this code works tho lol
ivory flame
still dk how this code works tho lol
u wrote it how do you not understand it
hardy coyote
u wrote it how do you not understand it
idk its not how i write code
so i dont understand most of it
the comments just say whats happening
ivory flame
dk why he js gave me it
who's he
ivory flame
why would immortalwhite just give you working code
hardy coyote
why would immortalwhite just give you working code
i asked for help a lot of times and all i got was "idk" or "use ai". Im not blaming him for getting bored and just giving it to me
but it would be nice
to learn what is even happening
instead of being thrown code
he said read it and understand it later or something
ivory flame
thats very strange but the bottom line here is really simple
don't use code you don't understand.
ivory flame
if you cannot follow along what this structure is doing you don't deserve to use it.
you haven't earned it
hardy coyote
if you cannot follow along what this structure is doing you don't deserve to use...
nah i get most of it then it starts to break my brain
ivory flame
it's like teaching someone to drive in a lambo, its just stupid, dont do that
hardy coyote
we look if the player is already burning in active burns, and then we set the expiry and dps in that already made burn index to whatever the new value is
if not we js create a new one
but then
how the hell does last part work
if this is the second time we do it
ivory flame
yeah you haven't earned these patterns yet
hardy coyote
yeah you haven't earned these patterns yet
i legit never asked for the code
idk why
ivory flame
so dont use it
hardy coyote
so dont use it
mk
ill write up my own
but uhm
could you point me in the right direction for the last part
whats going on there?
i'd like to know
ivory flame
how the hell does last part work
but on the side, to answer this, that's the responsibility of the states handler not the state itself. the state handler creates connection to heartbeat or some other kind of repeating loop that calls a function in the specific state. when you update the values in the state you don't recreate the loop - instead the loop is written dumb and as a slave to the values: it doesn't decide anything, it just takes the current values and does the work with that. at most it might decide if the state should remove itself, but that's it.
hardy coyote
but on the side, to answer this, that's the responsibility of the states handler...
uh
im gonna sound so annoying but
what heartbeat connection?
oh wait
the while loop you mean
yeah alr
ivory flame
what heartbeat connection?
what do you think while true do task.wait() end is doing?
ivory flame
it's all the same stuff
hardy coyote
but on the side, to answer this, that's the responsibility of the states handler...
ok 1 last question
why is it written dumb as a slave
ivory flame
if you design your code right you can let the state yield its own tick thread
hardy coyote
why does it not create two? i dont see where we overwrite it
ivory flame
so you can wait arbitrary length
ivory flame
why is it written dumb as a slave
the work is trivial
ivory flame
how you have it now you have all this burn = { dps} and task.spawn and if not StateCanValidlyApply then return end (in the form of if not hum or dps<1 or duration<1 then return end) this does not need to be in the application of the state, it should be a different function on its own because what else you gonna do at that point? chr:SetAttribute("Burning",true) oh wait sorry i changed my mind immediately chr:SetAttribute("Burning",false)
why do that dumb thing when instead
function onBurnTick() local dps=self.BurnData.dps self.StateHost.Humanoid:TakeDamage(dps) end
like
ivory flame
`function onBurnTick() local dps=self.BurnData.dps self.StateHost.Humanoid:TakeD...
this is not hard to understand yet you make it hard for no reason?
writing functions the way you do, where everything is extremely linear, is a really bad style
over-using the while true do loops to create repeating code, and then using this for everything that repeats, completely ignoring event based paradigms, is where you're getting screwed over, and will continue getting screwed over up until you get rid of those training wheels. while true do is for first-day scripters. time to break the bad habit.
instead what you need is to figure out some code as to how to write a better version of those while true do loops, where you can have 3 functions: one to start the loop, one to "step" the loop (each iteration), and one to stop the loop, all independent of each other.
when you figure that out, you will understand how to fix this.
hardy coyote
recursion?
hardy coyote
no cus you said
ivory flame
instead what you need is to figure out some code as to how to write a better ver...
i can't make it clearer than this
hardy coyote
i can't make it clearer than this
sorry
ivory flame
the start/stop/step pattern is very common for timers that have variable duration
hardy coyote
but if you say while true do is for low level scripters, then what else do i use for a loop that yields
ivory flame
coz with start/stop/step, you can then insert in an update function that changes the delay until the next step, or does other things to interrupt the loop
it's the same mistake that humanoid.MoveToFinished:Wait() is.
you cannot interrupt it if you do that
so instead you need to make interruptable code, aka event based paradigm
ivory flame
coz with start/stop/step, you can then insert in an update function that changes...
which is just this.
ivory flame
but if you say while true do is for low level scripters, then what else do i use...
convert it into the start/stop/step functions.
i can assure you it will be the weirdest while true do loop you've ever written.
hardy coyote
one function starts the loop, the other ends it and one is the function that i feed into the loop, or is step the one that controls well, the stepping
ivory flame
once you got that under your belt you should be good to go for the rest of this
ivory flame
one function starts the loop, the other ends it and one is the function that i f...
this is correct. you can very much add an extra function to control the stepper
but the basics of it is start/stop/step
step is where the actual work usually happens like damage is dealt
ivory flame
start/stop are kind-of like interruptions, you can easily add more of them to control stepper in unique ways
hardy coyote
And this is a loop, not a recursive function right
ivory flame
you've confused recursion with something else
do not use recursion for this pattern
it is just a regular while true do loop, but instead of being impossible to interrupt, you've added the functions to start and stop it
that step is one that beginners usually can't make
they get stuck in their love for while true do and never find out what you can really do when you take the training wheels off.
hardy coyote
that step is one that beginners usually can't make
how, is it not just stop() pass in the loop and break
im assuming once i get this down it will fit neatly into my state system
ivory flame
im assuming once i get this down it will fit neatly into my state system
haha no
they're not trivial to write
ivory flame
how, is it not just stop() pass in the loop and break
well tell you what, how about you actually try writing one instead of discussing it
like set your current project aside for a moment and just write up a very simple proof of concept
are you even able to make a while true do loop that can be stopped and started at will? - maybe add in ability to pause it too instead of outright stopping?
it's the same as doing task.delay(time, func) and then changing the delay later on
it's a bit awkward to do but it's very powerful pattern
hardy coyote
it's a bit awkward to do but it's very powerful pattern
alr but if its not what you explained, im srry because im kinda busy and words are looking werid to me
1 sec
hardy coyote
well tell you what, how about you actually try writing one instead of discussing...
you cant store a while loop by itself, so i need a task.spawn or corotine right?
ivory flame
you cant store a while loop by itself, so i need a task.spawn or corotine right?
that's one way to do it yeah
its very similar to while true do if break_condition then break end dostuff() end but you get more control over it
hardy coyote
its very similar to `while true do if break_condition then break end dostuff() e...
oh shoot...
i did coroutines
oh my days
im so sorry
im act wasting your time, arent i
ivory flame
local ticker
local dmg
local LoopDelay=0
function OnStep()
print("stepped with damage:",dmg)
end
function Looper()
while true do
OnStep()
task.wait(LoopDelay)
end
end
function StartAdjustLoop(delay,dmgValue)
dmg=dmgValue
if ticker then task.cancel(ticker) end
LoopDelay=delay
ticker=task.delay(delay,Looper)
end
function Stop()
if ticker then ticker=task.cancel(ticker) end
end``` this is a very beginner basic one using a timed delay instead of every tickyou could make stop set a break condition too
similar outcome
the heartbeat one is much nicer though but only relevant if you need it stepping every tick
local ticker
local dmg
function StopLoop()
if ticker then ticker=ticker:Disconnect() end
end
function OnStep()
print("stepped with damage:",dmg)
if math.random(1,100)==1 then StopLoop() end
end
function StartLoop(dmgValue)
dmg=dmgValue
if not ticker then ticker=RunService.Heartbeat:Connect(OnStep) end
end
i see
i dont think ill need a delay
so task.spawn is fine
hardy coyote
the heartbeat one is much nicer though but only relevant if you need it stepping...
I could do that and just check tick() to see if enough time has passed to run code, but wouldnt that just be redundant if while can do the same thing and run less?
ivory flame
```lua
local ticker
local dmg
function StopLoop()
if ticker then ticker=ticker...
notice how repeated calls to the StartLoop function will only update the damage value, it won't create a second loop
hardy coyote
notice how repeated calls to the StartLoop function will only update the damage ...
its so simple
i dont know why i didnt understand
ivory flame
I could do that and just check tick() to see if enough time has passed to run co...
you can but this is lazy way
hardy coyote
you can but this is lazy way
wt abt for performance
ivory flame
don't
hardy coyote
i can yield the while, but not the runservice
hardy coyote
uhhhhhhhhhhhhhhhhhhhhh
okay
alr i understand it now
i should probally experiment with it
ivory flame
i can yield the while, but not the runservice
hence the runservice one is only when you can have every tick
hardy coyote
hence the runservice one is only when you can have every tick
by every tick you mean frame in this context?
ivory flame
the coroutine version of this looks different
you really shouldn't rely on chatgpt for stuff like this
hardy coyote
you really shouldn't rely on chatgpt for stuff like this
what
?
???
i didnt use chatgpt...
i searched up stuff and i thought that coroutines do some of the stuff for me anyways
does it look chatgpt?
wow im bad
ivory flame
local ticker
local dmg
function OnStep()
print("stepped with damage:",dmg)
end
function Looper()
while true do
OnStep()
task.wait(1)
end
end
function Start(dmgValue)
dmg=dmgValue
if not ticker then ticker=task.spawn(Looper) end
end
function Stop()
pcall(task.cancel,ticker)
end``` would be one way to write the coroutine one, but usually with these you should refer to the first one for adjustable wait timer (you can make the next step run sooner if you needed to, whereas with this code you cannot do that)aka this
ivory flame
this on the other hand is ai slop, that's not how you use coroutine.yield
hardy coyote
this on the other hand is ai slop, that's not how you use coroutine.yield
I DIDNT USE AI
i just assumed thats how .yield works
if i used ai it would have turned out much better
ivory flame
i just assumed thats how .yield works
and all you achieved was making an ass out of u and me, read the docs always, even for things that you think are obvious https://create.roblox.com/docs/reference/engine/libraries/coroutine#yield
hardy coyote
and all you achieved was making an ass out of u and me, read the docs always, ev...
yessir
ivory flame
Suspends the execution of the calling coroutine. Any arguments to yield are passed as extra results to resume.
if you want to use a version that uses coroutine.resume then you need much longer context and i think i wrote enough examples of these
ivory flame
```lua
local ticker
local dmg
local LoopDelay=0
function OnStep()
print("stepp...
but in essence you have coroutine.resume in the OnStep function of this outer loop, and OnStep is usually called by some other event like for example coroutine.resume(main_thread) when all of a series of datastore:getasync has returned instead of being in a timer
in other words, you wouldn't use coroutine.resume for a timer unless you made your own scheduler
ivory flame
```lua
local ticker
local dmg
local LoopDelay=0
function OnStep()
print("stepp...
which is just this again
hardy coyote
aight let me try this again
ivory flame
anyway that should be enough for you to shake up how you've been writing these
hardy coyote
anyway that should be enough for you to shake up how you've been writing these
btw could i make this a module to use in a bunch of different scripts
ivory flame
i also offer private tutoring at charge so if you need more and have robux for it lmk
hardy coyote
i also offer private tutoring at charge so if you need more and have robux for i...
will do
ivory flame
btw could i make this a module to use in a bunch of different scripts
of course why wouldnt you
its better to learn the pattern than to just dump it into one structure
because there's lots of different ways to write these and how you write it will change depending on context, a generalized module is not trivial. this is more like a basic concept than something you'd turn into a utility, but you can definitely make utilities out of it.