[1.8.9] [SOLVED] is Block solid (block-support-physics)

[Bektor]

Hi,

 

I've got a small problem with some solid checks.

 

What should be checked:

 

• if block under StartBlock is solid
  
• if neighbor blocks on xz axis are solid and the neighbor blocks around them on the xz axis
  
• if block under neighbor block is solid and the block under this block
  
• if the neighbor blocks are connected to the StartBlock or a neighbor block who is conncected to the StartBlock or a neighbor blocks which is connected to a neighbor block which is connected to StartBlock and so on
  

 

This mechanism should automatically stop after a specific number of checks on the y axis. (it should never check if a block is above a block, so only y--, never y++)

And it should automatically stop when a specific number of blocks in the x or z direction was scanned.

 

So check for example 5 blocks in +x direction, 5 blocks in -x direction, 5 blocks in +z direction, 5 in -z direction and 25 blocks under them. (stop checking under block xyz when block xyz is not solid)

(please don't tell me that this can be done with recursion, thats how far I got )

 

Thx in advance.

Bektor

[Draco18s]

What are you trying to model?  Are you trying to create some kind of block-support-physics?

[Bektor]

Are you trying to create some kind of block-support-physics?

exactly (just a part of a small block physics system I'm working on)

[Draco18s]

Ok, so.

 

Step 1:

Whatever method you are going to use, make sure that a block does not ask a neighbor if it is supported, because that neighbor will ask the first block if it is supported.

 

Step 2: There's no need to go down more than 1 Y level.  If that block is not actually supported, it will fall when it gets a block update.

 

Note: Step 2 assumes that every block is made support-required, which includes TileEntity blocks, which actually can't be made to fall because of the TileEntity

 

Step 3: What other shortcuts can you take?

 

Here's what I did when I did this:

https://gist.github.com/Draco18s/a1a5d65fe39b8fe85cab

The third shortcut I took was to assume linear support only, no dog legs.

[Bektor]

Ok, so.

 

Step 1:

Whatever method you are going to use, make sure that a block does not ask a neighbor if it is supported, because that neighbor will ask the first block if it is supported.

 

Step 2: There's no need to go down more than 1 Y level.  If that block is not actually supported, it will fall when it gets a block update.

 

Note: Step 2 assumes that every block is made support-required, which includes TileEntity blocks, which actually can't be made to fall because of the TileEntity

 

Step 3: What other shortcuts can you take?

 

Here's what I did when I did this:

https://gist.github.com/Draco18s/a1a5d65fe39b8fe85cab

The third shortcut I took was to assume linear support only, no dog legs.

Thx for the answer.

 

Well, I thought asking the neighbor block would be a good idea because I have to check like 5 blocks in +x direction and 5 in -x direction etc.

So there is a value which tells how long you can build with this block a line in the air when its supported on one side before it collapses because it got to long.

 

The check with the y-level: I thought here of something like this: https://upload.wikimedia.org/wikipedia/commons/c/c7/St_Marys_Church,_Radnage,_Bucks,_England_15th_century_tie-beam_roof.jpg

So with doing such things you can build the whole thing a bit longer. Thats why doing multiply y-checks.

 

To your code: I think for reading it a few comments and better variable names would be nice. (not just one letter for a variable)

 

What do you mean with this?:

The third shortcut I took was to assume linear support only, no dog legs.

 

[Draco18s]

Well, I thought asking the neighbor block would be a good idea because I have to check like 5 blocks in +x direction and 5 in -x direction etc.

So there is a value which tells how long you can build with this block a line in the air when its supported on one side before it collapses because it got to long.

 

Imagine that your block checks in the following order: North, South, East, West.

 

It looks north and finds air, so it moves on.

It finds another block south and asks it if it's supported.

It looks north and finds another block and asks if it's supported.

It looks north and finds air, so it moves on.

It finds another block south and asks it if it's supported.

It looks north and finds another block and asks if it's supported.

It looks north and finds air, so it moves on.

It finds another block south and asks it if it's supported.

It looks north and finds another block and asks if it's supported.

It looks north and finds air, so it moves on.

It finds another block south and asks it if it's supported.

It looks north and finds another block and asks if it's supported.

...[/code]

 

Whoops.  Looks like we found an infinite loop!

Instead, of continually asking, you need to write a non-infinite loop:

 

do {
    look north: if support block there:
        look below that block: if support there:
            return true;
    else add 1 to distance checked
} while(!supported && distance <= 5)

 

Repeat for the other directions.

 

The check with the y-level: I thought here of something like this: https://upload.wikimedia.org/wikipedia/commons/c/c7/St_Marys_Church,_Radnage,_Bucks,_England_15th_century_tie-beam_roof.jpg

So with doing such things you can build the whole thing a bit longer. Thats why doing multiply y-checks.

 

The first block looks below itself and goes "yup, I'm supported."  The second block looks below itself and says "yup, I'm supported."  The third block looks below itself and finds air, but it has support to one side, so it says "yup, I'm supported."  The structure stays intact until a block anywhere finds that it is not supported and falls, every block it was supporting will now fall.

 

To your code: I think for reading it a few comments and better variable names would be nice. (not just one letter for a variable)

 

Sorry about that, it was never written with the intent of being visible.  All it does is loop through the 4 cardinal directions and check up to 6 blocks distant if there's a continuous line of support.

 

What do you mean with this?:

The third shortcut I took was to assume linear support only, no dog legs.

 

Golf term:

https://en.wikipedia.org/wiki/Golf_course#Fairway_and_rough

 

Verb

dogleg

    (intransitive) To bend in the shape of the hind leg of a dog, especially to turn and then turn back in original direction, such as down, right, down.

[Bektor]

Ok, thx. This helped a lot.

It's working now:

 

Just made a list which stores all blocks in one direction (at first just one block). While going through this list

more blocks will be added and finally when a specific value is reached it switches the direction,

does there the same and when all directions are finished it stops.

To not double check a block I made a second list which stores all checked blocks and the

first list checks this list before adding a new block to it. (all blocks in the first list will be checked)

(the complete logic is in a while loop which checks if the list contains blocks or not)