Merge apibutnotreally with the main packages

Do not consider anything outside of the true API safe to use. And even then,
I'm changing things. Just wait. Please I beg you.

src/main/java/WayofTime/bloodmagic/altar/AltarComponent.java

@@ -0,0 +1,56 @@
+package WayofTime.bloodmagic.altar;
+
+import net.minecraft.util.math.BlockPos;
+
+/**
+ * Used for building the altar structure.
+ */
+public class AltarComponent {
+    private BlockPos offset;
+    private boolean upgradeSlot;
+
+    private EnumAltarComponent component;
+
+    /**
+     * Sets a component location for the altar.
+     *
+     * @param offset    - Where the block should be in relation to the Altar
+     * @param component - The type of Component the location should contain
+     */
+    public AltarComponent(BlockPos offset, EnumAltarComponent component) {
+        this.offset = offset;
+        this.component = component;
+    }
+
+    /**
+     * Use for setting a location at which there must be a block, but the type
+     * of block does not matter.
+     *
+     * @param offset - Where the block should be in relation to the Altar
+     */
+    public AltarComponent(BlockPos offset) {
+        this(offset, EnumAltarComponent.NOTAIR);
+    }
+
+    /**
+     * Sets the location to an upgrade slot.
+     *
+     * @return the current instance for further use.
+     */
+    public AltarComponent setUpgradeSlot() {
+        this.upgradeSlot = true;
+        return this;
+    }
+
+    public BlockPos getOffset() {
+        return offset;
+    }
+
+    public boolean isUpgradeSlot() {
+        return upgradeSlot;
+    }
+
+    public EnumAltarComponent getComponent() {
+        return component;
+    }
+}

src/main/java/WayofTime/bloodmagic/altar/AltarUpgrade.java

@@ -0,0 +1,122 @@
+package WayofTime.bloodmagic.altar;
+
+public class AltarUpgrade {
+    private int speedCount;
+    private int efficiencyCount;
+    private int sacrificeCount;
+    private int selfSacrificeCount;
+    private int displacementCount;
+    private int capacityCount;
+    private int orbCapacityCount;
+    private int betterCapacityCount;
+    private int accelerationCount;
+    private int chargingCount;
+
+    public AltarUpgrade(int speedCount, int efficiencyCount, int sacrificeCount, int selfSacrificeCount, int displacementCount, int capacityCount, int orbCapacityCount, int betterCapacityCount, int accelerationCount, int chargingCount) {
+        this.speedCount = speedCount;
+        this.efficiencyCount = efficiencyCount;
+        this.sacrificeCount = sacrificeCount;
+        this.selfSacrificeCount = selfSacrificeCount;
+        this.displacementCount = displacementCount;
+        this.capacityCount = capacityCount;
+        this.orbCapacityCount = orbCapacityCount;
+        this.betterCapacityCount = betterCapacityCount;
+        this.accelerationCount = accelerationCount;
+        this.chargingCount = chargingCount;
+    }
+
+    public AltarUpgrade() {
+    }
+
+    // Adders
+
+    public AltarUpgrade addSpeed() {
+        speedCount++;
+        return this;
+    }
+
+    public AltarUpgrade addEfficiency() {
+        efficiencyCount++;
+        return this;
+    }
+
+    public AltarUpgrade addSacrifice() {
+        sacrificeCount++;
+        return this;
+    }
+
+    public AltarUpgrade addSelfSacrifice() {
+        selfSacrificeCount++;
+        return this;
+    }
+
+    public AltarUpgrade addDisplacement() {
+        displacementCount++;
+        return this;
+    }
+
+    public AltarUpgrade addCapacity() {
+        capacityCount++;
+        return this;
+    }
+
+    public AltarUpgrade addOrbCapacity() {
+        orbCapacityCount++;
+        return this;
+    }
+
+    public AltarUpgrade addBetterCapacity() {
+        betterCapacityCount++;
+        return this;
+    }
+
+    public AltarUpgrade addAcceleration() {
+        accelerationCount++;
+        return this;
+    }
+
+    public AltarUpgrade addCharging() {
+        chargingCount++;
+        return this;
+    }
+
+    public int getSpeedCount() {
+        return speedCount;
+    }
+
+    public int getEfficiencyCount() {
+        return efficiencyCount;
+    }
+
+    public int getSacrificeCount() {
+        return sacrificeCount;
+    }
+
+    public int getSelfSacrificeCount() {
+        return selfSacrificeCount;
+    }
+
+    public int getDisplacementCount() {
+        return displacementCount;
+    }
+
+    public int getCapacityCount() {
+        return capacityCount;
+    }
+
+    public int getOrbCapacityCount() {
+        return orbCapacityCount;
+    }
+
+    public int getBetterCapacityCount() {
+        return betterCapacityCount;
+    }
+
+    public int getAccelerationCount() {
+        return accelerationCount;
+    }
+
+    public int getChargingCount() {
+        return chargingCount;
+    }
+}

src/main/java/WayofTime/bloodmagic/altar/BloodAltar.java

@@ -3,12 +3,11 @@ package WayofTime.bloodmagic.altar;
 import WayofTime.bloodmagic.api.event.BloodMagicCraftedEvent;
 import WayofTime.bloodmagic.api.impl.BloodMagicAPI;
 import WayofTime.bloodmagic.api.impl.recipe.RecipeBloodAltar;
-import WayofTime.bloodmagic.apibutnotreally.BlockStack;
-import WayofTime.bloodmagic.apibutnotreally.Constants;
-import WayofTime.bloodmagic.apibutnotreally.altar.*;
-import WayofTime.bloodmagic.apibutnotreally.orb.BloodOrb;
-import WayofTime.bloodmagic.apibutnotreally.orb.IBloodOrb;
-import WayofTime.bloodmagic.apibutnotreally.util.helper.NetworkHelper;
+import WayofTime.bloodmagic.util.BlockStack;
+import WayofTime.bloodmagic.util.Constants;
+import WayofTime.bloodmagic.orb.BloodOrb;
+import WayofTime.bloodmagic.orb.IBloodOrb;
+import WayofTime.bloodmagic.util.helper.NetworkHelper;
 import WayofTime.bloodmagic.block.BlockBloodRune;
 import WayofTime.bloodmagic.block.BlockLifeEssence;
 import WayofTime.bloodmagic.tile.TileAltar;

src/main/java/WayofTime/bloodmagic/altar/EnumAltarComponent.java

@@ -0,0 +1,27 @@
+package WayofTime.bloodmagic.altar;
+
+import java.util.Locale;
+
+/**
+ * List of different components used to construct different tiers of altars.
+ */
+public enum EnumAltarComponent {
+    GLOWSTONE,
+    BLOODSTONE,
+    BEACON,
+    BLOODRUNE,
+    CRYSTAL,
+    NOTAIR;
+
+    public static final EnumAltarComponent[] VALUES = values();
+    private static final String BASE = "chat.bloodmagic.altar.comp.";
+    private String key;
+
+    EnumAltarComponent() {
+        this.key = BASE + name().toLowerCase(Locale.ENGLISH);
+    }
+
+    public String getKey() {
+        return key;
+    }
+}

src/main/java/WayofTime/bloodmagic/altar/EnumAltarTier.java

@@ -0,0 +1,138 @@
+package WayofTime.bloodmagic.altar;
+
+import net.minecraft.util.math.BlockPos;
+
+import java.util.ArrayList;
+
+//@formatter:off
+public enum EnumAltarTier {
+    ONE(), TWO() {
+        @Override
+        public void buildComponents() {
+            altarComponents.add(new AltarComponent(new BlockPos(-1, -1, -1), EnumAltarComponent.BLOODRUNE));
+            altarComponents.add(new AltarComponent(new BlockPos(0, -1, -1), EnumAltarComponent.BLOODRUNE).setUpgradeSlot());
+            altarComponents.add(new AltarComponent(new BlockPos(1, -1, -1), EnumAltarComponent.BLOODRUNE));
+            altarComponents.add(new AltarComponent(new BlockPos(-1, -1, 0), EnumAltarComponent.BLOODRUNE).setUpgradeSlot());
+            altarComponents.add(new AltarComponent(new BlockPos(1, -1, 0), EnumAltarComponent.BLOODRUNE).setUpgradeSlot());
+            altarComponents.add(new AltarComponent(new BlockPos(-1, -1, 1), EnumAltarComponent.BLOODRUNE));
+            altarComponents.add(new AltarComponent(new BlockPos(0, -1, 1), EnumAltarComponent.BLOODRUNE).setUpgradeSlot());
+            altarComponents.add(new AltarComponent(new BlockPos(1, -1, 1), EnumAltarComponent.BLOODRUNE));
+        }
+    },
+    THREE() {
+        @Override
+        public void buildComponents() {
+            altarComponents.add(new AltarComponent(new BlockPos(-1, -1, -1), EnumAltarComponent.BLOODRUNE).setUpgradeSlot());
+            altarComponents.add(new AltarComponent(new BlockPos(0, -1, -1), EnumAltarComponent.BLOODRUNE).setUpgradeSlot());
+            altarComponents.add(new AltarComponent(new BlockPos(1, -1, -1), EnumAltarComponent.BLOODRUNE).setUpgradeSlot());
+            altarComponents.add(new AltarComponent(new BlockPos(-1, -1, 0), EnumAltarComponent.BLOODRUNE).setUpgradeSlot());
+            altarComponents.add(new AltarComponent(new BlockPos(1, -1, 0), EnumAltarComponent.BLOODRUNE).setUpgradeSlot());
+            altarComponents.add(new AltarComponent(new BlockPos(-1, -1, 1), EnumAltarComponent.BLOODRUNE).setUpgradeSlot());
+            altarComponents.add(new AltarComponent(new BlockPos(0, -1, 1), EnumAltarComponent.BLOODRUNE).setUpgradeSlot());
+            altarComponents.add(new AltarComponent(new BlockPos(1, -1, 1), EnumAltarComponent.BLOODRUNE).setUpgradeSlot());
+            altarComponents.add(new AltarComponent(new BlockPos(-3, -1, -3)));
+            altarComponents.add(new AltarComponent(new BlockPos(-3, 0, -3)));
+            altarComponents.add(new AltarComponent(new BlockPos(3, -1, -3)));
+            altarComponents.add(new AltarComponent(new BlockPos(3, 0, -3)));
+            altarComponents.add(new AltarComponent(new BlockPos(-3, -1, 3)));
+            altarComponents.add(new AltarComponent(new BlockPos(-3, 0, 3)));
+            altarComponents.add(new AltarComponent(new BlockPos(3, -1, 3)));
+            altarComponents.add(new AltarComponent(new BlockPos(3, 0, 3)));
+            altarComponents.add(new AltarComponent(new BlockPos(-3, 1, -3), EnumAltarComponent.GLOWSTONE));
+            altarComponents.add(new AltarComponent(new BlockPos(3, 1, -3), EnumAltarComponent.GLOWSTONE));
+            altarComponents.add(new AltarComponent(new BlockPos(-3, 1, 3), EnumAltarComponent.GLOWSTONE));
+            altarComponents.add(new AltarComponent(new BlockPos(3, 1, 3), EnumAltarComponent.GLOWSTONE));
+
+            for (int i = -2; i <= 2; i++) {
+                altarComponents.add(new AltarComponent(new BlockPos(3, -2, i), EnumAltarComponent.BLOODRUNE).setUpgradeSlot());
+                altarComponents.add(new AltarComponent(new BlockPos(-3, -2, i), EnumAltarComponent.BLOODRUNE).setUpgradeSlot());
+                altarComponents.add(new AltarComponent(new BlockPos(i, -2, 3), EnumAltarComponent.BLOODRUNE).setUpgradeSlot());
+                altarComponents.add(new AltarComponent(new BlockPos(i, -2, -3), EnumAltarComponent.BLOODRUNE).setUpgradeSlot());
+            }
+        }
+    },
+    FOUR() {
+        @Override
+        public void buildComponents() {
+            altarComponents.addAll(THREE.getAltarComponents());
+
+            for (int i = -3; i <= 3; i++) {
+                altarComponents.add(new AltarComponent(new BlockPos(5, -3, i), EnumAltarComponent.BLOODRUNE).setUpgradeSlot());
+                altarComponents.add(new AltarComponent(new BlockPos(-5, -3, i), EnumAltarComponent.BLOODRUNE).setUpgradeSlot());
+                altarComponents.add(new AltarComponent(new BlockPos(i, -3, 5), EnumAltarComponent.BLOODRUNE).setUpgradeSlot());
+                altarComponents.add(new AltarComponent(new BlockPos(i, -3, -5), EnumAltarComponent.BLOODRUNE).setUpgradeSlot());
+            }
+
+            for (int i = -2; i <= 1; i++) {
+                altarComponents.add(new AltarComponent(new BlockPos(5, i, 5)));
+                altarComponents.add(new AltarComponent(new BlockPos(5, i, -5)));
+                altarComponents.add(new AltarComponent(new BlockPos(-5, i, -5)));
+                altarComponents.add(new AltarComponent(new BlockPos(-5, i, 5)));
+            }
+
+            altarComponents.add(new AltarComponent(new BlockPos(5, 2, 5), EnumAltarComponent.BLOODSTONE));
+            altarComponents.add(new AltarComponent(new BlockPos(5, 2, -5), EnumAltarComponent.BLOODSTONE));
+            altarComponents.add(new AltarComponent(new BlockPos(-5, 2, -5), EnumAltarComponent.BLOODSTONE));
+            altarComponents.add(new AltarComponent(new BlockPos(-5, 2, 5), EnumAltarComponent.BLOODSTONE));
+        }
+    },
+    FIVE() {
+        @Override
+        public void buildComponents() {
+            altarComponents.addAll(FOUR.getAltarComponents());
+            altarComponents.add(new AltarComponent(new BlockPos(-8, -3, 8), EnumAltarComponent.BEACON));
+            altarComponents.add(new AltarComponent(new BlockPos(-8, -3, -8), EnumAltarComponent.BEACON));
+            altarComponents.add(new AltarComponent(new BlockPos(8, -3, -8), EnumAltarComponent.BEACON));
+            altarComponents.add(new AltarComponent(new BlockPos(8, -3, 8), EnumAltarComponent.BEACON));
+
+            for (int i = -6; i <= 6; i++) {
+                altarComponents.add(new AltarComponent(new BlockPos(8, -4, i), EnumAltarComponent.BLOODRUNE).setUpgradeSlot());
+                altarComponents.add(new AltarComponent(new BlockPos(-8, -4, i), EnumAltarComponent.BLOODRUNE).setUpgradeSlot());
+                altarComponents.add(new AltarComponent(new BlockPos(i, -4, 8), EnumAltarComponent.BLOODRUNE).setUpgradeSlot());
+                altarComponents.add(new AltarComponent(new BlockPos(i, -4, -8), EnumAltarComponent.BLOODRUNE).setUpgradeSlot());
+            }
+        }
+    },
+    SIX() {
+        @Override
+        public void buildComponents() {
+            altarComponents.addAll(FIVE.getAltarComponents());
+
+            for (int i = -4; i <= 2; i++) {
+                altarComponents.add(new AltarComponent(new BlockPos(11, i, 11)));
+                altarComponents.add(new AltarComponent(new BlockPos(-11, i, -11)));
+                altarComponents.add(new AltarComponent(new BlockPos(11, i, -11)));
+                altarComponents.add(new AltarComponent(new BlockPos(-11, i, 11)));
+            }
+
+            altarComponents.add(new AltarComponent(new BlockPos(11, 3, 11), EnumAltarComponent.CRYSTAL));
+            altarComponents.add(new AltarComponent(new BlockPos(-11, 3, -11), EnumAltarComponent.CRYSTAL));
+            altarComponents.add(new AltarComponent(new BlockPos(11, 3, -11), EnumAltarComponent.CRYSTAL));
+            altarComponents.add(new AltarComponent(new BlockPos(-11, 3, 11), EnumAltarComponent.CRYSTAL));
+
+            for (int i = -9; i <= 9; i++) {
+                altarComponents.add(new AltarComponent(new BlockPos(11, -5, i), EnumAltarComponent.BLOODRUNE).setUpgradeSlot());
+                altarComponents.add(new AltarComponent(new BlockPos(-11, -5, i), EnumAltarComponent.BLOODRUNE).setUpgradeSlot());
+                altarComponents.add(new AltarComponent(new BlockPos(i, -5, 11), EnumAltarComponent.BLOODRUNE).setUpgradeSlot());
+                altarComponents.add(new AltarComponent(new BlockPos(i, -5, -11), EnumAltarComponent.BLOODRUNE).setUpgradeSlot());
+            }
+        }
+//@formatter:on
+    };
+
+    public static final int MAXTIERS = values().length;
+
+    ArrayList<AltarComponent> altarComponents = new ArrayList<AltarComponent>();
+
+    public void buildComponents() {
+
+    }
+
+    public int toInt() {
+        return ordinal() + 1;
+    }
+
+    public ArrayList<AltarComponent> getAltarComponents() {
+        return altarComponents;
+    }
+}

src/main/java/WayofTime/bloodmagic/altar/IAltarComponent.java

@@ -0,0 +1,12 @@
+package WayofTime.bloodmagic.altar;
+
+import net.minecraft.block.state.IBlockState;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.world.World;
+
+import javax.annotation.Nullable;
+
+public interface IAltarComponent {
+    @Nullable
+    EnumAltarComponent getType(World world, IBlockState state, BlockPos pos);
+}

src/main/java/WayofTime/bloodmagic/altar/IAltarManipulator.java

@@ -0,0 +1,8 @@
+package WayofTime.bloodmagic.altar;
+
+/**
+ * Any item that implements this interface will not be pulled into the Altar on
+ * right click.
+ */
+public interface IAltarManipulator {
+}

src/main/java/WayofTime/bloodmagic/altar/IBloodAltar.java

@@ -0,0 +1,54 @@
+package WayofTime.bloodmagic.altar;
+
+public interface IBloodAltar {
+    int getCapacity();
+
+    int getCurrentBlood();
+
+    EnumAltarTier getTier();
+
+    int getProgress();
+
+    float getSacrificeMultiplier();
+
+    float getSelfSacrificeMultiplier();
+
+    float getOrbMultiplier();
+
+    float getDislocationMultiplier();
+
+    float getConsumptionMultiplier();
+
+    float getConsumptionRate();
+
+    int getChargingRate();
+
+    int getChargingFrequency();
+
+    int getTotalCharge();
+
+    int getLiquidRequired();
+
+    int getBufferCapacity();
+
+    void sacrificialDaggerCall(int amount, boolean isSacrifice);
+
+    void startCycle();
+
+    void checkTier();
+
+    boolean isActive();
+
+    void setActive();
+
+    int fillMainTank(int amount);
+
+    /**
+     * Will set the altar to initiate a cooldown cycle after it crafts before
+     * starting to craft again, giving the user time to interact with the altar.
+     * This can only be set while the altar is not active.
+     *
+     * @param cooldown - How long the cooldown should last
+     */
+    void requestPauseAfterCrafting(int cooldown);
+}