Added button to enter machines directly to the GUI

This button only shows when having a shrinking device somewhere in
the inventory and the player is actually allowed to enter the machine.

This also includes an internal change to the way items are being
recognized as Shrinking Devices.

Author: davenonymous

src/main/java/org/dave/compactmachines3/CompactMachines3.java

@@ -9,10 +9,12 @@
 import net.minecraftforge.fml.common.event.FMLPostInitializationEvent;
 import net.minecraftforge.fml.common.event.FMLPreInitializationEvent;
 import net.minecraftforge.fml.common.event.FMLServerStartingEvent;
+import org.dave.compactmachines3.capability.PlayerShrinkingCapability;
 import org.dave.compactmachines3.command.CommandCompactMachines3;
 import org.dave.compactmachines3.gui.GuiHandler;
 import org.dave.compactmachines3.integration.CapabilityNullHandlerRegistry;
 import org.dave.compactmachines3.miniaturization.MultiblockRecipes;
+import org.dave.compactmachines3.misc.CapabilityEventHandler;
 import org.dave.compactmachines3.misc.ConfigurationHandler;
 import org.dave.compactmachines3.misc.PlayerEventHandler;
 import org.dave.compactmachines3.misc.RenderTickCounter;
@@ -50,6 +52,7 @@ public void preInit(FMLPreInitializationEvent event) {
         MinecraftForge.EVENT_BUS.register(WorldSavedDataMachines.class);
         MinecraftForge.EVENT_BUS.register(RenderTickCounter.class);
         MinecraftForge.EVENT_BUS.register(BakeryHandler.class);
+        MinecraftForge.EVENT_BUS.register(CapabilityEventHandler.class);
 
         // Insist on keeping an already registered dimension by registering in pre-registerDimension.
         DimensionTools.registerDimension();
@@ -73,6 +76,7 @@ public void init(FMLInitializationEvent event) {
 
     @EventHandler
     public void postInit(FMLPostInitializationEvent event) {
+        PlayerShrinkingCapability.init();
         CapabilityNullHandlerRegistry.registerNullHandlers();
         ExtraTileDataProviderRegistry.registerExtraTileDataProviders();
 

src/main/java/org/dave/compactmachines3/api/IPlayerShrinkingCapability.java

@@ -0,0 +1,4 @@
+package org.dave.compactmachines3.api;
+
+public interface IPlayerShrinkingCapability {
+}

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

@@ -33,9 +33,9 @@
 import net.minecraftforge.fml.relauncher.Side;
 import net.minecraftforge.fml.relauncher.SideOnly;
 import org.dave.compactmachines3.CompactMachines3;
+import org.dave.compactmachines3.capability.PlayerShrinkingCapability;
 import org.dave.compactmachines3.compat.ITopInfoProvider;
 import org.dave.compactmachines3.init.Blockss;
-import org.dave.compactmachines3.item.ItemPersonalShrinkingDevice;
 import org.dave.compactmachines3.misc.CreativeTabCompactMachines3;
 import org.dave.compactmachines3.network.MessageMachineContent;
 import org.dave.compactmachines3.network.PackageHandler;
@@ -312,41 +312,10 @@ public boolean onBlockActivated(World world, BlockPos pos, IBlockState state, En
         }
 
         TileEntityMachine machine = (TileEntityMachine)world.getTileEntity(pos);
-        if(machine.isInsideItself()) {
-            return true;
-        }
-
         ItemStack playerStack = player.getHeldItemMainhand();
-        if(!playerStack.isEmpty() && machine.isAllowedToEnter(player)) {
-            Item playerItem = playerStack.getItem();
-
-            // TODO: Convert the ability to teleport into a machine into an itemstack capability
-            if(playerItem instanceof ItemPersonalShrinkingDevice) {
-                // TODO: Clean up, this belongs into a separate class
-                if(machine.coords == -1) {
-                    StructureTools.generateCubeForMachine(machine);
-
-                    double[] destination = new double[] {
-                            machine.coords * 1024 + 0.5 + machine.getSize().getDimension() / 2,
-                            42,
-                            0.5 + machine.getSize().getDimension() / 2
-                    };
-
-                    WorldSavedDataMachines.INSTANCE.addSpawnPoint(machine.coords, destination);
-                }
-
-                WorldSavedDataMachines.INSTANCE.addMachinePosition(machine.coords, pos, world.provider.getDimension(), machine.getSize());
-
-                TeleportationTools.teleportPlayerToMachine((EntityPlayerMP) player, machine);
-                StructureTools.setBiomeForCoords(machine.coords, world.getBiome(pos));
-
-                if(!machine.hasOwner() || "Unknown".equals(machine.getOwnerName())) {
-                    machine.setOwner(player);
-                    machine.markDirty();
-                }
-
-                return true;
-            }
+        if(PlayerShrinkingCapability.isShrinkingDevice(playerStack)) {
+            TeleportationTools.tryToEnterMachine(player, machine);
+            return true;
         }
 
         player.openGui(CompactMachines3.instance, GuiIds.MACHINE_VIEW.ordinal(), world, pos.getX(), pos.getY(), pos.getZ());

src/main/java/org/dave/compactmachines3/capability/PlayerShrinkingCapability.java

@@ -0,0 +1,71 @@
+package org.dave.compactmachines3.capability;
+
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTBase;
+import net.minecraft.util.EnumFacing;
+import net.minecraft.util.EnumHand;
+import net.minecraftforge.common.capabilities.Capability;
+import net.minecraftforge.common.capabilities.CapabilityInject;
+import net.minecraftforge.common.capabilities.CapabilityManager;
+import org.dave.compactmachines3.api.IPlayerShrinkingCapability;
+
+import javax.annotation.Nullable;
+import java.util.concurrent.Callable;
+
+public class PlayerShrinkingCapability {
+    @CapabilityInject(IPlayerShrinkingCapability.class)
+    public static Capability<IPlayerShrinkingCapability> PLAYER_SHRINKING_CAPABILITY = null;
+
+    public static void init() {
+        CapabilityManager.INSTANCE.register(IPlayerShrinkingCapability.class, new Storage(), new Factory());
+    }
+
+    public static boolean isShrinkingDevice(ItemStack stack) {
+        if(stack.isEmpty() || stack == null) {
+            return false;
+        }
+
+        return stack.hasCapability(PlayerShrinkingCapability.PLAYER_SHRINKING_CAPABILITY, null);
+    }
+
+    public static boolean hasShrinkingDeviceInHand(EntityPlayer player) {
+        return isShrinkingDevice(player.getHeldItemMainhand()) || isShrinkingDevice(player.getHeldItemOffhand());
+    }
+
+    public static boolean hasShrinkingDeviceInHand(EntityPlayer player, EnumHand hand) {
+        return isShrinkingDevice(player.getHeldItem(hand));
+    }
+
+    public static boolean hasShrinkingDeviceInInventory(EntityPlayer player) {
+        for(int slot = 0; slot < player.inventory.getSizeInventory(); slot++) {
+            ItemStack stack = player.inventory.getStackInSlot(slot);
+            if(isShrinkingDevice(stack)) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    private static class Storage implements Capability.IStorage<IPlayerShrinkingCapability> {
+
+        @Nullable
+        @Override
+        public NBTBase writeNBT(Capability<IPlayerShrinkingCapability> capability, IPlayerShrinkingCapability instance, EnumFacing side) {
+            return null;
+        }
+
+        @Override
+        public void readNBT(Capability<IPlayerShrinkingCapability> capability, IPlayerShrinkingCapability instance, EnumFacing side, NBTBase nbt) {
+        }
+    }
+
+    private  static class Factory implements Callable<IPlayerShrinkingCapability> {
+
+        @Override
+        public IPlayerShrinkingCapability call() throws Exception {
+            return new IPlayerShrinkingCapability() {};
+        }
+    }
+}

src/main/java/org/dave/compactmachines3/gui/machine/GuiMachine.java

@@ -5,7 +5,6 @@
 import net.minecraft.client.gui.GuiButton;
 import net.minecraft.client.gui.GuiTextField;
 import net.minecraft.client.gui.inventory.GuiContainer;
-import net.minecraft.client.network.NetworkPlayerInfo;
 import net.minecraft.client.renderer.*;
 import net.minecraft.client.renderer.texture.TextureManager;
 import net.minecraft.client.renderer.texture.TextureMap;
@@ -24,8 +23,10 @@
 import net.minecraftforge.client.ForgeHooksClient;
 import net.minecraftforge.fml.client.config.GuiCheckBox;
 import org.dave.compactmachines3.CompactMachines3;
+import org.dave.compactmachines3.capability.PlayerShrinkingCapability;
 import org.dave.compactmachines3.gui.GUIHelper;
 import org.dave.compactmachines3.init.Blockss;
+import org.dave.compactmachines3.init.Itemss;
 import org.dave.compactmachines3.misc.ConfigurationHandler;
 import org.dave.compactmachines3.misc.RenderTickCounter;
 import org.dave.compactmachines3.network.MessagePlayerWhiteListToggle;
@@ -57,6 +58,7 @@ public class GuiMachine extends GuiContainer {
     private GuiMachinePlayerWhitelist guiWhiteList;
     private GuiButton guiWhiteListAddButton;
     private GuiCheckBox guiMachineLockedButton;
+    private GuiButton guiEnterButton;
 
     int glListId = -1;
     int activeTab = 0;  // TODO: This should not be an integer, but rather a GuiTab object or something like that
@@ -67,18 +69,17 @@ public GuiMachine() {
 
     private boolean shouldShowTabs() {
         boolean isOwner = mc.player.getName().equals(GuiMachineData.owner);
-        boolean isCreative = mc.player.isCreative();
 
         // TODO: Add server-side operator & isCreative check
-        return isOwner || isCreative;
+        return isOwner;
     }
 
     @Override
     public void initGui() {
         super.initGui();
 
         this.bgImage = new ResourceLocation("minecraft", "textures/gui/container/crafting_table.png");
-        this.tabIcons =  new ResourceLocation(CompactMachines3.MODID, "textures/gui/tabicons.png");
+        this.tabIcons = new ResourceLocation(CompactMachines3.MODID, "textures/gui/tabicons.png");
 
         int offsetX = (int)((this.width - this.windowWidth) / 2.0f);
         int offsetY = (int)((this.height - this.windowHeight) / 2.0f);
@@ -98,6 +99,9 @@ public void initGui() {
                 20,
                 windowWidth - 10,
                 windowHeight);
+
+        this.guiEnterButton = new GuiButton(2, offsetX+5+windowWidth-30, offsetY+windowHeight-25, 20, 20, "");
+        this.buttonList.add(this.guiEnterButton);
     }
 
     @Override
@@ -157,6 +161,7 @@ public void drawScreen(int mouseX, int mouseY, float partialTicks) {
             renderChunk();
 
             drawOwner(partialTicks, mouseX, mouseY);
+            drawEnterButton(partialTicks, mouseX, mouseY);
         } else {
             // TODO: Draw unused screen and help information; account for future updates with loot compact machines
         }
@@ -166,6 +171,30 @@ public void drawScreen(int mouseX, int mouseY, float partialTicks) {
         }
     }
 
+    private void drawEnterButton(float partialTicks, int mouseX, int mouseY) {
+        if(!PlayerShrinkingCapability.hasShrinkingDeviceInInventory(mc.player)) {
+            return;
+        }
+
+        if(GuiMachineData.coords == -1) {
+            return;
+        }
+
+        if(!GuiMachineData.isAllowedToEnter(mc.player)) {
+            return;
+        }
+
+        guiEnterButton.drawButton(this.mc, mouseX, mouseY, partialTicks);
+
+
+        ItemStack itemstack = new ItemStack(Itemss.psd);
+        GlStateManager.pushAttrib();
+        RenderHelper.enableGUIStandardItemLighting();
+        this.itemRender.renderItemAndEffectIntoGUI(itemstack, guiEnterButton.x+2, guiEnterButton.y+1);
+        RenderHelper.enableStandardItemLighting();
+        GlStateManager.popAttrib();
+    }
+
     protected void drawOwner(float partialTicks, int mouseX, int mouseY) {
         float offsetX = (this.width - this.windowWidth) / 2.0f;
         float offsetY = (this.height - this.windowHeight) / 2.0f;
@@ -298,6 +327,10 @@ protected void actionPerformed(GuiButton button) throws IOException {
         if(button.id == 1) {
             PackageHandler.instance.sendToServer(new MessageRequestMachineAction(GuiMachineData.coords, MessageRequestMachineAction.Action.TOGGLE_LOCKED));
         }
+
+        if(button.id == 2) {
+            PackageHandler.instance.sendToServer(new MessageRequestMachineAction(GuiMachineData.coords, MessageRequestMachineAction.Action.TRY_TO_ENTER));
+        }
     }
 
     @Override
@@ -339,6 +372,16 @@ protected void mouseClicked(int mouseX, int mouseY, int mouseButton) throws IOEx
                 this.guiMachineLockedButton.playPressSound(this.mc.getSoundHandler());
                 this.actionPerformed(this.guiMachineLockedButton);
             }
+        } else if(activeTab == 0 && mouseButton == 0) {
+            boolean mousePressed = this.guiEnterButton.mousePressed(this.mc, mouseX, mouseY);
+            boolean hasDevice = PlayerShrinkingCapability.hasShrinkingDeviceInInventory(mc.player);
+            boolean validCoords = GuiMachineData.coords != -1;
+            boolean isAllowedToEnter = GuiMachineData.isAllowedToEnter(mc.player);
+
+            if(mousePressed && hasDevice && validCoords && isAllowedToEnter) {
+                this.guiEnterButton.playPressSound(this.mc.getSoundHandler());
+                this.actionPerformed(this.guiEnterButton);
+            }
         }
 
         if(shouldShowTabs()) {

src/main/java/org/dave/compactmachines3/gui/machine/GuiMachineAdmin.java

@@ -18,7 +18,7 @@ public class GuiMachineAdmin extends GuiMachine {
     private GuiButton buttonTeleportInside;
 
     private List<GuiButton> adminButtons;
-    private int buttonIdOffset = 2;
+    private int buttonIdOffset = 3;
 
     @Override
     public void initGui() {

src/main/java/org/dave/compactmachines3/gui/machine/GuiMachineData.java

@@ -1,5 +1,6 @@
 package org.dave.compactmachines3.gui.machine;
 
+import net.minecraft.entity.player.EntityPlayer;
 import net.minecraft.nbt.NBTTagCompound;
 import net.minecraft.util.math.BlockPos;
 import net.minecraft.world.IBlockAccess;
@@ -31,6 +32,26 @@ public class GuiMachineData {
     public static boolean requiresNewDisplayList = false;
     public static boolean canRender = false;
 
+    public static boolean isAllowedToEnter(EntityPlayer player) {
+        if(!locked) {
+            return true;
+        }
+
+        if(owner == null || owner.length() <= 0) {
+            return true;
+        }
+
+        if(player.getName().equals(owner)) {
+            return true;
+        }
+
+        if(playerWhiteList.contains(player.getName())) {
+            return true;
+        }
+
+        return false;
+    }
+
     public static void updateGuiMachineData(NBTTagCompound rawData, int machineSize, int coords, DimensionBlockPos machinePos, String owner, String customName, Set<String> playerWhiteList, boolean locked) {
         canRender = false;
         GuiMachineData.rawData = rawData;

src/main/java/org/dave/compactmachines3/gui/machine/GuiMachinePlayerWhitelist.java

@@ -7,7 +7,6 @@
 import net.minecraftforge.fml.client.GuiScrollingList;
 import org.dave.compactmachines3.network.MessagePlayerWhiteListToggle;
 import org.dave.compactmachines3.network.PackageHandler;
-import org.dave.compactmachines3.utility.Logz;
 
 public class GuiMachinePlayerWhitelist extends GuiScrollingList {
     private final GuiContainer parent;

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

@@ -0,0 +1,46 @@
+package org.dave.compactmachines3.misc;
+
+
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.EnumFacing;
+import net.minecraft.util.ResourceLocation;
+import net.minecraftforge.common.capabilities.Capability;
+import net.minecraftforge.common.capabilities.ICapabilityProvider;
+import net.minecraftforge.event.AttachCapabilitiesEvent;
+import net.minecraftforge.fml.common.eventhandler.SubscribeEvent;
+import org.dave.compactmachines3.CompactMachines3;
+import org.dave.compactmachines3.capability.PlayerShrinkingCapability;
+import org.dave.compactmachines3.init.Itemss;
+
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+
+public class CapabilityEventHandler {
+
+    private static boolean isIntegratedShrinkingDevice(Item item) {
+        return item == Itemss.psd;
+    }
+
+    @SubscribeEvent
+    public static void onAttachCapabilitiesToItems(AttachCapabilitiesEvent<ItemStack> event) {
+        ItemStack stack = event.getObject();
+        if(isIntegratedShrinkingDevice(stack.getItem()) && !PlayerShrinkingCapability.isShrinkingDevice(stack)) {
+            event.addCapability(new ResourceLocation(CompactMachines3.MODID, "canShrinkPlayers"), new PlayerShrinkingCapabilityProvider());
+        }
+    }
+
+    private static class PlayerShrinkingCapabilityProvider implements ICapabilityProvider {
+
+        @Override
+        public boolean hasCapability(@Nonnull Capability<?> capability, @Nullable EnumFacing facing) {
+            return capability == PlayerShrinkingCapability.PLAYER_SHRINKING_CAPABILITY;
+        }
+
+        @Nullable
+        @Override
+        public <T> T getCapability(@Nonnull Capability<T> capability, @Nullable EnumFacing facing) {
+            return (T) PlayerShrinkingCapability.PLAYER_SHRINKING_CAPABILITY.getDefaultInstance();
+        }
+    }
+}

src/main/java/org/dave/compactmachines3/network/MessageRequestMachineAction.java

@@ -40,6 +40,7 @@ public enum Action {
         GIVE_ITEM,
         TELEPORT_INSIDE,
         TELEPORT_OUTSIDE,
-        TOGGLE_LOCKED
+        TOGGLE_LOCKED,
+        TRY_TO_ENTER
     }
 }