A simple optimization please?

[thebest108]

The method the game uses to check for collisions between entities is *slightly* inefficient, and in my case slows down my code by a lot.

 

The method called World.getEntitiesWithinAABB() that takes in a filter goes down to this chunk method

public void getEntitiesOfTypeWithinAAAB(Class entityClass, AxisAlignedBB aabb, List listToFill, Predicate p_177430_4_)
    {
        int i = MathHelper.floor_double((aabb.minY - World.MAX_ENTITY_RADIUS) / 16.0D);
        int j = MathHelper.floor_double((aabb.maxY + World.MAX_ENTITY_RADIUS) / 16.0D);
        i = MathHelper.clamp_int(i, 0, this.entityLists.length - 1);
        j = MathHelper.clamp_int(j, 0, this.entityLists.length - 1);

        for (int k = i; k <= j; ++k)
        {
            Iterator iterator = this.entityLists[k].func_180215_b(entityClass).iterator();

            while (iterator.hasNext())
            {
                Entity entity = (Entity)iterator.next();

                if (entity.getEntityBoundingBox().intersectsWith(aabb) && (p_177430_4_ == null || p_177430_4_.apply(entity)))
                {
                    listToFill.add(entity);
                }
            }
        }
    }

 

My suggestion is to move the predicate checker 1 step higher to something like this

 

public void getEntitiesOfTypeWithinAAAB(Class entityClass, AxisAlignedBB aabb, List listToFill, Predicate p_177430_4_)
    {
        int i = MathHelper.floor_double((aabb.minY - World.MAX_ENTITY_RADIUS) / 16.0D);
        int j = MathHelper.floor_double((aabb.maxY + World.MAX_ENTITY_RADIUS) / 16.0D);
        i = MathHelper.clamp_int(i, 0, this.entityLists.length - 1);
        j = MathHelper.clamp_int(j, 0, this.entityLists.length - 1);

        for (int k = i; k <= j; ++k)
        {
            Iterator iterator = this.entityLists[k].func_180215_b(entityClass).iterator();

            while (iterator.hasNext())
            {
                Entity entity = (Entity)iterator.next();
                if(p_177430_4_ == null || p_177430_4_.apply(entity)){
                     if (entity.getEntityBoundingBox().intersectsWith(aabb) && ()
                     {
                           listToFill.add(entity);
                     }
               }
            }
        }
    }

 

This code does Exactly the same thing but it avoids unnecessary intercept calculations.

 

In my case where I have thousands of entities that use a complex intercept calculation this slows things down by a lot.

 

Please change, its a performance improvement for everybody!

[LexManos]

Thats the thing tho, the intersection calculations should be the SIMPLE part of that statement.

As it should be simple 'is this box inside this other box'

The predicate is the expensive part which usually ends up doing inheritance checking or other things.

So what you're proposing us do si actually make it less efficient for the proper use cases...

[Ernio]

@thebest108 - bro, you know you should not use thousands of entities just to make one entity have multiple hitBoxes.

From your previous posts I can tell this goes under bad design. You have entites assigned to one entity and you make server not even update those sub-entities, that is literally missing the point of making entities. Making multipart entity is not that hard Why you choose such workaround?