if you've played fortnite, whenever you break a build (like a wall, floor, or stair) anything that was connected to that build (i call them tiles) also break since they're not connected to anything anymore. I'm trying to do this in minecraft. Currently, to detect connecting tiles, i have a "roots" and "shoots" system. I "root" tile has the flag "build.shoots" and each "shoot" tile has the flag "build.roots". Currently, it's working the way i want it to. but im having trouble figuring out the next step. For example, whenever a tile that's in between a root and a nonroot (vertically), even though there's no tile connecting the remaining root and shoots, the flags indicate that the remaining shoot belongs to the root and vice versa.
#(nimsy) how to make a domino effect when breaking tiles?
slate turret
tropic moonBOT
(nimsy) how to make a domino effect when breaking tiles?
tropic moonBOT
if you've played fortnite, whenever you break a build (like a wall, floor, or st...
Hi I'm AutoThreadBot! Don't mind me, I'll just be adding the helper team to this thread so they can see it. A human will get to you soon.
You can block this bot if you don't want to see these messages, I won't mind.
<@&525394568410038282>
slate turret
!haste
wild sonnet
tropic moonBOT
slate turret
Yo idk if this thread is being ignored or not
crystal turtle
Why not just do a custom flood fill?
Start from the broken block, and moving up and out, find each fortnite tile, and keep going until they either connect with the ground, or don't
If they do, break, if not, breakn't
slate turret
i was doing that for a while
but the problem is up and out doesn't work
lemme give u a scenario
if i broke a simple structure like this, it would work
but lets say i break the circled tile
nothing else should break, because it's connected to another root
crystal turtle
Right, did you miss the breakn't step?
slate turret
?
crystal turtle
slate turret
Start from the broken block, and moving up and out, find each fortnite tile, and...
ok but how would i do this?
wouldn't i need a while or something?
because who knows how many branches of tiles there are
crystal turtle
If any part of the structure is touching a non build able material, you can stop the loop. It's touching the ground, no need to keep checking
slate turret
yeah but that's the problem
crystal turtle
What's the problem?
slate turret
right now, when i break the tile in the middle, the bottom tile still thinks the top tile is connected to it and vice versa
crystal turtle
Why? When you flood fill, the two structures you fill into are two seperate structures
slate turret
what's flood fill?
crystal turtle
I mean it in a generic sense. You have a block, you get the six surrounding blocks. Then for each block, you get it's six surrounding blocks, and deduplicate the list. so on and so forth
slate turret
yeah but im confused on how the itteration should work
crystal turtle
So you just keep doing that, but in your case, you're checking your tiles instead of individual blocks.
slate turret
wouldn't it be a while?
crystal turtle
A while loop? Ya
slate turret
Start from the broken block, and moving up and out, find each fortnite tile, and...
it's more complicated than this tho
how would i check if it's connected to the ground or not?
i mean i already have a proc for it, but im saying how would i check that a tile that's in the air is indirectly connected to a tile that's connected to the ground?
also, how should i go about my connecting tiles system? should i use flags or just calculate it on the whim?
crystal turtle
if a tile is on the air, and there's no tile directly below it, then it's not connected to the one on the ground. each tile only needs to worry about the one directly around it. as far as you're connecting tiles system? it would be easier to calculate it on the fly.
slate turret
if a tile is on the air, and there's no tile directly below it, then it's not co...
so just forget about the whole tile flagging system?
crystal turtle
yeah, that's overcomplicated and not necessary. I already described this earlier, you should only need to check a few locations in every 5x5x5 tile to determine if one of your structures is there or not. You don't need to flag them
slate turret
can i not just do something like
- define nearby_tiles <[center].find_blocks_flagged[build.structure].within[5].parse[flag[build.structure]].deduplicate.exclude[<[tile]>]>
wait
- define nearby_tiles <[center].find_blocks_flagged[build.structure].within[5].parse[flag[build.structure]].deduplicate.exclude[<[tile]>]>
- define connecting_tiles <[nearby_tiles].filter[intersects[<[tile]>]]>
like that
but i fear if i do that for every tile, it'll be pretty heavy
bitter girder
How were you thinking you'd identify the tiles, jump? Match them manually block-for-block?
slate turret
she said id just have to check a few locations
bitter girder
can people build normally in this world
slate turret
no
slate turret
so...
would i have to put each branch in a while loop?
oh god
this is giving me a headache
i forgot there could literally be branches of branches
and so on
like this
yea i think the flag system would be much easier jump
rather than calculating it on the fly
actually, now that i think of it, i dont think it'd make a difference
it'd still be hard either way
crystal turtle
How were you thinking you'd identify the tiles, jump? Match them manually block-...
Each tile has a block/a couple blocks in a location that doesn't overlap with another tile. So he only need to check one or two locations per 5x5x5 area to determine if one of his tiles was there.
crystal turtle
Ya, pretty much that
slate turret
but the problem is, not all tiles are 5x5x5
crystal turtle
Wdym?
crystal turtle
When I say 5x5x5, I mean that if a tile is in a location, it fills that location.
I'm not talking about it's actual footprint in the world
You couldn't put down stairs and a pyramid in the same spot, for example.
slate turret
yea but their centers are also 5x0x5 and 5x5x0 respectively
crystal turtle
Literally no idea what you're trying to say here
slate turret
whatever
forget about the whole "checking to see if there are any direclty connected tiles to that tiles"
i already know how to do that
my brain just hurts thinking about the while system
crystal turtle
??? Why?
slate turret
i did it before, but i dont think i did it right
crystal turtle
Gotcha, so you're primed to do it a certain way, that makes sense.
slate turret
nono im open to anything
im just saying like
it would bea foreach in a foreach in a foreach infinitely until there's nothing to foreach
crystal turtle
it would bea foreach in a foreach in a foreach infinitely until there's nothing...
If you ever run into a situation where you think you have infinite loops, then that means something isn't in the loop that should be.
slate turret
well it wouldn't be infinite
im just saying we don't know/shouldn't know when it stops
and that's why it has to be a while
crystal turtle
im just saying we don't know/shouldn't know when it stops
Yes, when you've checked each tile, and there's no more connections
slate turret
ye
how can i type that though?
because wouldn't i need a while for each branch?
and each branch can have sub branches and so on?
crystal turtle
- Get tile
- If touching ground, all touching tiles are good
- Get all surrounding tiles
- If no surrounding tiles, break every touching tile
- Go to step 1
If you throw this part into a task, then you can just run it for each tile. So it can be simplified even more to "For each tile, run grounded_or_sibling", if any of the runs return true, break structure
slate turret
ok so
for step 1
assuming <[center]> and <[tile]> belong to the tile we just removed (by hand)
crystal turtle
Sure
slate turret
- define nearby_tiles <[center].find_blocks_flagged[build.structure].within[5].parse[flag[build.structure]].deduplicate.exclude[<[tile]>]>
- define connected_tiles <[nearby_tiles].filter[intersects[<[tile]>]].filter[center.y.equals[OR_MORE].than[<[center].y>]]>
<[connected_tiles]> would be the original branching out tiles
these
crystal turtle
Okay, following
slate turret
step 2
- define branched_tiles:->:<[c_tile]>
this list would represent all the branched tiles from each of those tiles circled above
crystal turtle
Uhm, sure, you can do that
slate turret
i edited
crystal turtle
Ah, ya, that makes sense
slate turret
ok now
crystal turtle
But also, remember that each initial branch off of the center tile is it's own structure, initially.
slate turret
yea
crystal turtle
Because left, right and down might connect to the floor somewhere else, but above never would.
slate turret
yea but what if the initial branches eventually reconnect?
crystal turtle
So adding all the connected branch tiles to a single list gets rid of the distinction
Then that's fine
slate turret
```
- define branched_tiles:->:<[c_tile]>
```
this list would represent all the ...
starting from here
i changed definitions
slate turret
<[connected_tiles]> would be the original branching out tiles
i changed this to initial_branched_tiles instead, and ill be using connected_tiles for the tiles that are connected to the initial_branched_tiles to clear up confusion
fuck
this is hard to sorta explain without being in a call or something ngl
- foreach <[initial_branch_tiles]> as:i_tile:
- define branched_tiles <list[]>
- define center <[i_tile].center.flag[build.center]>
- define type <[center].flag[build.type]>
- define branched_tiles <[branched_tiles].include[<[i_tile]>]>
#if root, everything connected to this structure is fine
- if <proc[is_root].context[<[center]>|<[type]>]>:
- foreach next
I mean, I explained it to you, you're the one who would write it.
slate turret
```
- foreach <[initial_branch_tiles]> as:i_tile:
- define branched_t...
this is what i have so far
next up is the while
crystal turtle
What does "is_root" do?
slate turret
checks if it's connected to the ground
crystal turtle
Ah, gotcha
slate turret
honestly i might have to make a proc for finding connected tiles via the intersects method too, but im thinking of maybe using a flag system instead to make it a bit lighter
- foreach <[initial_branch_tiles]> as:i_tile:
- define has_root False
- define branched_tiles <list[]>
- define center <[i_tile].center.flag[build.center]>
- define type <[center].flag[build.type]>
- define branched_tiles <[branched_tiles].include[<[i_tile]>]>
#if root, everything connected to this structure is fine
- if <proc[is_root].context[<[center]>|<[type]>]>:
- foreach next
- define nearby_tiles <[center].find_blocks_flagged[build.structure].within[5].parse[flag[build.structure]].deduplicate>
- define connected_tiles <[nearby_tiles].filter[intersects[<[i_tile]>]]>
- while <[connected_tiles].any> && !<player.has_flag[test]>:
- define branched_tiles <[branched_tiles].include[<[connected_tiles]>]>
- define new_connected_tiles <list[]>
- foreach <[connected_tiles]> as:c_tile:
- define center <[c_tile].center.flag[build.center]>
- define type <[center].flag[build.type]>
#if it's a root, then everything is chilling
- if <proc[is_root].context[<[center]>|<[type]>]>:
- define has_root True
- while stop
#this time, the nearby tiles will INCLUDE its own tile
- define nearby_tiles <[center].find_blocks_flagged[build.structure].within[5].parse[flag[build.structure]].deduplicate>
- define next_tiles <[nearby_tiles].filter[intersects[<[c_tile]>]]>
- define connected_tiles <[connected_tiles].include[<[next_tiles]>]>
- define connected_tiles <[connected_tiles].deduplicate>
- if <[has_root]>:
- foreach next
- narrate "remove <[branched_tiles].size> tiles"
!haste
slate turret
alright @crystal turtle https://paste.denizenscript.com/View/106948
i really dont know if this is right
bro
the second i tried using the script, my PC started sounding like a fucking jet engine 😂
as i expected, something is wrong lol
i think it might be because it's reusing previous tiles too
crystal turtle
yup. Give me a second, I'll clean this up for you which might help you get a clearer idea
crystal turtle
Alright, here ```yaml
#get_tile is a proc that takes a location, and returns the 5x5x5 tile that it's in.
#get_surrounding_tiles takes a tile and returns each tile on the six cardinals.
- define broken_tile <proc[get_tile].context[<[initial_break_location]>]>
- define branches <proc[get_surrounding_tiles].context[<[broken_tile]>]>
#There's only six branches (or less) for each cardinal
#direction, so we use a foreach, and go through each one.
-
foreach <[branches]> as:starting_tile:
#The tiles to check are a list of tiles that we need to get siblings of.
#Each tile in this list gets checked once, and removed.- define tiles_to_check <list[<[starting_tile]>]>
#The structure is a list of every tile in a single continous structure.
#When you determine that a group of tiles needs to be broken, you'll go through this list. - define structure <list[<[starting_tile]>]>
#The two above lists are emptied at the start of each while loop,
#so that way previous tiles from other branches don't bleed into this one.- while <[tiles_to_check].any>:
#Just grab the tile on top of the pile. It doesn't matter the order
#in which we check, we'll get to them all eventually, unless the
#strucure is touching the ground, in which case it doesn't really
#matter.- define tile <[tiles_to_check].last>
#If the tile is touching the ground, then skip this branch. The
#tiles_to_check and structure lists get flushed out and we start
#on the next branch. When we next the foreach, we are
#also breaking out of the while, so we don't need to worry about
#keeping track (like you had with has_root) - foreach next if:<proc[is_root].context[<[tile]>]>
#If the tile ISN'T touching the ground, then first, we remove it
#from the tiles to check list, because obvi we've already checked
#it. - define tiles_to_check:<-:<[tile]>
#Next, we get every surrounding tile, but only if they're not already
#in the structure list. That means that we don't keep rechecking tiles
#we've already checked. - define surrounding_tiles <proc[get_surrounding_tiles].context[<[tile]>].exclude[<[structure]>]>
#We add all these new tiles to the structure, and since we already excluded
#the previous list of tiles in the structure, we don't need to deduplicate. - define structure:|:<[surrounding_tiles]>
#Since these are all new tiles, we need to check them as well. - define tiles_to_check:|:<[surrounding_tiles]>
#If we get to this point, then that means we didn't skip out early with foreach.
#That means we know it's not touching ground anywhere, so now we want to break
#each tile. So we go through the structure list, and break each one (however you handle that.)
- define tile <[tiles_to_check].last>
- foreach <[structure]> as:tile:
- run break_tile def.tile:<[tile]>```
- define tiles_to_check <list[<[starting_tile]>]>
So obviously, a lot of this is abstracted. For two reasons, I don't want to make you have to do something that breaks your previous system (like you using flags over checking locations manually), but also because it makes it a lot easier to follow along with what you're actually trying to accomplish, at a high level.
slate turret
yea idk why this was such a hard concept for me to grasp
ill try it out rn, sorry for the wait
also ty for this spacing trick, didn't know about it
slate turret
finally got it to work jump
i had to sneak in 1 extra line in there after i finally found the culprit that flooded my console with errors
added this before the root check
- foreach next if:!<[tile].center.has_flag[build.center]>
that way, if it was removed, (since i remove the flags when i remove the tile), it means that branch was already destroyed
my only concern now is performance issues
!haste
bitter girder
added this before the root check
```
- foreach next if:!<[tile].cent...
did uhh
you test this?
I'm not certain, but i don't think ! works with the if arg
violet void
It does iirc
crystal turtle
I mean, best way to check performance is to run it, and check it with spark or some sort of profiler.
eternal shoal