So, I have a block with a TileEntity. All's working fine, except for the main purpose of said TileEntity. I want it to loop through each entity standing on top of the block, and run some code for each one.
 

It doesn't.

I define an AxisAlignedBB:

AxisAlignedBB aabbAbove = new AxisAlignedBB(pos.up());

and use it in my tick() method:

for (LivingEntity ent : world.getEntitiesWithinAABB(LivingEntity.class, aabbAbove)) {
    if(ent.getHealth() > 1) {
        ent.setHealth(ent.getHealth() - 1);
        ent.performHurtAnimation();
        collectedHealth++;
    }
}

but the above for loop never fires... any ideas?

Thanks,

  ~Blocky

Edited May 18, 20205 yr by BlockyPenguin
Solevd

Show more code.

1 hour ago, Draco18s said:

Show more code.

Ok
 

package com.blockypenguin.labkit.tileentities;

import ...

public class HealthCollectorTile extends TileEntity implements ITickableTileEntity, INamedContainerProvider {

    private LazyOptional<IEnergyStorage> energy = LazyOptional.of(this::createEnergy);

    int counter = 10; // 20 ticks is approximately one second, therefore 10 ticks is approximately half a second.
    BlockState newBlockState;
	int collectedHealth = 0;
	Mode mode = Mode.DAMAGE_HEAL;
	
    AxisAlignedBB aabbAbove = new AxisAlignedBB(pos.up());
	
    public HealthCollectorTile() {
        super(ModTiles.HEALTH_COLLECTOR_TILE);
    }

    @Override
    public void tick() {
    	if(world.isRemote())
    		return;

        if (counter <= 0) {
        	for (LivingEntity ent : world.getEntitiesWithinAABB(LivingEntity.class, aabbAbove)) {
        		if(ent.getHealth() > 1) {
        			
        			ent.setHealth(ent.getHealth() - 1);
        			ent.performHurtAnimation();
        			energy.ifPresent(e -> ((CustomEnergyStorage)e).subtractEnergy(100));
        			collectedHealth++;
        			
        		}
			}
        	counter = 10;
        }else {
        	counter--;
            markDirty();
        }
        
        energy.ifPresent(e -> {
        	if(e.getEnergyStored() < 0) {
        		((CustomEnergyStorage) e).setEnergy(0);
        	}
        });
        
    }
    
    // Get data from the NBT
    @SuppressWarnings("unchecked")
	@Override
    public void read(CompoundNBT tag) {
        CompoundNBT energyTag = tag.getCompound("energy");
        energy.ifPresent(e -> ((INBTSerializable<CompoundNBT>) e).deserializeNBT(energyTag));

        counter = tag.getInt("counter");
        collectedHealth = tag.getInt("collectedHealth");
        super.read(tag);
    }
    
    // Send data to the NBT
    @SuppressWarnings("unchecked")
	@Override
    public CompoundNBT write(CompoundNBT tag) {
        energy.ifPresent(h -> {
            CompoundNBT compound = ((INBTSerializable<CompoundNBT>) h).serializeNBT();
            tag.put("energy", compound);
        });

        tag.putInt("counter", counter);
        tag.putInt("collectedHealth", collectedHealth);
        return super.write(tag);
    }
    
    // When creating the energy storage, use CustomEnergyStorage, with a maximum capacity of 100,000FE
    private IEnergyStorage createEnergy() {
        return new CustomEnergyStorage(100000, 0);
    }
    
    @Nonnull
    @Override
    public <T> LazyOptional<T> getCapability(@Nonnull Capability<T> cap, @Nullable Direction side) {
        if (cap == CapabilityEnergy.ENERGY) {
            return energy.cast();
        }
        return super.getCapability(cap, side);
    }

    @Override
    public ITextComponent getDisplayName() {
        return new TranslationTextComponent("container.labkit.health_collector");
    }

    @Nullable
    @Override
    public Container createMenu(int i, PlayerInventory playerInventory, PlayerEntity playerEntity) {
        return new HealthCollectorContainer(i, world, pos, playerInventory, playerEntity);
    }
    
    public static enum Mode {
    	DAMAGE_HEAL,
    	PERMANENT
    }
}

I know Mode doesn't do anything, that's coming later. My goal is to damage the entity every 10 ticks, so long as the entity has more than half a heart of health, and save the amount of damage dealt to colledtedHealth.

Also, as a sidenote, all aesthetics and nice-feeling timings aside, how effective is having a counter at decreasing server lag?

31 minutes ago, BlockyPenguin said:

Also, as a sidenote, all aesthetics and nice-feeling timings aside, how effective is having a counter at decreasing server lag?

A counter is fine, but an another way of doing it would be to increase a number every tick and then use the modulo operator to compare the current value.

So for example, create a ticks field, run ++ticks every tick to increment, then do if (ticks % 10 == 0). It will return true every ten ticks.

The modulo operator is basically a division operator that returns the remainder, so comparing it to zero will only return true if the value is cleanly divisible.

It won't make a noticeable difference performance-wise, but you may find the code to be a little cleaner. It's just a personal preference thing.

2 minutes ago, imacatlolol said:

A counter is fine, but an another way of doing it would be to increase a number every tick and then use the modulo operator to compare the current value.

So for example, create a ticks field, run ++ticks every tick to increment, then do if (ticks % 10 == 0). It will return true every ten ticks.

The modulo operator is basically a division operator that returns the remainder, so comparing it to zero will only return true if the value is cleanly divisible.

It won't make a noticeable difference performance-wise, but you may find the code to be a little cleaner. It's just a personal preference thing.

Ah, nice! I hadn't thought about that! Thanks!

Use breakpoints and debug mode to see what's going on.

Ah, actually I know what the problem is.

5 hours ago, BlockyPenguin said:

AxisAlignedBB aabbAbove = new AxisAlignedBB(pos.up());

This AABB is zero-volume and cannot contain any entities. Look at how vanilla entities like the hopper define their collection volume.

6 hours ago, Draco18s said:

Ah, actually I know what the problem is.

This AABB is zero-volume and cannot contain any entities. Look at how vanilla entities like the hopper define their collection volume.

Ah, ok, thanks! I'l take a look now

Ah, that works! Brilliant, thank you!