I'm trying to write a method that produces a Map<BlockPos, Double> containing every block within a certain radius of a given point and their distance to that point. However, it has a very strange problem: if there are 30 blocks within that radius, it will add each of those 30 blocks to the output map... and then return a map contianing 30 copies of a single block, which isn't even within the radius provided. (It's the block with the highest x,y,z coordinates in the original box.)

Does anyone know what's going wrong here? My apologies if this turns out to be me misusing streams rather than an actual Forge issue, but I think there's an equal chance that I'm misunderstanding BlockPos.betweenClosedStream() instead.

   @Override
    public Map<BlockPos, Double> blockMap() {
        //Create a box
        int variation = (int) Math.ceil(radius);
        BlockPos pos1 = new BlockPos(origin.getX()-variation, origin.getY()-variation,origin.getZ()-variation);
        BlockPos pos2 = new BlockPos(origin.getX()+variation, origin.getY()+variation, origin.getZ()+variation);
      	//(pos2 is the block that I end up with many copies of in the map)

        //Put all blocks within that box into a map if they pass a filter
        //Create a map to collect outputs in
        HashMap<BlockPos, Double> output = new HashMap<BlockPos, Double>();
        //Create a stream of blocks
        BlockPos.betweenClosedStream(pos1, pos2)
                //Filter out ones that don't match our criteria
                .filter(c -> distance(c) <= radius)

                //Put the remaining ones into a map:
                .forEach(c -> {
                    //Put the block into the map
                    output.put(c, (double) distance(c));

//                    Log that you've done this. This indicates that many different elements are being placed into the map.
                    LogUtils.getLogger().info("Placing " + c.toShortString() + " into pattern map");
                    LogUtils.getLogger().info("Pattern map has " + output.entrySet().size() + " elements");
                    StringBuilder sb1 = new StringBuilder("Sphere pattern blocks: ");
                    for (BlockPos pos : output.keySet()) {
                        sb1.append("(").append(pos.toShortString()).append("), ");
                    }
                    LogUtils.getLogger().info(sb1.toString());
                });

        //After the loop, do the *exact same* printing of the output. This suddenly shows that the output
        //is full of many copies of the *same* block, which shouldn't even have passed the filter.
        //It's either the first or last block to have been passed into the stream, not sure.
        LogUtils.getLogger().info("Generated a sphere pattern. It has " + output.entrySet().size() + " elements.");
        LogUtils.getLogger().info("Sphere pattern blocks: ");
        StringBuilder sb = new StringBuilder();
        for (BlockPos pos : output.keySet()) {
            sb.append("(").append(pos.toShortString()).append("), ");
        }
        LogUtils.getLogger().info(sb.toString());

        //Return
        return output;
    }

The log then looks like this:

https://imgur.com/4IPVU7i

Edited July 6, 20223 yr by Syric

So I would do something like this? Just checking that I understand what you mean by calling #immutable.

BlockPos.betweenClosedStream(pos1, pos2)
                //Filter out ones that don't match our criteria
                .filter(c -> distance(c) <= radius)

                //Put the remaining ones into a map:
                .forEach(c -> {
                    //Put the block into the map
                    output.put(c.immutable(), (double) distance(c));
                });

Edit: yep, that worked. Thank you!

Edited July 6, 20223 yr by Syric

I am sure many are confused when you used the javadoc convention for naming methods.

Hobbiest programmers have probably never written javadoc. 🙂