Fields: Add a bunch of utility code for offsets and calculations

Author: robotgryphon

src/main/java/com/robotgryphon/compactcrafting/blocks/FieldProjectorBlock.java

@@ -2,27 +2,35 @@
 
 import com.robotgryphon.compactcrafting.blocks.tiles.FieldProjectorTile;
 import com.robotgryphon.compactcrafting.core.Registration;
+import com.robotgryphon.compactcrafting.field.ProjectorHelper;
 import mcjty.theoneprobe.api.IProbeHitData;
 import mcjty.theoneprobe.api.IProbeInfo;
 import mcjty.theoneprobe.api.IProbeInfoProvider;
 import mcjty.theoneprobe.api.ProbeMode;
 import net.minecraft.block.Block;
-import net.minecraft.block.BlockRenderType;
 import net.minecraft.block.BlockState;
 import net.minecraft.entity.LivingEntity;
 import net.minecraft.entity.player.PlayerEntity;
 import net.minecraft.item.ItemStack;
+import net.minecraft.particles.ParticleTypes;
 import net.minecraft.state.DirectionProperty;
 import net.minecraft.state.StateContainer;
 import net.minecraft.tileentity.TileEntity;
+import net.minecraft.util.ActionResultType;
 import net.minecraft.util.Direction;
+import net.minecraft.util.Hand;
 import net.minecraft.util.math.BlockPos;
+import net.minecraft.util.math.BlockRayTraceResult;
 import net.minecraft.util.math.shapes.VoxelShape;
 import net.minecraft.util.math.shapes.VoxelShapes;
 import net.minecraft.world.IBlockReader;
+import net.minecraft.world.IWorld;
+import net.minecraft.world.IWorldReader;
 import net.minecraft.world.World;
+import net.minecraft.world.server.ServerWorld;
 
 import javax.annotation.Nullable;
+import java.util.Optional;
 
 public class FieldProjectorBlock extends Block implements IProbeInfoProvider  {
 
@@ -35,6 +43,17 @@ public FieldProjectorBlock(Properties properties) {
             .with(FACING, Direction.NORTH));
     }
 
+    public static Optional<Direction> getDirection(IWorldReader world, BlockPos position) {
+        BlockState positionState = world.getBlockState(position);
+
+        // The passed block position was not a field projector, cannot continue
+        if (!(positionState.getBlock() instanceof FieldProjectorBlock))
+            return Optional.empty();
+
+        Direction facing = positionState.get(FieldProjectorBlock.FACING);
+        return Optional.of(facing);
+    }
+
     @Override
     public VoxelShape getRenderShape(BlockState state, IBlockReader worldIn, BlockPos pos) {
         return VoxelShapes.empty();
@@ -67,6 +86,37 @@ public void addProbeInfo(ProbeMode probeMode, IProbeInfo iProbeInfo, PlayerEntit
 
     }
 
+    @Override
+    public ActionResultType onBlockActivated(BlockState state, World world, BlockPos pos, PlayerEntity player, Hand handIn, BlockRayTraceResult hit) {
+        if(world.isRemote)
+            return ActionResultType.PASS;
+
+        FieldProjectorTile tile = (FieldProjectorTile) world.getTileEntity(pos);
+
+        // Shouldn't happen, but safety
+        if(tile == null)
+            return ActionResultType.PASS;
+
+        Optional<BlockPos> oppositeProjector = tile.getOppositeProjector();
+        if(!oppositeProjector.isPresent()) {
+            // Spawn particle in valid places
+
+            ProjectorHelper.getValidOppositePositions(world, pos)
+                .forEach(opp -> {
+                    ((ServerWorld) world).spawnParticle(ParticleTypes.BARRIER,
+                            opp.getX() + 0.5f,
+                            opp.getY() + 0.5f,
+                            opp.getZ() + 0.5f,
+                            1,
+                            0, 0, 0, 0);
+                });
+
+            return ActionResultType.SUCCESS;
+        }
+
+        return ActionResultType.PASS;
+    }
+
     @Override
     public void onBlockPlacedBy(World worldIn, BlockPos pos, BlockState state, @Nullable LivingEntity placer, ItemStack stack) {
         Direction facing = placer.getHorizontalFacing();
@@ -75,4 +125,27 @@ public void onBlockPlacedBy(World worldIn, BlockPos pos, BlockState state, @Null
 
         // Add owner information to field projector
     }
+
+    @Override
+    public void onPlayerDestroy(IWorld world, BlockPos pos, BlockState state) {
+
+        if(world.isRemote())
+            return;
+
+        FieldProjectorTile te = (FieldProjectorTile) world.getTileEntity(pos);
+        if(te == null)
+            return;
+
+        if(!te.isMainProjector()) {
+            Optional<BlockPos> mainProjectorPosition = te.getMainProjectorPosition();
+            if(!mainProjectorPosition.isPresent())
+                return;
+
+            FieldProjectorTile mainProjectorTE = (FieldProjectorTile) world.getTileEntity(mainProjectorPosition.get());
+            if(mainProjectorTE == null)
+                return;
+
+            mainProjectorTE.invalidateField();
+        }
+    }
 }

src/main/java/com/robotgryphon/compactcrafting/blocks/tiles/FieldProjectorTile.java

@@ -1,82 +1,41 @@
 package com.robotgryphon.compactcrafting.blocks.tiles;
 
-import com.robotgryphon.compactcrafting.CompactCrafting;
 import com.robotgryphon.compactcrafting.blocks.FieldProjectorBlock;
-import com.robotgryphon.compactcrafting.core.FieldProjectionSize;
+import com.robotgryphon.compactcrafting.field.FieldProjection;
+import com.robotgryphon.compactcrafting.field.FieldProjectionSize;
 import com.robotgryphon.compactcrafting.core.Registration;
 import com.robotgryphon.compactcrafting.crafting.CraftingHelper;
 import net.minecraft.block.BlockState;
 import net.minecraft.entity.item.ItemEntity;
-import net.minecraft.entity.player.PlayerEntity;
 import net.minecraft.item.Item;
 import net.minecraft.item.ItemStack;
 import net.minecraft.item.Items;
-import net.minecraft.particles.ParticleTypes;
 import net.minecraft.tileentity.ITickableTileEntity;
 import net.minecraft.tileentity.TileEntity;
-import net.minecraft.tileentity.TileEntityType;
 import net.minecraft.util.Direction;
 import net.minecraft.util.math.AxisAlignedBB;
 import net.minecraft.util.math.BlockPos;
-import net.minecraft.util.math.vector.Vector3d;
-import net.minecraft.util.math.vector.Vector3f;
-import net.minecraft.util.math.vector.Vector3i;
-import net.minecraftforge.items.ItemHandlerHelper;
 
+import java.time.Instant;
 import java.util.*;
 import java.util.stream.Collectors;
-import java.util.stream.Stream;
 
 public class FieldProjectorTile extends TileEntity implements ITickableTileEntity {
 
-    private FieldProjectionSize projectionSize = FieldProjectionSize.MEDIUM;
+    private boolean isCrafting = false;
+    private Optional<FieldProjection> field = Optional.empty();
+    private int fieldCheckTimeout = 0;
 
     public FieldProjectorTile() {
         super(Registration.FIELD_PROJECTOR_TILE.get());
     }
 
-    public Optional<BlockPos> getCenter() {
-        BlockState bs = this.getBlockState();
-        Direction facing = bs.get(FieldProjectorBlock.FACING);
-
-
-        Optional<BlockPos> location = getOppositeProjector();
-        if (location.isPresent()) {
-            BlockPos opp = location.get();
-            int centerOffset = opp.manhattanDistance(pos);
-
-            BlockPos center = pos.offset(facing, centerOffset / 2);
-            return Optional.of(center);
-        } else {
-            // No center -- no found opposite
-            return Optional.empty();
-        }
-    }
-
-    public Optional<FieldProjectionSize> getFieldSize() {
-        BlockState bs = this.getBlockState();
-        Direction facing = bs.get(FieldProjectorBlock.FACING);
-
-        Optional<FieldProjectionSize> matchedSize = Arrays
-                .stream(FieldProjectionSize.values())
-                .sorted(Comparator.comparingInt(FieldProjectionSize::getOffset))
-                .filter(size -> {
-                    // check block exists in offset position
-                    BlockPos offsetInDirection = pos.offset(facing, size.getOffset() + 1);
-                    BlockState stateInPos = world.getBlockState(offsetInDirection);
-
-                    if (stateInPos.getBlock() instanceof FieldProjectorBlock) {
-                        // We have a field projector
-                        Direction otherFpDirection = stateInPos.get(FieldProjectorBlock.FACING);
-                        if (otherFpDirection == facing.getOpposite())
-                            return true;
-                    }
-
-                    return false;
-                })
-                .findFirst();
+    @Override
+    public void remove() {
+        super.remove();
 
-        return matchedSize;
+        // Invalidate field
+        invalidateField();
     }
 
     /**
@@ -85,15 +44,16 @@ public Optional<FieldProjectionSize> getFieldSize() {
      * @return
      */
     public Optional<BlockPos> getOppositeProjector() {
-        Optional<FieldProjectionSize> size = getFieldSize();
-        if(size.isPresent()) {
-            int offset = size.get().getOffset() + 1;
-            BlockPos opposite = getPos().offset(getFacing(), offset);
+        if (!field.isPresent())
+            return Optional.empty();
 
-            return Optional.of(opposite);
-        }
+        FieldProjection field = this.field.get();
+        FieldProjectionSize size = field.getFieldSize();
 
-        return Optional.empty();
+        int offset = (size.getOffset() * 2) + 1;
+        BlockPos opposite = getPos().offset(getFacing(), offset);
+
+        return Optional.of(opposite);
     }
 
     public Direction getFacing() {
@@ -115,49 +75,87 @@ public boolean isMainProjector() {
         return side == Direction.NORTH;
     }
 
+    public Optional<BlockPos> getMainProjectorPosition() {
+        if (this.isMainProjector())
+            return Optional.of(this.pos);
+
+        if (this.field.isPresent()) {
+            FieldProjection fp = this.field.get();
+            BlockPos north = fp.getProjectorInDirection(Direction.NORTH);
+
+            return Optional.of(north);
+        }
+
+        return Optional.empty();
+    }
+
+    public void invalidateField() {
+        this.field = Optional.empty();
+        this.fieldCheckTimeout = 20;
+    }
+
     @Override
     public void tick() {
-        if (!isMainProjector())
-            return;
-
-        Optional<AxisAlignedBB> fieldBounds = getFieldBounds();
-        if (fieldBounds.isPresent()) {
-            // TODO: Check crafting state of projection field, update that state instead of doing manual work here
-            boolean hasCatalyst = hasCatalystInBounds(fieldBounds.get(), Items.ENDER_PEARL);
-
-            if (hasCatalyst) {
-                List<ItemEntity> enderPearls = getCatalystsInField(fieldBounds.get(), Items.ENDER_PEARL);
-
-                // We dropped an ender pearl in - are there any blocks in the field?
-                // If so, we'll need to check the recipes -- but for now we just use it to
-                // not delete the item if there's nothing in here
-                if (CraftingHelper.hasBlocksInField(world, fieldBounds.get())) {
-                    CraftingHelper.deleteCraftingBlocks(world, fieldBounds.get());
-                    CraftingHelper.consumeCatalystItem(enderPearls.get(0), 1);
-                }
+        // If we don't have a valid field, search again
+        if (!field.isPresent()) {
+            if (fieldCheckTimeout > 0) {
+                fieldCheckTimeout--;
+                return;
             }
+
+            // Check timeout has elapsed, run field scan
+            doFieldCheck();
+
+            // If we still don't have a valid field, get out of tick logic
+            if (!field.isPresent())
+                return;
+        }
+
+        if (fieldCheckTimeout > 0) {
+            fieldCheckTimeout--;
+        } else {
+            doFieldCheck();
         }
     }
 
-    private Optional<AxisAlignedBB> getFieldBounds() {
-        Optional<BlockPos> center = getCenter();
+    /**
+     * Invalidates the current field projection and attempts to rebuild it from this position as an initial.
+     */
+    private void doFieldCheck() {
+        Optional<FieldProjection> field = FieldProjection.tryCreateFromPosition(world, this.pos);
+        if (field.isPresent()) {
+            this.field = field;
+            return;
+        }
 
-        // No center area - no other projector present
-        if (!center.isPresent())
-            return Optional.empty();
+        this.field = Optional.empty();
 
-        BlockPos centerPos = center.get();
-        Optional<FieldProjectionSize> size = this.getFieldSize();
-        if(size.isPresent()) {
-            AxisAlignedBB bounds = new AxisAlignedBB(centerPos).grow(size.get().getSize());
+        // If we didn't find a valid field, restart timer and keep looking
+        fieldCheckTimeout = 20;
+    }
 
-            return Optional.of(bounds);
-        }
+    private void beginCraft() {
+        this.isCrafting = true;
+    }
 
-        // No valid field found
-        return Optional.empty();
+    private void tickCrafting() {
+        FieldProjection fp = this.field.get();
+        Optional<AxisAlignedBB> fieldBounds = fp.getBounds();
+
+        List<ItemEntity> enderPearls = getCatalystsInField(fieldBounds.get(), Items.ENDER_PEARL);
+
+        // We dropped an ender pearl in - are there any blocks in the field?
+        // If so, we'll need to check the recipes -- but for now we just use it to
+        // not delete the item if there's nothing in here
+        if (CraftingHelper.hasBlocksInField(world, fieldBounds.get())) {
+            CraftingHelper.deleteCraftingBlocks(world, fieldBounds.get());
+            CraftingHelper.consumeCatalystItem(enderPearls.get(0), 1);
+
+            this.isCrafting = false;
+        }
     }
 
+
     private List<ItemEntity> getCatalystsInField(AxisAlignedBB fieldBounds, Item itemFilter) {
         List<ItemEntity> itemsInRange = world.getEntitiesWithinAABB(ItemEntity.class, fieldBounds);
         return itemsInRange.stream()
@@ -180,7 +178,6 @@ private boolean hasCatalystInBounds(AxisAlignedBB bounds, Item itemFilter) {
 
     private int collectItems(List<ItemEntity> itemsInRange) {
         return itemsInRange.stream()
-                // .filter(ise -> ise.getItem().getItem() == item)
                 .map(ItemEntity::getItem)
                 .map(ItemStack::getCount)
                 .mapToInt(Integer::intValue)
@@ -189,11 +186,20 @@ private int collectItems(List<ItemEntity> itemsInRange) {
 
     @Override
     public AxisAlignedBB getRenderBoundingBox() {
-        Optional<AxisAlignedBB> field = this.getFieldBounds();
-        if (field.isPresent()) {
-            return field.get().grow(10);
+        // Check - if we have a valid field use the entire field plus space
+        // Otherwise just use the super implementation
+        if (this.field.isPresent()) {
+            FieldProjection fp = this.field.get();
+            if (!fp.getBounds().isPresent())
+                return super.getRenderBoundingBox();
+
+            return fp.getBounds().get().grow(10);
         }
 
         return super.getRenderBoundingBox();
     }
+
+    public Optional<FieldProjection> getField() {
+        return this.field;
+    }
 }