Improved placement of Field Projectors

Changed the basic logic how the rotation of a field projector is
determined. It is now using the hitpos on the block you are building
on, which makes it possible to place FPs facing any direction
independent of the player position.

Fixes #345

Author: davenonymous

src/main/java/org/dave/compactmachines3/block/BlockFieldProjector.java

@@ -13,12 +13,15 @@
 import net.minecraft.entity.EntityLivingBase;
 import net.minecraft.entity.player.EntityPlayer;
 import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraft.init.Blocks;
 import net.minecraft.item.Item;
 import net.minecraft.item.ItemStack;
 import net.minecraft.tileentity.TileEntity;
 import net.minecraft.util.EnumFacing;
 import net.minecraft.util.EnumHand;
 import net.minecraft.util.math.BlockPos;
+import net.minecraft.util.math.RayTraceResult;
+import net.minecraft.util.math.Vec3d;
 import net.minecraft.util.text.TextComponentTranslation;
 import net.minecraft.world.IBlockAccess;
 import net.minecraft.world.World;
@@ -30,6 +33,7 @@
 import org.dave.compactmachines3.miniaturization.MultiblockRecipe;
 import org.dave.compactmachines3.miniaturization.MultiblockRecipes;
 import org.dave.compactmachines3.misc.CreativeTabCompactMachines3;
+import org.dave.compactmachines3.misc.RotationTools;
 import org.dave.compactmachines3.network.MessageParticleBlockMarker;
 import org.dave.compactmachines3.network.PackageHandler;
 import org.dave.compactmachines3.render.TESRFieldProjector;
@@ -180,15 +184,29 @@ public boolean isOpaqueCube(IBlockState state) {
 
     @Override
     public void onBlockPlacedBy(World world, BlockPos pos, IBlockState state, EntityLivingBase placer, ItemStack stack) {
-        world.setBlockState(pos, state.withProperty(FACING, getFacingFromEntity(pos, placer)), 2);
+        // Make sure the block is rotated properly
+        world.setBlockState(pos, Blocks.AIR.getDefaultState());
+        float blockReachDistance = 6.0F;
 
+        Vec3d posVec = placer.getPositionEyes(1.0f);
+        Vec3d lookVec = placer.getLook(1.0f);
+        Vec3d endVec = posVec.add(lookVec.scale(blockReachDistance));
+        RayTraceResult trace = world.rayTraceBlocks(posVec, endVec);
+
+        Vec3d hitPosition = trace.hitVec;
+        hitPosition = hitPosition.subtract(new Vec3d(trace.getBlockPos()));
+        hitPosition = hitPosition.subtract(0.5d, 0.5d, 0.5d);
+
+        world.setBlockState(pos, state.withProperty(FACING, RotationTools.getFacingByTriangle(hitPosition)), 2);
+
+        // Then copy tile entity data to the block
         if(!(world.getTileEntity(pos) instanceof TileEntityFieldProjector)) {
             return;
         }
 
         TileEntityFieldProjector teProjector = (TileEntityFieldProjector) world.getTileEntity(pos);
         if(stack.hasTagCompound()) {
-            if(stack.getTagCompound().hasKey("owner")) {
+            if(stack.getTagCompound().hasKey("ownerLeast") && stack.getTagCompound().hasKey("ownerMost")) {
                 teProjector.setOwner(stack.getTagCompound().getUniqueId("owner"));
             }
         }

src/main/java/org/dave/compactmachines3/misc/PlayerEventHandler.java

@@ -1,21 +1,29 @@
 package org.dave.compactmachines3.misc;
 
+import net.minecraft.client.Minecraft;
 import net.minecraft.entity.player.EntityPlayer;
 import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraft.item.ItemBlock;
+import net.minecraft.item.ItemStack;
 import net.minecraft.potion.Potion;
 import net.minecraft.potion.PotionEffect;
+import net.minecraft.util.EnumFacing;
+import net.minecraft.util.EnumHand;
 import net.minecraft.util.math.AxisAlignedBB;
 import net.minecraft.util.math.BlockPos;
+import net.minecraft.util.math.RayTraceResult;
 import net.minecraft.util.math.Vec3d;
 import net.minecraft.util.text.TextComponentTranslation;
 import net.minecraftforge.client.event.GuiOpenEvent;
+import net.minecraftforge.client.event.RenderWorldLastEvent;
 import net.minecraftforge.event.entity.player.PlayerSleepInBedEvent;
 import net.minecraftforge.fml.common.eventhandler.SubscribeEvent;
 import net.minecraftforge.fml.common.gameevent.PlayerEvent;
 import net.minecraftforge.fml.common.gameevent.TickEvent;
 import net.minecraftforge.fml.relauncher.Side;
 import net.minecraftforge.fml.relauncher.SideOnly;
 import org.dave.compactmachines3.gui.machine.GuiMachineData;
+import org.dave.compactmachines3.init.Blockss;
 import org.dave.compactmachines3.reference.EnumMachineSize;
 import org.dave.compactmachines3.world.WorldSavedDataMachines;
 import org.dave.compactmachines3.world.tools.StructureTools;
@@ -71,6 +79,50 @@ public static void onGuiClose(GuiOpenEvent event) {
         }
     }
 
+    @SubscribeEvent
+    @SideOnly(Side.CLIENT)
+    public static void renderRotationIndicator(RenderWorldLastEvent event) {
+        if(!Minecraft.isGuiEnabled() || Minecraft.getMinecraft().player == null) {
+            return;
+        }
+
+        EntityPlayer player = Minecraft.getMinecraft().player;
+        ItemStack heldItem = player.getHeldItem(EnumHand.MAIN_HAND);
+        if(heldItem.isEmpty()) {
+            return;
+        }
+
+        if(!(heldItem.getItem() instanceof ItemBlock && ((ItemBlock) heldItem.getItem()).getBlock() == Blockss.fieldProjector)) {
+            return;
+        }
+
+        RayTraceResult trace = Minecraft.getMinecraft().objectMouseOver;
+        if(trace == null || trace.hitVec == null || trace.typeOfHit != RayTraceResult.Type.BLOCK) {
+            return;
+        }
+
+        if(trace.sideHit != EnumFacing.UP) {
+            return;
+        }
+
+        // Get a interpolated clientPosition so we don't get flickering when moving
+        Vec3d cameraPosition = new Vec3d(
+            player.lastTickPosX + (player.posX - player.lastTickPosX) * event.getPartialTicks(),
+            player.lastTickPosY + (player.posY - player.lastTickPosY) * event.getPartialTicks(),
+            player.lastTickPosZ + (player.posZ - player.lastTickPosZ) * event.getPartialTicks()
+        );
+
+        // Get the position on the top face of the block the player is looking at, between -0.5 and +0.5 on both axis
+        Vec3d hitPosition = trace.hitVec;
+        hitPosition = hitPosition.subtract(new Vec3d(trace.getBlockPos()));
+        hitPosition = hitPosition.subtract(0.5d, 0.5d, 0.5d);
+
+        // Move the drawing area to one block above the block we are looking at
+        BlockPos drawPosition = trace.getBlockPos().up();
+
+        RotationTools.renderArrowOnGround(cameraPosition, hitPosition, drawPosition);
+    }
+
     @SubscribeEvent
     public static void onPlayerTick(TickEvent.PlayerTickEvent event) {
         if(event.player.world.isRemote) {

src/main/java/org/dave/compactmachines3/misc/RotationTools.java

@@ -0,0 +1,148 @@
+package org.dave.compactmachines3.misc;
+
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.renderer.BufferBuilder;
+import net.minecraft.client.renderer.GlStateManager;
+import net.minecraft.client.renderer.Tessellator;
+import net.minecraft.client.renderer.vertex.DefaultVertexFormats;
+import net.minecraft.util.EnumFacing;
+import net.minecraft.util.ResourceLocation;
+import net.minecraft.util.Tuple;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.util.math.Vec3d;
+import net.minecraftforge.fml.relauncher.Side;
+import net.minecraftforge.fml.relauncher.SideOnly;
+import org.dave.compactmachines3.CompactMachines3;
+
+import java.util.ArrayList;
+
+public class RotationTools {
+    @SideOnly(Side.CLIENT)
+    private static ResourceLocation arrowImage;
+
+    @SideOnly(Side.CLIENT)
+    public static void renderArrowOnGround(Vec3d cameraPosition, Vec3d hitPosition, BlockPos drawPosition) {
+        EnumFacing facing = RotationTools.getFacingByTriangle(hitPosition);
+
+        RotationTools.TextureRotationList rotList = new RotationTools.TextureRotationList();
+        switch (facing) {
+            case SOUTH:
+                break;
+            case WEST:
+                rotList.rotateFromStart();
+                break;
+            case NORTH:
+                rotList.rotateFromStart();
+                rotList.rotateFromStart();
+                break;
+            case EAST:
+                rotList.rotateFromStart();
+                rotList.rotateFromStart();
+                rotList.rotateFromStart();
+                break;
+        }
+
+        if(arrowImage == null) {
+             arrowImage = new ResourceLocation(CompactMachines3.MODID, "textures/particles/blockmarker.png");
+        }
+        Minecraft.getMinecraft().getTextureManager().bindTexture(arrowImage);
+
+        GlStateManager.pushMatrix();
+
+        GlStateManager.translate(-cameraPosition.x, -cameraPosition.y, -cameraPosition.z);
+        GlStateManager.translate(drawPosition.getX(), drawPosition.getY(), drawPosition.getZ());
+
+        // Draw with 50% transparency
+        GlStateManager.color(1.0F, 1.0F, 1.0F, 0.5F);
+
+        // Actually draw
+        Tessellator tessellator = Tessellator.getInstance();
+        BufferBuilder bufferbuilder = tessellator.getBuffer();
+        bufferbuilder.begin(7, DefaultVertexFormats.POSITION_TEX);
+
+        rotList.fillBufferBuilder(bufferbuilder, 0.0005d);
+
+        tessellator.draw();
+
+        GlStateManager.popMatrix();
+    }
+
+    public static EnumFacing getFacingByTriangle(Vec3d vec) {
+        if(vec.z > 0) {
+            if(vec.x < 0) {
+                // Quadrant 1
+                if(Math.abs(vec.x) < Math.abs(vec.z)) {
+                    // Bottom
+                    return EnumFacing.SOUTH;
+                } else {
+                    // Left
+                    return EnumFacing.WEST;
+                }
+            } else {
+                // Quadrant 2
+                if(Math.abs(vec.x) > Math.abs(vec.z)) {
+                    // Right
+                    return EnumFacing.EAST;
+                } else {
+                    // Bottom
+                    return EnumFacing.SOUTH;
+                }
+            }
+        } else {
+            if(vec.x < 0) {
+                // Quadrant 3
+                if(Math.abs(vec.x) < Math.abs(vec.z)) {
+                    // Top
+                    return EnumFacing.NORTH;
+                } else {
+                    // Left
+                    return EnumFacing.WEST;
+                }
+
+            } else {
+                // Quadrant 4
+                if(Math.abs(vec.x) > Math.abs(vec.z)) {
+                    // Right
+                    return EnumFacing.EAST;
+                } else {
+                    // Top
+                    return EnumFacing.NORTH;
+                }
+            }
+        }
+    }
+
+    @SideOnly(Side.CLIENT)
+    public static class TextureRotationList extends RotatingList<Tuple<Integer, Integer>> {
+        public TextureRotationList() {
+            this.add(new Tuple<>(0, 1));
+            this.add(new Tuple<>(1, 1));
+            this.add(new Tuple<>(1, 0));
+            this.add(new Tuple<>(0, 0));
+        }
+
+        public void fillBufferBuilder(BufferBuilder buffer, double yLevel) {
+            buffer.pos(0, yLevel, 1).tex(this.get(0).getFirst(), this.get(0).getSecond()).endVertex();
+            buffer.pos(1, yLevel, 1).tex(this.get(1).getFirst(), this.get(1).getSecond()).endVertex();
+            buffer.pos(1, yLevel, 0).tex(this.get(2).getFirst(), this.get(2).getSecond()).endVertex();
+            buffer.pos(0, yLevel, 0).tex(this.get(3).getFirst(), this.get(3).getSecond()).endVertex();
+
+        }
+    }
+
+
+    public static class RotatingList<T> extends ArrayList<T> {
+        public void rotateFromStart() {
+            T firstElement = this.get(0);
+            this.remove(0);
+
+            this.add(firstElement);
+        }
+
+        public void rotateFromEnd() {
+            T lastElement = this.get(this.size()-1);
+            this.remove(this.size()-1);
+            this.add(0, lastElement);
+        }
+    }
+}