Additional work on the Alchemy Table, as well as the Elytra upgrade.

src/main/java/WayofTime/bloodmagic/block/BlockAlchemyTable.java

@@ -1,31 +1,32 @@
 package WayofTime.bloodmagic.block;
 
-import java.util.ArrayList;
-import java.util.List;
-
 import net.minecraft.block.BlockContainer;
 import net.minecraft.block.material.Material;
+import net.minecraft.block.properties.IProperty;
+import net.minecraft.block.properties.PropertyBool;
+import net.minecraft.block.properties.PropertyEnum;
+import net.minecraft.block.state.BlockStateContainer;
 import net.minecraft.block.state.IBlockState;
 import net.minecraft.tileentity.TileEntity;
 import net.minecraft.util.BlockRenderLayer;
 import net.minecraft.util.EnumBlockRenderType;
+import net.minecraft.util.EnumFacing;
 import net.minecraft.util.math.BlockPos;
 import net.minecraft.world.IBlockAccess;
 import net.minecraft.world.World;
-
-import org.apache.commons.lang3.tuple.ImmutablePair;
-import org.apache.commons.lang3.tuple.Pair;
-
 import WayofTime.bloodmagic.BloodMagic;
 import WayofTime.bloodmagic.api.Constants;
-import WayofTime.bloodmagic.client.IVariantProvider;
+import WayofTime.bloodmagic.tile.TileAlchemyTable;
-import WayofTime.bloodmagic.tile.TileDemonCrucible;
 
-public class BlockAlchemyTable extends BlockContainer implements IVariantProvider
+public class BlockAlchemyTable extends BlockContainer
 {
+    public static final PropertyBool INVISIBLE = PropertyBool.create("invisible");
+    public static final PropertyEnum<EnumFacing> DIRECTION = PropertyEnum.<EnumFacing>create("direction", EnumFacing.class);
+
     public BlockAlchemyTable()
     {
         super(Material.ROCK);
+//        this.setDefaultState(this.blockState.getBaseState().withProperty(DIRECTION, EnumFacing.DOWN).withProperty(INVISIBLE, false));
 
         setUnlocalizedName(Constants.Mod.MODID + ".alchemyTable");
         setCreativeTab(BloodMagic.tabBloodMagic);
@@ -72,10 +73,43 @@ public class BlockAlchemyTable extends BlockContainer implements IVariantProvide
         return layer == BlockRenderLayer.CUTOUT_MIPPED || layer == BlockRenderLayer.TRANSLUCENT;
     }
 
+    @Override
+    public IBlockState getStateFromMeta(int meta)
+    {
+        return this.getDefaultState();
+    }
+
+    /**
+     * Convert the BlockState into the correct metadata value
+     */
+    @Override
+    public int getMetaFromState(IBlockState state)
+    {
+        return 0;
+    }
+
+    @Override
+    public IBlockState getActualState(IBlockState state, IBlockAccess world, BlockPos pos)
+    {
+        TileEntity tile = world.getTileEntity(pos);
+        if (tile instanceof TileAlchemyTable)
+        {
+            return state.withProperty(INVISIBLE, ((TileAlchemyTable) tile).isInvisible()).withProperty(DIRECTION, ((TileAlchemyTable) tile).getDirection());
+        }
+
+        return state.withProperty(INVISIBLE, false);
+    }
+
+    @Override
+    protected BlockStateContainer createBlockState()
+    {
+        return new BlockStateContainer(this, new IProperty[] { DIRECTION, INVISIBLE });
+    }
+
     @Override
     public TileEntity createNewTileEntity(World world, int meta)
     {
-        return new TileDemonCrucible();
+        return new TileAlchemyTable();
     }
 
 //    @Override
@@ -103,18 +137,18 @@ public class BlockAlchemyTable extends BlockContainer implements IVariantProvide
     @Override
     public void breakBlock(World world, BlockPos blockPos, IBlockState blockState)
     {
-        TileDemonCrucible tile = (TileDemonCrucible) world.getTileEntity(blockPos);
+        TileAlchemyTable tile = (TileAlchemyTable) world.getTileEntity(blockPos);
         if (tile != null)
             tile.dropItems();
 
         super.breakBlock(world, blockPos, blockState);
     }
-
+//
-    @Override
+//    @Override
-    public List<Pair<Integer, String>> getVariants()
+//    public List<Pair<Integer, String>> getVariants()
-    {
+//    {
-        List<Pair<Integer, String>> ret = new ArrayList<Pair<Integer, String>>();
+//        List<Pair<Integer, String>> ret = new ArrayList<Pair<Integer, String>>();
-        ret.add(new ImmutablePair<Integer, String>(0, "normal"));
+//        ret.add(new ImmutablePair<Integer, String>(0, "normal"));
-        return ret;
+//        return ret;
-    }
+//    }
 }

src/main/java/WayofTime/bloodmagic/item/armour/ItemLivingArmour.java

@@ -36,6 +36,8 @@ import WayofTime.bloodmagic.client.IMeshProvider;
 import WayofTime.bloodmagic.item.ItemComponent;
 import WayofTime.bloodmagic.livingArmour.LivingArmour;
 import WayofTime.bloodmagic.livingArmour.upgrade.LivingArmourUpgradeElytra;
+import WayofTime.bloodmagic.network.BloodMagicPacketHandler;
+import WayofTime.bloodmagic.network.PlayerFallDistancePacketProcessor;
 import WayofTime.bloodmagic.registry.ModItems;
 import WayofTime.bloodmagic.util.helper.TextHelper;
 
@@ -293,10 +295,23 @@ public class ItemLivingArmour extends ItemArmor implements ISpecialArmor, IMeshP
                         LivingArmourUpgrade upgrade = ItemLivingArmour.getUpgrade(Constants.Mod.MODID + ".upgrade.elytra", chestStack);
                         if (upgrade instanceof LivingArmourUpgradeElytra)
                         {
-                            if (spPlayer.movementInput.jump && !spPlayer.onGround && spPlayer.motionY < 0.0D && !spPlayer.isElytraFlying() && !spPlayer.capabilities.isFlying)
+                            if (spPlayer.motionY > -0.5D)
                             {
-                                byte b0 = player.getDataManager().get(FLAGS);
+                                BloodMagicPacketHandler.INSTANCE.sendToServer(new PlayerFallDistancePacketProcessor(1));
-                                player.getDataManager().set(FLAGS, (byte) (b0 | 1 << 7));
+                            }
+
+                            if (spPlayer.movementInput.jump && !spPlayer.onGround && spPlayer.motionY < 0.0D && !spPlayer.capabilities.isFlying)
+                            {
+                                if (spPlayer.motionY > -0.5D)
+                                {
+                                    BloodMagicPacketHandler.INSTANCE.sendToServer(new PlayerFallDistancePacketProcessor(1));
+                                }
+
+                                if (!spPlayer.isElytraFlying())
+                                {
+                                    byte b0 = player.getDataManager().get(FLAGS);
+                                    player.getDataManager().set(FLAGS, (byte) (b0 | 1 << 7));
+                                }
                             } else if (spPlayer.isElytraFlying() && !spPlayer.movementInput.jump && !spPlayer.onGround)
                             {
                                 byte b0 = player.getDataManager().get(FLAGS);

src/main/java/WayofTime/bloodmagic/item/block/ItemBlockAlchemyTable.java

@@ -0,0 +1,59 @@
+package WayofTime.bloodmagic.item.block;
+
+import net.minecraft.block.Block;
+import net.minecraft.block.state.IBlockState;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.init.Blocks;
+import net.minecraft.item.ItemBlock;
+import net.minecraft.item.ItemStack;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.util.EnumFacing;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.world.World;
+import WayofTime.bloodmagic.tile.TileAlchemyTable;
+
+public class ItemBlockAlchemyTable extends ItemBlock
+{
+    public ItemBlockAlchemyTable(Block block)
+    {
+        super(block);
+    }
+
+    @Override
+    public boolean placeBlockAt(ItemStack stack, EntityPlayer player, World world, BlockPos pos, EnumFacing side, float hitX, float hitY, float hitZ, IBlockState newState)
+    {
+        float yaw = player.rotationYaw;
+        EnumFacing direction = EnumFacing.fromAngle(yaw);
+
+        if (direction.getFrontOffsetY() != 0)
+        {
+            return false;
+        }
+
+        if (!world.isAirBlock(pos.offset(direction)))
+        {
+            return false;
+        }
+
+//        newState = block.getDefaultState().withProperty(BlockAlchemyTable.DIRECTION, direction).withProperty(BlockAlchemyTable.INVISIBLE, true);
+
+        if (!world.setBlockState(pos, newState, 3))
+            return false;
+
+        world.setBlockState(pos.offset(direction), Blocks.LAPIS_BLOCK.getDefaultState());
+
+        IBlockState state = world.getBlockState(pos);
+        if (state.getBlock() == this.block)
+        {
+            TileEntity tile = world.getTileEntity(pos);
+            if (tile instanceof TileAlchemyTable)
+            {
+                ((TileAlchemyTable) tile).setInitialTableParameters(direction, false, pos.offset(direction));
+            }
+            setTileEntityNBT(world, player, pos, stack);
+            this.block.onBlockPlacedBy(world, pos, state, player, stack);
+        }
+
+        return true;
+    }
+}

src/main/java/WayofTime/bloodmagic/livingArmour/upgrade/LivingArmourUpgradeElytra.java

@@ -19,7 +19,10 @@ public class LivingArmourUpgradeElytra extends LivingArmourUpgrade
     @Override
     public void onTick(World world, EntityPlayer player, ILivingArmour livingArmour)
     {
-
+        if (!world.isRemote && player.motionY > -0.5)
+        {
+            player.fallDistance = 1;
+        }
     }
 
     @Override

src/main/java/WayofTime/bloodmagic/network/BloodMagicPacketHandler.java

@@ -18,6 +18,7 @@ public class BloodMagicPacketHandler
         INSTANCE.registerMessage(ChatUtil.PacketNoSpamChat.Handler.class, ChatUtil.PacketNoSpamChat.class, 0, Side.CLIENT);
         INSTANCE.registerMessage(ItemRouterButtonPacketProcessor.class, ItemRouterButtonPacketProcessor.class, 1, Side.SERVER);
         INSTANCE.registerMessage(PlayerVelocityPacketProcessor.class, PlayerVelocityPacketProcessor.class, 2, Side.CLIENT);
+        INSTANCE.registerMessage(PlayerFallDistancePacketProcessor.class, PlayerFallDistancePacketProcessor.class, 3, Side.SERVER);
     }
 
     public static void sendToAllAround(IMessage message, TileEntity te, int range)

src/main/java/WayofTime/bloodmagic/network/PlayerFallDistancePacketProcessor.java

@@ -0,0 +1,55 @@
+package WayofTime.bloodmagic.network;
+
+import io.netty.buffer.ByteBuf;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.network.PacketBuffer;
+import net.minecraftforge.fml.common.network.simpleimpl.IMessage;
+import net.minecraftforge.fml.common.network.simpleimpl.IMessageHandler;
+import net.minecraftforge.fml.common.network.simpleimpl.MessageContext;
+import net.minecraftforge.fml.relauncher.Side;
+import net.minecraftforge.fml.relauncher.SideOnly;
+
+public class PlayerFallDistancePacketProcessor implements IMessage, IMessageHandler<PlayerFallDistancePacketProcessor, IMessage>
+{
+    private float fallDistance;
+
+    public PlayerFallDistancePacketProcessor()
+    {
+
+    }
+
+    public PlayerFallDistancePacketProcessor(float fallDistance)
+    {
+        this.fallDistance = fallDistance;
+    }
+
+    @Override
+    public void fromBytes(ByteBuf buffer)
+    {
+        PacketBuffer buff = new PacketBuffer(buffer);
+        fallDistance = buff.readFloat();
+    }
+
+    @Override
+    public void toBytes(ByteBuf buffer)
+    {
+        PacketBuffer buff = new PacketBuffer(buffer);
+        buff.writeFloat(fallDistance);
+    }
+
+    @Override
+    public IMessage onMessage(PlayerFallDistancePacketProcessor message, MessageContext ctx)
+    {
+        if (ctx.side == Side.SERVER)
+        {
+            message.onMessageFromClient(ctx.getServerHandler().playerEntity);
+        }
+        return null;
+    }
+
+    @SideOnly(Side.CLIENT)
+    public void onMessageFromClient(EntityPlayer player)
+    {
+        player.fallDistance = fallDistance;
+    }
+}

src/main/java/WayofTime/bloodmagic/registry/ModArmourTrackers.java

@@ -22,6 +22,7 @@ import WayofTime.bloodmagic.livingArmour.tracker.StatTrackerStepAssist;
 import WayofTime.bloodmagic.livingArmour.upgrade.LivingArmourUpgradeArrowShot;
 import WayofTime.bloodmagic.livingArmour.upgrade.LivingArmourUpgradeCriticalStrike;
 import WayofTime.bloodmagic.livingArmour.upgrade.LivingArmourUpgradeDigging;
+import WayofTime.bloodmagic.livingArmour.upgrade.LivingArmourUpgradeElytra;
 import WayofTime.bloodmagic.livingArmour.upgrade.LivingArmourUpgradeExperience;
 import WayofTime.bloodmagic.livingArmour.upgrade.LivingArmourUpgradeFallProtect;
 import WayofTime.bloodmagic.livingArmour.upgrade.LivingArmourUpgradeGraveDigger;
@@ -79,5 +80,6 @@ public class ModArmourTrackers
         LivingArmourHandler.registerArmourUpgrade(new LivingArmourUpgradeGraveDigger(0));
         LivingArmourHandler.registerArmourUpgrade(new LivingArmourUpgradeSprintAttack(0));
         LivingArmourHandler.registerArmourUpgrade(new LivingArmourUpgradeCriticalStrike(0));
+        LivingArmourHandler.registerArmourUpgrade(new LivingArmourUpgradeElytra(0));
     }
 }

src/main/java/WayofTime/bloodmagic/registry/ModBlocks.java

@@ -35,6 +35,7 @@ import WayofTime.bloodmagic.block.BlockRitualStone;
 import WayofTime.bloodmagic.block.BlockSoulForge;
 import WayofTime.bloodmagic.block.BlockSpectral;
 import WayofTime.bloodmagic.block.BlockTeleposer;
+import WayofTime.bloodmagic.item.block.ItemBlockAlchemyTable;
 import WayofTime.bloodmagic.item.block.ItemBlockBloodRune;
 import WayofTime.bloodmagic.item.block.ItemBlockBloodStoneBrick;
 import WayofTime.bloodmagic.item.block.ItemBlockBloodTank;
@@ -46,6 +47,7 @@ import WayofTime.bloodmagic.item.block.ItemBlockRitualController;
 import WayofTime.bloodmagic.item.block.ItemBlockRitualStone;
 import WayofTime.bloodmagic.item.block.ItemBlockRoutingNode;
 import WayofTime.bloodmagic.tile.TileAlchemyArray;
+import WayofTime.bloodmagic.tile.TileAlchemyTable;
 import WayofTime.bloodmagic.tile.TileAltar;
 import WayofTime.bloodmagic.tile.TileBloodTank;
 import WayofTime.bloodmagic.tile.TileDemonCrucible;
@@ -133,7 +135,7 @@ public class ModBlocks
         demonCrystallizer = registerBlock(new BlockDemonCrystallizer(), Constants.BloodMagicBlock.DEMON_CRYSTALLIZER.getRegName());
         demonCrystal = registerBlock(new ItemBlockDemonCrystal(new BlockDemonCrystal()), Constants.BloodMagicBlock.DEMON_CRYSTAL.getRegName());
 
-        alchemyTable = registerBlock(new BlockAlchemyTable(), Constants.BloodMagicBlock.ALCHEMY_TABLE.getRegName());
+        alchemyTable = registerBlock(new ItemBlockAlchemyTable(new BlockAlchemyTable()), Constants.BloodMagicBlock.ALCHEMY_TABLE.getRegName());
 
         dimensionalPortal = registerBlock(new BlockDimensionalPortal(), Constants.BloodMagicBlock.DIMENSIONAL_PORTAL.getRegName());
         bloodTank = registerBlock(new ItemBlockBloodTank(new BlockBloodTank()), Constants.BloodMagicBlock.BLOOD_TANK.getRegName());
@@ -168,6 +170,7 @@ public class ModBlocks
         GameRegistry.registerTileEntity(TileDemonPylon.class, Constants.Mod.MODID + ":" + TileDemonPylon.class.getSimpleName());
         GameRegistry.registerTileEntity(TileDemonCrystallizer.class, Constants.Mod.MODID + ":" + TileDemonCrystallizer.class.getSimpleName());
         GameRegistry.registerTileEntity(TileDemonCrystal.class, Constants.Mod.MODID + ":" + TileDemonCrystal.class.getSimpleName());
+        GameRegistry.registerTileEntity(TileAlchemyTable.class, Constants.Mod.MODID + ":" + TileAlchemyTable.class.getSimpleName());
 
         GameRegistry.registerTileEntity(TileDimensionalPortal.class, Constants.Mod.MODID + ":" + TileDimensionalPortal.class.getSimpleName());
         GameRegistry.registerTileEntity(TileBloodTank.class, Constants.Mod.MODID + ":" + TileBloodTank.class.getSimpleName());
@@ -188,6 +191,7 @@ public class ModBlocks
         renderHelper.itemRender(InventoryRenderHelper.getItemFromBlock(inputRoutingNode));
         renderHelper.itemRender(InventoryRenderHelper.getItemFromBlock(masterRoutingNode));
         renderHelper.itemRender(InventoryRenderHelper.getItemFromBlock(itemRoutingNode));
+        renderHelper.itemRender(InventoryRenderHelper.getItemFromBlock(alchemyTable));
         renderHelperV2.registerRender(InventoryRenderHelper.getItemFromBlock(demonCrystal), 0, "ItemBlockDemonCrystal", "default");
         renderHelperV2.registerRender(InventoryRenderHelper.getItemFromBlock(demonCrystal), 1, "ItemBlockDemonCrystal", "corrosive");
         renderHelperV2.registerRender(InventoryRenderHelper.getItemFromBlock(demonCrystal), 2, "ItemBlockDemonCrystal", "destructive");

src/main/java/WayofTime/bloodmagic/tile/TileAlchemyTable.java

@@ -0,0 +1,86 @@
+package WayofTime.bloodmagic.tile;
+
+import lombok.Getter;
+import net.minecraft.inventory.ISidedInventory;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.util.EnumFacing;
+import net.minecraft.util.ITickable;
+import net.minecraft.util.math.BlockPos;
+import WayofTime.bloodmagic.api.Constants;
+
+@Getter
+public class TileAlchemyTable extends TileInventory implements ISidedInventory, ITickable
+{
+    public EnumFacing direction = EnumFacing.NORTH;
+    public boolean isSlave = false;
+
+    public BlockPos connectedPos = BlockPos.ORIGIN;
+
+    public TileAlchemyTable()
+    {
+        super(1, "alchemyTable");
+    }
+
+    public void setInitialTableParameters(EnumFacing direction, boolean isSlave, BlockPos connectedPos)
+    {
+        this.isSlave = isSlave;
+        this.connectedPos = connectedPos;
+
+        if (!isSlave)
+        {
+            this.direction = direction;
+        }
+    }
+
+    public boolean isInvisible()
+    {
+        return isSlave();
+    }
+
+    @Override
+    public void readFromNBT(NBTTagCompound tag)
+    {
+        super.readFromNBT(tag);
+
+        isSlave = tag.getBoolean("isSlave");
+        direction = EnumFacing.getFront(tag.getInteger(Constants.NBT.DIRECTION));
+        connectedPos = new BlockPos(tag.getInteger(Constants.NBT.X_COORD), tag.getInteger(Constants.NBT.Y_COORD), tag.getInteger(Constants.NBT.Z_COORD));
+    }
+
+    @Override
+    public void writeToNBT(NBTTagCompound tag)
+    {
+        super.writeToNBT(tag);
+
+        tag.setBoolean("isSlave", isSlave);
+        tag.setInteger(Constants.NBT.DIRECTION, direction.getIndex());
+        tag.setInteger(Constants.NBT.X_COORD, pos.getX());
+        tag.setInteger(Constants.NBT.Y_COORD, pos.getY());
+        tag.setInteger(Constants.NBT.Z_COORD, pos.getZ());
+    }
+
+    @Override
+    public int[] getSlotsForFace(EnumFacing side)
+    {
+        return new int[0];
+    }
+
+    @Override
+    public boolean canInsertItem(int index, ItemStack itemStackIn, EnumFacing direction)
+    {
+        return false;
+    }
+
+    @Override
+    public boolean canExtractItem(int index, ItemStack stack, EnumFacing direction)
+    {
+        return false;
+    }
+
+    @Override
+    public void update()
+    {
+        //TODO: Stuff and things
+    }
+}

src/main/java/WayofTime/bloodmagic/util/handler/EventHandler.java

@@ -376,6 +376,19 @@ public class EventHandler
             }
         }
 
+        if (event.getLeft().getItem() == Items.BOOK && event.getRight().getItem() == Items.ELYTRA && !event.getRight().isItemDamaged())
+        {
+            ItemStack output = new ItemStack(ModItems.upgradeTome);
+            output = NBTHelper.checkNBT(output);
+            ItemHelper.LivingUpgrades.setKey(output, Constants.Mod.MODID + ".upgrade.elytra");
+            ItemHelper.LivingUpgrades.setLevel(output, 1);
+            event.setCost(30);
+
+            event.setOutput(output);
+
+            return;
+        }
+
         if (event.getLeft().getItem() == ModItems.upgradeTome && event.getRight().getItem() == ModItems.upgradeTome)
         {
             LivingArmourUpgrade leftUpgrade = ItemHelper.LivingUpgrades.getUpgrade(event.getLeft());

src/main/resources/assets/bloodmagic/blockstates/BlockAlchemyTable.json

@@ -4,10 +4,46 @@
         "textures": { },
         "model": "bloodmagic:ModelAlchemyTable.obj",
         "custom": { "flip-v": true },
-        "transform" : "forge:default-block"
+        "transform" : "forge:default-block",
+        "uvlock": true
     },
     "variants": {
-        "normal": [{
+        "direction": {
+    		"down": {
+    		},
+    		"up": {
+    		},
+    		"north": {
+    			"transform": {
+            		"rotation": {"y": -90}
+        		}
+    		},
+    		"south": {
+    			"transform": {
+            		"rotation": {"y": 90}
+        		}
+    		},
+    		"east": {
+    			"transform": {
+            		"rotation": {"y": 180}
+        		}
+    		},
+    		"west": {
+
+    		}
+    	},
+    	"invisible": {
+    		"true": {
+    			"model": "cube_all",
+    			"textures": {
+		          	"all": "bloodmagic:blocks/empty"
+		        }
+    		},
+    		"false": {
+    			
+    		}
+    	},
+		"inventory": [{
 
         }]
     }

src/main/resources/assets/bloodmagic/lang/en_US.lang

@@ -335,6 +335,7 @@ tooltip.BloodMagic.livingArmour.upgrade.fallProtect=Soft Fall
 tooltip.BloodMagic.livingArmour.upgrade.graveDigger=Grave Digger
 tooltip.BloodMagic.livingArmour.upgrade.sprintAttack=Charging Strike
 tooltip.BloodMagic.livingArmour.upgrade.criticalStrike=True Strike
+tooltip.BloodMagic.livingArmour.upgrade.elytra=Elytra
 tooltip.BloodMagic.livingArmour.upgrade.level=%s (Level %d)
 tooltip.BloodMagic.livingArmour.upgrade.points=&6Upgrade points: %s / %s