lauchmelder/BloodMagic
1
0
Fork 0
Code Issues Pull requests Actions Packages Projects Releases Wiki Activity

Run code formatter

Browse source 
🦀 Way is gone 🦀
This commit is contained in:
Nicholas Ignoffo 2019-04-14 08:22:42 -07:00
parent 7c1565a68c
commit 53b6030ba9
77 changed files with 1289 additions and 2232 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

78
src/main/java/WayofTime/bloodmagic/ConfigHandler.java
View file

@ -9,90 +9,82 @@ import net.minecraftforge.fml.common.eventhandler.SubscribeEvent;
@Config(modid = BloodMagic.MODID, name = BloodMagic.MODID + "/" + BloodMagic.MODID, category = "") @Config(modid = BloodMagic.MODID, name = BloodMagic.MODID + "/" + BloodMagic.MODID, category = "")
@Mod.EventBusSubscriber(modid = BloodMagic.MODID) @Mod.EventBusSubscriber(modid = BloodMagic.MODID)
public class ConfigHandler public class ConfigHandler {
{
@Config.Comment({ "General settings" }) @Config.Comment({"General settings"})
public static ConfigGeneral general = new ConfigGeneral(); public static ConfigGeneral general = new ConfigGeneral();
@Config.Comment({ "Blacklist options for various features" }) @Config.Comment({"Blacklist options for various features"})
public static ConfigBlacklist blacklist = new ConfigBlacklist(); public static ConfigBlacklist blacklist = new ConfigBlacklist();
@Config.Comment({ "Value modifiers for various features" }) @Config.Comment({"Value modifiers for various features"})
public static ConfigValues values = new ConfigValues(); public static ConfigValues values = new ConfigValues();
@Config.Comment({ "Settings that only pertain to the client" }) @Config.Comment({"Settings that only pertain to the client"})
public static ConfigClient client = new ConfigClient(); public static ConfigClient client = new ConfigClient();
@Config.Comment({ "Compatibility settings" }) @Config.Comment({"Compatibility settings"})
public static ConfigCompat compat = new ConfigCompat(); public static ConfigCompat compat = new ConfigCompat();
@SubscribeEvent @SubscribeEvent
public static void onConfigChanged(ConfigChangedEvent.OnConfigChangedEvent event) public static void onConfigChanged(ConfigChangedEvent.OnConfigChangedEvent event) {
{ if (event.getModID().equals(BloodMagic.MODID)) {
if (event.getModID().equals(BloodMagic.MODID))
{
ConfigManager.sync(event.getModID(), Config.Type.INSTANCE); // Sync config values ConfigManager.sync(event.getModID(), Config.Type.INSTANCE); // Sync config values
BloodMagic.RITUAL_MANAGER.syncConfig(); BloodMagic.RITUAL_MANAGER.syncConfig();
MeteorConfigHandler.handleMeteors(false); // Reload meteors MeteorConfigHandler.handleMeteors(false); // Reload meteors
} }
} }
public static class ConfigGeneral public static class ConfigGeneral {
{ @Config.Comment({"Enables extra information to be printed to the log.", "Warning: May drastically increase log size."})
@Config.Comment({ "Enables extra information to be printed to the log.", "Warning: May drastically increase log size." })
public boolean enableDebugLogging = false; public boolean enableDebugLogging = false;
@Config.Comment({ "Enables extra information to be printed to the log." }) @Config.Comment({"Enables extra information to be printed to the log."})
public boolean enableAPILogging = false; public boolean enableAPILogging = false;
@Config.Comment({ "Enables extra information to be printed to the log.", "Warning: May drastically increase log size." }) @Config.Comment({"Enables extra information to be printed to the log.", "Warning: May drastically increase log size."})
public boolean enableVerboseAPILogging = false; public boolean enableVerboseAPILogging = false;
@Config.Comment({ "Enables tier 6 related registrations. This is for pack makers."}) @Config.Comment({"Enables tier 6 related registrations. This is for pack makers."})
@Config.RequiresMcRestart @Config.RequiresMcRestart
public boolean enableTierSixEvenThoughThereIsNoContent = false; public boolean enableTierSixEvenThoughThereIsNoContent = false;
} }
public static class ConfigBlacklist public static class ConfigBlacklist {
{ @Config.Comment({"Stops listed blocks and entities from being teleposed.", "Use the registry name of the block or entity. Vanilla objects do not require the modid.", "If a block is specified, you can list the variants to only blacklist a given state."})
@Config.Comment({ "Stops listed blocks and entities from being teleposed.", "Use the registry name of the block or entity. Vanilla objects do not require the modid.", "If a block is specified, you can list the variants to only blacklist a given state." }) public String[] teleposer = {"bedrock", "mob_spawner"};
public String[] teleposer = { "bedrock", "mob_spawner" }; @Config.Comment({"Stops listed blocks from being transposed.", "Use the registry name of the block. Vanilla blocks do not require the modid."})
@Config.Comment({ "Stops listed blocks from being transposed.", "Use the registry name of the block. Vanilla blocks do not require the modid." }) public String[] transposer = {"bedrock", "mob_spawner"};
public String[] transposer = { "bedrock", "mob_spawner" }; @Config.Comment({"Stops the listed entities from being used in the Well of Suffering.", "Use the registry name of the entity. Vanilla entities do not require the modid."})
@Config.Comment({ "Stops the listed entities from being used in the Well of Suffering.", "Use the registry name of the entity. Vanilla entities do not require the modid." })
public String[] wellOfSuffering = {}; public String[] wellOfSuffering = {};
} }
public static class ConfigValues public static class ConfigValues {
{ @Config.Comment({"Declares the amount of LP gained per HP sacrificed for the given entity.", "Setting the value to 0 will blacklist it.", "Use the registry name of the entity followed by a ';' and then the value you want.", "Vanilla entities do not require the modid."})
@Config.Comment({ "Declares the amount of LP gained per HP sacrificed for the given entity.", "Setting the value to 0 will blacklist it.", "Use the registry name of the entity followed by a ';' and then the value you want.", "Vanilla entities do not require the modid." }) public String[] sacrificialValues = {"villager;100", "slime;15", "enderman;10", "cow;100", "chicken;100", "horse;100", "sheep;100", "wolf;100", "ocelot;100", "pig;100", "rabbit;100"};
public String[] sacrificialValues = { "villager;100", "slime;15", "enderman;10", "cow;100", "chicken;100", "horse;100", "sheep;100", "wolf;100", "ocelot;100", "pig;100", "rabbit;100" }; @Config.Comment({"Amount of LP the Coat of Arms should provide for each damage dealt."})
@Config.Comment({ "Amount of LP the Coat of Arms should provide for each damage dealt." })
@Config.RangeInt(min = 0, max = 100) @Config.RangeInt(min = 0, max = 100)
public int coatOfArmsConversion = 20; public int coatOfArmsConversion = 20;
@Config.Comment({ "Amount of LP the Sacrificial Dagger should provide for each damage dealt." }) @Config.Comment({"Amount of LP the Sacrificial Dagger should provide for each damage dealt."})
@Config.RangeInt(min = 0, max = 10000) @Config.RangeInt(min = 0, max = 10000)
public int sacrificialDaggerConversion = 100; public int sacrificialDaggerConversion = 100;
@Config.Comment({ "Will rewrite any default meteor types with new versions.", "Disable this if you want any of your changes to stay, or do not want default meteor types regenerated." }) @Config.Comment({"Will rewrite any default meteor types with new versions.", "Disable this if you want any of your changes to stay, or do not want default meteor types regenerated."})
public boolean shouldResyncMeteors = true; public boolean shouldResyncMeteors = true;
@Config.Comment({ "Should mobs that die through the Well of Suffering Ritual drop items?"}) @Config.Comment({"Should mobs that die through the Well of Suffering Ritual drop items?"})
public boolean wellOfSufferingDrops = true; public boolean wellOfSufferingDrops = true;
} }
public static class ConfigClient public static class ConfigClient {
{ @Config.Comment({"Always render the beams between routing nodes.", "If disabled, the beams will only render while the Node Router is held."})
@Config.Comment({ "Always render the beams between routing nodes.", "If disabled, the beams will only render while the Node Router is held." })
public boolean alwaysRenderRoutingLines = false; public boolean alwaysRenderRoutingLines = false;
@Config.Comment({ "Completely hide spectral blocks from view.", "If disabled, a transparent block will be displayed." }) @Config.Comment({"Completely hide spectral blocks from view.", "If disabled, a transparent block will be displayed."})
public boolean invisibleSpectralBlocks = true; public boolean invisibleSpectralBlocks = true;
@Config.Comment({ "When cycling through slots, the Sigil of Holding will skip over empty slots and move to the next occupied one.", "If disabled, it will behave identically to the default hotbar." }) @Config.Comment({"When cycling through slots, the Sigil of Holding will skip over empty slots and move to the next occupied one.", "If disabled, it will behave identically to the default hotbar."})
public boolean sigilHoldingSkipsEmptySlots = false; public boolean sigilHoldingSkipsEmptySlots = false;
} }
public static class ConfigCompat public static class ConfigCompat {
{ @Config.Comment({"The display mode to use when looking at a Blood Altar.", "ALWAYS - Always display information.", "SIGIL_HELD - Only display information when a Divination or Seers sigil is held in either hand.", "SIGIL_CONTAINED - Only display information when a Divination or Seers sigil is somewhere in the inventory."})
@Config.Comment({ "The display mode to use when looking at a Blood Altar.", "ALWAYS - Always display information.", "SIGIL_HELD - Only display information when a Divination or Seers sigil is held in either hand.", "SIGIL_CONTAINED - Only display information when a Divination or Seers sigil is somewhere in the inventory." })
public AltarDisplayMode wailaAltarDisplayMode = AltarDisplayMode.SIGIL_HELD; public AltarDisplayMode wailaAltarDisplayMode = AltarDisplayMode.SIGIL_HELD;
public enum AltarDisplayMode public enum AltarDisplayMode {
{
ALWAYS, ALWAYS,
SIGIL_HELD, SIGIL_HELD,
SIGIL_CONTAINED, ; SIGIL_CONTAINED,
;
} }
} }
} }

102
src/main/java/WayofTime/bloodmagic/alchemyArray/AlchemyArrayEffectArrowTurret.java
View file

@ -22,8 +22,7 @@ import net.minecraft.world.World;
import net.minecraftforge.items.IItemHandler; import net.minecraftforge.items.IItemHandler;
import WayofTime.bloodmagic.util.Utils; import WayofTime.bloodmagic.util.Utils;
public class AlchemyArrayEffectArrowTurret extends AlchemyArrayEffect public class AlchemyArrayEffectArrowTurret extends AlchemyArrayEffect {
{
public EntityLiving target; public EntityLiving target;
public int arrowTimer; public int arrowTimer;
public static final int ARROW_WINDUP = 50; public static final int ARROW_WINDUP = 50;
@ -34,49 +33,39 @@ public class AlchemyArrayEffectArrowTurret extends AlchemyArrayEffect
private double yaw = 0; private double yaw = 0;
private double lastYaw = 0; private double lastYaw = 0;
public AlchemyArrayEffectArrowTurret(String key) public AlchemyArrayEffectArrowTurret(String key) {
{
super(key); super(key);
} }
@Override @Override
public boolean update(TileEntity tile, int ticksActive) public boolean update(TileEntity tile, int ticksActive) {
{
BlockPos pos = tile.getPos(); BlockPos pos = tile.getPos();
World world = tile.getWorld(); World world = tile.getWorld();
BlockPos chestPos = pos.down(); BlockPos chestPos = pos.down();
TileEntity chestTile = world.getTileEntity(chestPos); TileEntity chestTile = world.getTileEntity(chestPos);
if (chestTile == null) if (chestTile == null) {
{
return false; return false;
} }
IItemHandler itemHandler = Utils.getInventory(chestTile, EnumFacing.UP); IItemHandler itemHandler = Utils.getInventory(chestTile, EnumFacing.UP);
if (itemHandler == null) if (itemHandler == null) {
{
return false; return false;
} }
ItemStack arrowStack = new ItemStack(Items.AIR); ItemStack arrowStack = new ItemStack(Items.AIR);
if (lastChestSlot >= 0 && lastChestSlot < itemHandler.getSlots()) if (lastChestSlot >= 0 && lastChestSlot < itemHandler.getSlots()) {
{
ItemStack testStack = itemHandler.extractItem(lastChestSlot, 1, true); ItemStack testStack = itemHandler.extractItem(lastChestSlot, 1, true);
if (testStack.isEmpty() || !(testStack.getItem() instanceof ItemArrow)) if (testStack.isEmpty() || !(testStack.getItem() instanceof ItemArrow)) {
{
lastChestSlot = -1; lastChestSlot = -1;
} else } else {
{
arrowStack = testStack; arrowStack = testStack;
} }
} }
if (lastChestSlot < 0) if (lastChestSlot < 0) {
{ for (int i = 0; i < itemHandler.getSlots(); i++) {
for (int i = 0; i < itemHandler.getSlots(); i++)
{
ItemStack testStack = itemHandler.extractItem(i, 1, true); ItemStack testStack = itemHandler.extractItem(i, 1, true);
if (!testStack.isEmpty() && testStack.getItem() instanceof ItemArrow) if (!testStack.isEmpty() && testStack.getItem() instanceof ItemArrow) {
{
arrowStack = testStack; arrowStack = testStack;
lastChestSlot = i; lastChestSlot = i;
break; break;
@ -85,13 +74,11 @@ public class AlchemyArrayEffectArrowTurret extends AlchemyArrayEffect
} }
if (lastChestSlot < 0) if (lastChestSlot < 0) {
{
return false; //No arrows in the chest. Welp! return false; //No arrows in the chest. Welp!
} }
if (canFireOnMob(world, pos, target)) if (canFireOnMob(world, pos, target)) {
{
Vector2d pitchYaw = getPitchYaw(pos, target); Vector2d pitchYaw = getPitchYaw(pos, target);
lastPitch = pitch; lastPitch = pitch;
lastYaw = yaw; lastYaw = yaw;
@ -99,27 +86,23 @@ public class AlchemyArrayEffectArrowTurret extends AlchemyArrayEffect
yaw = pitchYaw.y; yaw = pitchYaw.y;
arrowTimer++; arrowTimer++;
if (arrowTimer >= ARROW_WINDUP) if (arrowTimer >= ARROW_WINDUP) {
{
// ItemStack arrowStack = new ItemStack(Items.ARROW); // ItemStack arrowStack = new ItemStack(Items.ARROW);
fireOnTarget(world, pos, arrowStack, target); fireOnTarget(world, pos, arrowStack, target);
if (!world.isRemote) if (!world.isRemote) {
{
itemHandler.extractItem(lastChestSlot, 1, false); itemHandler.extractItem(lastChestSlot, 1, false);
} }
arrowTimer = 0; arrowTimer = 0;
} }
return false; return false;
} else } else {
{
target = null; target = null;
arrowTimer = -1; arrowTimer = -1;
} }
List<EntityMob> mobsInRange = world.getEntitiesWithinAABB(EntityMob.class, getBounds(pos)); List<EntityMob> mobsInRange = world.getEntitiesWithinAABB(EntityMob.class, getBounds(pos));
for (EntityMob entity : mobsInRange) for (EntityMob entity : mobsInRange) {
{
if (canFireOnMob(world, pos, entity))// && isMobInFilter(ent)) if (canFireOnMob(world, pos, entity))// && isMobInFilter(ent))
{ {
target = entity; target = entity;
@ -133,34 +116,27 @@ public class AlchemyArrayEffectArrowTurret extends AlchemyArrayEffect
return false; return false;
} }
public double getPitch() public double getPitch() {
{
return pitch; return pitch;
} }
public double getLastPitch() public double getLastPitch() {
{
return lastPitch; return lastPitch;
} }
public double getYaw() public double getYaw() {
{
return yaw; return yaw;
} }
public double getLastYaw() public double getLastYaw() {
{
return lastYaw; return lastYaw;
} }
public void fireOnTarget(World world, BlockPos pos, ItemStack arrowStack, EntityLiving targetMob) public void fireOnTarget(World world, BlockPos pos, ItemStack arrowStack, EntityLiving targetMob) {
{
float vel = 3f; float vel = 3f;
double damage = 2; double damage = 2;
if (!world.isRemote) if (!world.isRemote) {
{ if (arrowStack.getItem() instanceof ItemArrow) {
if (arrowStack.getItem() instanceof ItemArrow)
{
// ItemArrow arrow = (ItemArrow) arrowStack.getItem(); // ItemArrow arrow = (ItemArrow) arrowStack.getItem();
// EntityArrow entityarrow = arrow.createArrow(world, arrowStack, targetMob); // EntityArrow entityarrow = arrow.createArrow(world, arrowStack, targetMob);
EntityTippedArrow entityarrow = new EntityTippedArrow(world); EntityTippedArrow entityarrow = new EntityTippedArrow(world);
@ -180,10 +156,8 @@ public class AlchemyArrayEffectArrowTurret extends AlchemyArrayEffect
} }
} }
public static Vector2d getPitchYaw(BlockPos pos, Entity entityIn) public static Vector2d getPitchYaw(BlockPos pos, Entity entityIn) {
{ if (entityIn == null) {
if (entityIn == null)
{
return new Vector2d(0, 0); return new Vector2d(0, 0);
} }
@ -197,46 +171,38 @@ public class AlchemyArrayEffectArrowTurret extends AlchemyArrayEffect
return new Vector2d(pitch, yaw); return new Vector2d(pitch, yaw);
} }
public boolean canEntityBeSeen(World world, BlockPos pos, Entity entityIn) public boolean canEntityBeSeen(World world, BlockPos pos, Entity entityIn) {
{
return world.rayTraceBlocks(new Vec3d(pos.getX() + 0.5, pos.getY() + 0.5, pos.getZ() + 0.5), new Vec3d(entityIn.posX, entityIn.posY + (double) entityIn.getEyeHeight(), entityIn.posZ), false, true, false) == null; return world.rayTraceBlocks(new Vec3d(pos.getX() + 0.5, pos.getY() + 0.5, pos.getZ() + 0.5), new Vec3d(entityIn.posX, entityIn.posY + (double) entityIn.getEyeHeight(), entityIn.posZ), false, true, false) == null;
} }
public boolean canFireOnMob(World world, BlockPos pos, Entity entityIn) public boolean canFireOnMob(World world, BlockPos pos, Entity entityIn) {
{
return entityIn != null && !entityIn.isDead && entityIn.getDistanceSqToCenter(pos) <= getRange() * getRange() && entityIn.getDistanceSqToCenter(pos) >= getMinRange() * getMinRange() && canEntityBeSeen(world, pos, entityIn); return entityIn != null && !entityIn.isDead && entityIn.getDistanceSqToCenter(pos) <= getRange() * getRange() && entityIn.getDistanceSqToCenter(pos) >= getMinRange() * getMinRange() && canEntityBeSeen(world, pos, entityIn);
} }
public AxisAlignedBB getBounds(BlockPos pos) public AxisAlignedBB getBounds(BlockPos pos) {
{
return new AxisAlignedBB(pos).grow(getRange(), getRange(), getRange()); return new AxisAlignedBB(pos).grow(getRange(), getRange(), getRange());
} }
public float getRange() public float getRange() {
{
return 32; return 32;
} }
public float getMinRange() public float getMinRange() {
{
return 3; return 3;
} }
@Override @Override
public void writeToNBT(NBTTagCompound tag) public void writeToNBT(NBTTagCompound tag) {
{
} }
@Override @Override
public void readFromNBT(NBTTagCompound tag) public void readFromNBT(NBTTagCompound tag) {
{
} }
@Override @Override
public AlchemyArrayEffect getNewCopy() public AlchemyArrayEffect getNewCopy() {
{
return new AlchemyArrayEffectArrowTurret(key); return new AlchemyArrayEffectArrowTurret(key);
} }

72
src/main/java/WayofTime/bloodmagic/alchemyArray/AlchemyArrayEffectFurnaceFuel.java
View file

@ -17,25 +17,21 @@ import net.minecraft.util.math.AxisAlignedBB;
import net.minecraft.util.math.BlockPos; import net.minecraft.util.math.BlockPos;
import net.minecraft.world.World; import net.minecraft.world.World;
public class AlchemyArrayEffectFurnaceFuel extends AlchemyArrayEffect public class AlchemyArrayEffectFurnaceFuel extends AlchemyArrayEffect {
{
static double radius = 10; static double radius = 10;
static int burnTicksAdded = 401; //Set to +1 more than it needs to be due to a hacky method - basically done so that the array doesn't double dip your health if you only add one item. static int burnTicksAdded = 401; //Set to +1 more than it needs to be due to a hacky method - basically done so that the array doesn't double dip your health if you only add one item.
public AlchemyArrayEffectFurnaceFuel(String key) public AlchemyArrayEffectFurnaceFuel(String key) {
{
super(key); super(key);
} }
@Override @Override
public boolean update(TileEntity tile, int ticksActive) public boolean update(TileEntity tile, int ticksActive) {
{
BlockPos pos = tile.getPos(); BlockPos pos = tile.getPos();
World world = tile.getWorld(); World world = tile.getWorld();
EntityPlayer sacrifice = null; EntityPlayer sacrifice = null;
for (EnumFacing face : EnumFacing.VALUES) for (EnumFacing face : EnumFacing.VALUES) {
{
BlockPos furnacePos = pos.offset(face); BlockPos furnacePos = pos.offset(face);
Block block = world.getBlockState(furnacePos).getBlock(); Block block = world.getBlockState(furnacePos).getBlock();
if (block != Blocks.FURNACE) //This will only work vanilla furnaces. No others! if (block != Blocks.FURNACE) //This will only work vanilla furnaces. No others!
@ -44,33 +40,25 @@ public class AlchemyArrayEffectFurnaceFuel extends AlchemyArrayEffect
} }
TileEntity bottomTile = world.getTileEntity(furnacePos); TileEntity bottomTile = world.getTileEntity(furnacePos);
if (bottomTile instanceof TileEntityFurnace) if (bottomTile instanceof TileEntityFurnace) {
{
TileEntityFurnace furnaceTile = (TileEntityFurnace) bottomTile; TileEntityFurnace furnaceTile = (TileEntityFurnace) bottomTile;
if (canFurnaceSmelt(furnaceTile) && !furnaceTile.isBurning()) if (canFurnaceSmelt(furnaceTile) && !furnaceTile.isBurning()) {
{ if (sacrifice == null || sacrifice.isDead) {
if (sacrifice == null || sacrifice.isDead)
{
AxisAlignedBB bb = new AxisAlignedBB(pos).grow(radius); AxisAlignedBB bb = new AxisAlignedBB(pos).grow(radius);
List<EntityPlayer> playerList = world.getEntitiesWithinAABB(EntityPlayer.class, bb); List<EntityPlayer> playerList = world.getEntitiesWithinAABB(EntityPlayer.class, bb);
for (EntityPlayer player : playerList) for (EntityPlayer player : playerList) {
{ if (!player.isDead) {
if (!player.isDead)
{
sacrifice = player; sacrifice = player;
} }
} }
} }
if (sacrifice == null || sacrifice.isDead) if (sacrifice == null || sacrifice.isDead) {
{
return false; return false;
} }
if (addFuelTime(furnaceTile, world, furnacePos, burnTicksAdded)) if (addFuelTime(furnaceTile, world, furnacePos, burnTicksAdded)) {
{ if (!sacrifice.capabilities.isCreativeMode) {
if (!sacrifice.capabilities.isCreativeMode)
{
sacrifice.hurtResistantTime = 0; sacrifice.hurtResistantTime = 0;
sacrifice.attackEntityFrom(DamageSourceBloodMagic.INSTANCE, 1.0F); //No. sacrifice.attackEntityFrom(DamageSourceBloodMagic.INSTANCE, 1.0F); //No.
} }
@ -82,41 +70,32 @@ public class AlchemyArrayEffectFurnaceFuel extends AlchemyArrayEffect
return false; return false;
} }
public static boolean addFuelTime(TileEntityFurnace furnaceTile, World world, BlockPos furnacePos, int cookTime) public static boolean addFuelTime(TileEntityFurnace furnaceTile, World world, BlockPos furnacePos, int cookTime) {
{
furnaceTile.setField(0, cookTime); furnaceTile.setField(0, cookTime);
BlockFurnace.setState(true, world, furnacePos); BlockFurnace.setState(true, world, furnacePos);
return true; return true;
} }
public static boolean canFurnaceSmelt(TileEntityFurnace furnaceTile) public static boolean canFurnaceSmelt(TileEntityFurnace furnaceTile) {
{
ItemStack burnStack = furnaceTile.getStackInSlot(0); ItemStack burnStack = furnaceTile.getStackInSlot(0);
if (burnStack.isEmpty()) if (burnStack.isEmpty()) {
{
return false; return false;
} else } else {
{
ItemStack resultStack = FurnaceRecipes.instance().getSmeltingResult(burnStack); ItemStack resultStack = FurnaceRecipes.instance().getSmeltingResult(burnStack);
if (resultStack.isEmpty()) if (resultStack.isEmpty()) {
{
return false; return false;
} else } else {
{
ItemStack finishStack = furnaceTile.getStackInSlot(2); ItemStack finishStack = furnaceTile.getStackInSlot(2);
if (finishStack.isEmpty()) if (finishStack.isEmpty()) {
{
return true; return true;
} else if (!finishStack.isItemEqual(resultStack)) } else if (!finishStack.isItemEqual(resultStack)) {
{
return false; return false;
} else if (finishStack.getCount() + resultStack.getCount() <= furnaceTile.getInventoryStackLimit() && finishStack.getCount() + resultStack.getCount() <= finishStack.getMaxStackSize()) // Forge fix: make furnace respect stack sizes in furnace recipes } else if (finishStack.getCount() + resultStack.getCount() <= furnaceTile.getInventoryStackLimit() && finishStack.getCount() + resultStack.getCount() <= finishStack.getMaxStackSize()) // Forge fix: make furnace respect stack sizes in furnace recipes
{ {
return true; return true;
} else } else {
{
return finishStack.getCount() + resultStack.getCount() <= resultStack.getMaxStackSize(); // Forge fix: make furnace respect stack sizes in furnace recipes return finishStack.getCount() + resultStack.getCount() <= resultStack.getMaxStackSize(); // Forge fix: make furnace respect stack sizes in furnace recipes
} }
} }
@ -124,20 +103,17 @@ public class AlchemyArrayEffectFurnaceFuel extends AlchemyArrayEffect
} }
@Override @Override
public void writeToNBT(NBTTagCompound tag) public void writeToNBT(NBTTagCompound tag) {
{
} }
@Override @Override
public void readFromNBT(NBTTagCompound tag) public void readFromNBT(NBTTagCompound tag) {
{
} }
@Override @Override
public AlchemyArrayEffect getNewCopy() public AlchemyArrayEffect getNewCopy() {
{
return new AlchemyArrayEffectFurnaceFuel(key); return new AlchemyArrayEffectFurnaceFuel(key);
} }
} }

60
src/main/java/WayofTime/bloodmagic/alchemyArray/AlchemyArrayEffectLaputa.java
View file

@ -13,8 +13,7 @@ import WayofTime.bloodmagic.tile.TileAlchemyArray;
import WayofTime.bloodmagic.util.Constants; import WayofTime.bloodmagic.util.Constants;
import WayofTime.bloodmagic.util.Utils; import WayofTime.bloodmagic.util.Utils;
public class AlchemyArrayEffectLaputa extends AlchemyArrayEffect public class AlchemyArrayEffectLaputa extends AlchemyArrayEffect {
{
public static final int TELEPOSE_DELAY = 4; public static final int TELEPOSE_DELAY = 4;
private BlockPos currentPos = BlockPos.ORIGIN; private BlockPos currentPos = BlockPos.ORIGIN;
@ -22,20 +21,16 @@ public class AlchemyArrayEffectLaputa extends AlchemyArrayEffect
private int radius = -1; private int radius = -1;
private int teleportHeightOffset = 5; private int teleportHeightOffset = 5;
public AlchemyArrayEffectLaputa(String key) public AlchemyArrayEffectLaputa(String key) {
{
super(key); super(key);
} }
@Override @Override
public boolean update(TileEntity tile, int ticksActive) public boolean update(TileEntity tile, int ticksActive) {
{ if (ticksActive >= 100) {
if (ticksActive >= 100)
{
World world = tile.getWorld(); World world = tile.getWorld();
if (radius == -1) if (radius == -1) {
{
((TileAlchemyArray) tile).setItemDrop(false); ((TileAlchemyArray) tile).setItemDrop(false);
radius = getRandomRadius(world.rand); radius = getRandomRadius(world.rand);
teleportHeightOffset = getRandomHeightOffset(world.rand); teleportHeightOffset = getRandomHeightOffset(world.rand);
@ -43,8 +38,7 @@ public class AlchemyArrayEffectLaputa extends AlchemyArrayEffect
} }
BlockPos pos = tile.getPos(); BlockPos pos = tile.getPos();
if (world.isRemote) if (world.isRemote) {
{
return false; return false;
} }
@ -52,8 +46,7 @@ public class AlchemyArrayEffectLaputa extends AlchemyArrayEffect
int i = -radius; int i = -radius;
int k = -radius; int k = -radius;
if (currentPos != null) if (currentPos != null) {
{
j = currentPos.getY(); j = currentPos.getY();
i = currentPos.getX(); i = currentPos.getX();
k = currentPos.getZ(); k = currentPos.getZ();
@ -61,34 +54,27 @@ public class AlchemyArrayEffectLaputa extends AlchemyArrayEffect
int checks = 0; int checks = 0;
int maxChecks = 100; int maxChecks = 100;
while (j <= radius) while (j <= radius) {
{ while (i <= radius) {
while (i <= radius) while (k <= radius) {
{ if (i == 0 && j == 0 && k == 0) {
while (k <= radius)
{
if (i == 0 && j == 0 && k == 0)
{
k++; k++;
continue; continue;
} }
checks++; checks++;
if (checks >= maxChecks) if (checks >= maxChecks) {
{
this.currentPos = new BlockPos(i, j, k); this.currentPos = new BlockPos(i, j, k);
return false; return false;
} }
if (checkIfSphere(radius, i, j, k)) if (checkIfSphere(radius, i, j, k)) {
{
BlockPos newPos = pos.add(i, j, k); BlockPos newPos = pos.add(i, j, k);
BlockPos offsetPos = newPos.up(teleportHeightOffset); BlockPos offsetPos = newPos.up(teleportHeightOffset);
IBlockState state = world.getBlockState(newPos); IBlockState state = world.getBlockState(newPos);
TeleposeEvent event = new TeleposeEvent(world, newPos, world, offsetPos); TeleposeEvent event = new TeleposeEvent(world, newPos, world, offsetPos);
if (state.getBlockHardness(world, newPos) > 0 && !MinecraftForge.EVENT_BUS.post(event) && Utils.swapLocations(event.initalWorld, event.initialBlockPos, event.finalWorld, event.finalBlockPos)) if (state.getBlockHardness(world, newPos) > 0 && !MinecraftForge.EVENT_BUS.post(event) && Utils.swapLocations(event.initalWorld, event.initialBlockPos, event.finalWorld, event.finalBlockPos)) {
{
k++; k++;
this.currentPos = new BlockPos(i, j, k); this.currentPos = new BlockPos(i, j, k);
@ -112,25 +98,21 @@ public class AlchemyArrayEffectLaputa extends AlchemyArrayEffect
return false; return false;
} }
public boolean checkIfSphere(float radius, float xOff, float yOff, float zOff) public boolean checkIfSphere(float radius, float xOff, float yOff, float zOff) {
{
float possOffset = 0.5f; float possOffset = 0.5f;
return xOff * xOff + yOff * yOff + zOff * zOff <= ((radius + possOffset) * (radius + possOffset)); return xOff * xOff + yOff * yOff + zOff * zOff <= ((radius + possOffset) * (radius + possOffset));
} }
public int getRandomRadius(Random rand) public int getRandomRadius(Random rand) {
{
return rand.nextInt(5) + 4; return rand.nextInt(5) + 4;
} }
public int getRandomHeightOffset(Random rand) public int getRandomHeightOffset(Random rand) {
{
return radius * 2 + 1 + rand.nextInt(5); return radius * 2 + 1 + rand.nextInt(5);
} }
@Override @Override
public void writeToNBT(NBTTagCompound tag) public void writeToNBT(NBTTagCompound tag) {
{
tag.setInteger("radius", radius); tag.setInteger("radius", radius);
tag.setInteger("teleportHeightOffset", teleportHeightOffset); tag.setInteger("teleportHeightOffset", teleportHeightOffset);
tag.setInteger(Constants.NBT.X_COORD, currentPos.getX()); tag.setInteger(Constants.NBT.X_COORD, currentPos.getX());
@ -139,16 +121,14 @@ public class AlchemyArrayEffectLaputa extends AlchemyArrayEffect
} }
@Override @Override
public void readFromNBT(NBTTagCompound tag) public void readFromNBT(NBTTagCompound tag) {
{
radius = tag.getInteger("radius"); radius = tag.getInteger("radius");
teleportHeightOffset = tag.getInteger("teleportHeightOffset"); teleportHeightOffset = tag.getInteger("teleportHeightOffset");
currentPos = new BlockPos(tag.getInteger(Constants.NBT.X_COORD), tag.getInteger(Constants.NBT.Y_COORD), tag.getInteger(Constants.NBT.Z_COORD)); currentPos = new BlockPos(tag.getInteger(Constants.NBT.X_COORD), tag.getInteger(Constants.NBT.Y_COORD), tag.getInteger(Constants.NBT.Z_COORD));
} }
@Override @Override
public AlchemyArrayEffect getNewCopy() public AlchemyArrayEffect getNewCopy() {
{
return new AlchemyArrayEffectLaputa(key); return new AlchemyArrayEffectLaputa(key);
} }
} }

84
src/main/java/WayofTime/bloodmagic/alchemyArray/AlchemyArrayEffectMobSacrifice.java
View file

@ -29,29 +29,24 @@ import WayofTime.bloodmagic.ritual.AreaDescriptor;
import WayofTime.bloodmagic.util.DamageSourceBloodMagic; import WayofTime.bloodmagic.util.DamageSourceBloodMagic;
import WayofTime.bloodmagic.util.helper.PurificationHelper; import WayofTime.bloodmagic.util.helper.PurificationHelper;
public class AlchemyArrayEffectMobSacrifice extends AlchemyArrayEffect public class AlchemyArrayEffectMobSacrifice extends AlchemyArrayEffect {
{
public static final AreaDescriptor itemDescriptor = new AreaDescriptor.Rectangle(new BlockPos(-5, -5, -5), 11); public static final AreaDescriptor itemDescriptor = new AreaDescriptor.Rectangle(new BlockPos(-5, -5, -5), 11);
public static final AreaDescriptor mobDescriptor = new AreaDescriptor.Rectangle(new BlockPos(-5, -5, -5), 11); public static final AreaDescriptor mobDescriptor = new AreaDescriptor.Rectangle(new BlockPos(-5, -5, -5), 11);
public int craftTime = 0; public int craftTime = 0;
public static final int REQUIRED_CRAFT_TIME = 200; public static final int REQUIRED_CRAFT_TIME = 200;
public AlchemyArrayEffectMobSacrifice(String key) public AlchemyArrayEffectMobSacrifice(String key) {
{
super(key); super(key);
} }
@Override @Override
public boolean update(TileEntity tile, int ticksActive) public boolean update(TileEntity tile, int ticksActive) {
{
World world = tile.getWorld(); World world = tile.getWorld();
if (world.isRemote && ticksActive < 200 && ticksActive > 40) if (world.isRemote && ticksActive < 200 && ticksActive > 40) {
{
BlockPos pos = tile.getPos(); BlockPos pos = tile.getPos();
Random rand = world.rand; Random rand = world.rand;
for (int i = 0; i < 2; i++) for (int i = 0; i < 2; i++) {
{
double d0 = (double) pos.getX() + 0.5D + (rand.nextDouble() - 0.5D) * 2.5D; double d0 = (double) pos.getX() + 0.5D + (rand.nextDouble() - 0.5D) * 2.5D;
double d1 = (double) pos.getY() + 0.2D + (rand.nextDouble() - 0.5D) * 0.2D; double d1 = (double) pos.getY() + 0.2D + (rand.nextDouble() - 0.5D) * 0.2D;
double d2 = (double) pos.getZ() + 0.5D + (rand.nextDouble() - 0.5D) * 2.5D; double d2 = (double) pos.getZ() + 0.5D + (rand.nextDouble() - 0.5D) * 2.5D;
@ -61,26 +56,22 @@ public class AlchemyArrayEffectMobSacrifice extends AlchemyArrayEffect
//We need to do the check on both sides to correctly do particles. //We need to do the check on both sides to correctly do particles.
if (ticksActive >= 200) if (ticksActive >= 200) {
{
BlockPos pos = tile.getPos(); BlockPos pos = tile.getPos();
List<EntityItem> itemList = world.getEntitiesWithinAABB(EntityItem.class, itemDescriptor.getAABB(pos)); List<EntityItem> itemList = world.getEntitiesWithinAABB(EntityItem.class, itemDescriptor.getAABB(pos));
List<ItemStack> inputList = new ArrayList<ItemStack>(); List<ItemStack> inputList = new ArrayList<ItemStack>();
for (EntityItem entityItem : itemList) for (EntityItem entityItem : itemList) {
{ if (entityItem.isDead || entityItem.getItem().isEmpty()) {
if (entityItem.isDead || entityItem.getItem().isEmpty())
{
continue; continue;
} }
inputList.add(entityItem.getItem().copy()); inputList.add(entityItem.getItem().copy());
} }
if (inputList.isEmpty()) if (inputList.isEmpty()) {
{
return false; return false;
} }
@ -90,52 +81,42 @@ public class AlchemyArrayEffectMobSacrifice extends AlchemyArrayEffect
} }
RecipeSacrificeCraft recipe = BloodMagicAPI.INSTANCE.getRecipeRegistrar().getSacrificeCraft(inputList); RecipeSacrificeCraft recipe = BloodMagicAPI.INSTANCE.getRecipeRegistrar().getSacrificeCraft(inputList);
if (recipe != null) if (recipe != null) {
{
double healthRequired = recipe.getHealthRequired(); double healthRequired = recipe.getHealthRequired();
double healthAvailable = 0; double healthAvailable = 0;
List<EntityLivingBase> livingEntities = world.getEntitiesWithinAABB(EntityLivingBase.class, mobDescriptor.getAABB(pos)); List<EntityLivingBase> livingEntities = world.getEntitiesWithinAABB(EntityLivingBase.class, mobDescriptor.getAABB(pos));
for (EntityLivingBase living : livingEntities) for (EntityLivingBase living : livingEntities) {
{
double health = getEffectiveHealth(living); double health = getEffectiveHealth(living);
if (health > 0) if (health > 0) {
{
healthAvailable += health; healthAvailable += health;
} }
} }
if (healthAvailable < healthRequired) if (healthAvailable < healthRequired) {
{
craftTime = 0; craftTime = 0;
return false; return false;
} }
craftTime++; craftTime++;
if (craftTime >= REQUIRED_CRAFT_TIME) if (craftTime >= REQUIRED_CRAFT_TIME) {
{ if (!world.isRemote) {
if (!world.isRemote) for (EntityLivingBase living : livingEntities) {
{
for (EntityLivingBase living : livingEntities)
{
double health = getEffectiveHealth(living); double health = getEffectiveHealth(living);
if (healthAvailable > 0 && health > 0) if (healthAvailable > 0 && health > 0) {
{
healthAvailable -= health; healthAvailable -= health;
living.getEntityWorld().playSound(null, living.posX, living.posY, living.posZ, SoundEvents.BLOCK_FIRE_EXTINGUISH, SoundCategory.BLOCKS, 0.5F, 2.6F + (living.getEntityWorld().rand.nextFloat() - living.getEntityWorld().rand.nextFloat()) * 0.8F); living.getEntityWorld().playSound(null, living.posX, living.posY, living.posZ, SoundEvents.BLOCK_FIRE_EXTINGUISH, SoundCategory.BLOCKS, 0.5F, 2.6F + (living.getEntityWorld().rand.nextFloat() - living.getEntityWorld().rand.nextFloat()) * 0.8F);
living.setHealth(-1); living.setHealth(-1);
living.onDeath(DamageSourceBloodMagic.INSTANCE); living.onDeath(DamageSourceBloodMagic.INSTANCE);
} }
if (healthAvailable <= 0) if (healthAvailable <= 0) {
{
break; break;
} }
} }
for (EntityItem itemEntity : itemList) for (EntityItem itemEntity : itemList) {
{
itemEntity.getItem().setCount(itemEntity.getItem().getCount() - 1); itemEntity.getItem().setCount(itemEntity.getItem().getCount() - 1);
if (itemEntity.getItem().isEmpty()) //TODO: Check container if (itemEntity.getItem().isEmpty()) //TODO: Check container
{ {
@ -146,13 +127,10 @@ public class AlchemyArrayEffectMobSacrifice extends AlchemyArrayEffect
world.spawnEntity(new EntityItem(world, pos.getX() + 0.5, pos.getY() + 2.5, pos.getZ() + 0.5, recipe.getOutput())); world.spawnEntity(new EntityItem(world, pos.getX() + 0.5, pos.getY() + 2.5, pos.getZ() + 0.5, recipe.getOutput()));
craftTime = 0; craftTime = 0;
} }
} else } else {
{ if (world.isRemote) {
if (world.isRemote)
{
Vec3d spawnPosition = new Vec3d(pos.getX() + 0.5, pos.getY() + 2.5, pos.getZ() + 0.5); Vec3d spawnPosition = new Vec3d(pos.getX() + 0.5, pos.getY() + 2.5, pos.getZ() + 0.5);
for (EntityItem itemEntity : itemList) for (EntityItem itemEntity : itemList) {
{
ItemStack stack = itemEntity.getItem(); ItemStack stack = itemEntity.getItem();
double velocityFactor = 0.1; double velocityFactor = 0.1;
@ -168,11 +146,9 @@ public class AlchemyArrayEffectMobSacrifice extends AlchemyArrayEffect
// world.spawnParticle(EnumParticleTypes.ITEM_CRACK, spawnPosition.x, spawnPosition.y, spawnPosition.z, velVec2.x, velVec2.y, velVec2.z, Item.getIdFromItem(stack.getItem()), stack.getMetadata()); // world.spawnParticle(EnumParticleTypes.ITEM_CRACK, spawnPosition.x, spawnPosition.y, spawnPosition.z, velVec2.x, velVec2.y, velVec2.z, Item.getIdFromItem(stack.getItem()), stack.getMetadata());
} }
for (EntityLivingBase living : livingEntities) for (EntityLivingBase living : livingEntities) {
{
double health = getEffectiveHealth(living); double health = getEffectiveHealth(living);
if (health <= 0) if (health <= 0) {
{
continue; continue;
} }
double d0 = (double) living.posX + (world.rand.nextDouble() - 0.5D) * 0.5D; double d0 = (double) living.posX + (world.rand.nextDouble() - 0.5D) * 0.5D;
@ -189,8 +165,7 @@ public class AlchemyArrayEffectMobSacrifice extends AlchemyArrayEffect
} }
//Future-proofing in case I want to make different mobs give different effective health //Future-proofing in case I want to make different mobs give different effective health
public double getEffectiveHealth(EntityLivingBase living) public double getEffectiveHealth(EntityLivingBase living) {
{
if (living == null) if (living == null)
return 0; return 0;
@ -214,20 +189,17 @@ public class AlchemyArrayEffectMobSacrifice extends AlchemyArrayEffect
} }
@Override @Override
public void writeToNBT(NBTTagCompound tag) public void writeToNBT(NBTTagCompound tag) {
{
} }
@Override @Override
public void readFromNBT(NBTTagCompound tag) public void readFromNBT(NBTTagCompound tag) {
{
} }
@Override @Override
public AlchemyArrayEffect getNewCopy() public AlchemyArrayEffect getNewCopy() {
{
return new AlchemyArrayEffectMobSacrifice(key); return new AlchemyArrayEffectMobSacrifice(key);
} }
} }

24
src/main/java/WayofTime/bloodmagic/alchemyArray/AlchemyArrayEffectSpike.java
View file

@ -10,43 +10,35 @@ import net.minecraft.util.math.BlockPos;
import net.minecraft.world.World; import net.minecraft.world.World;
import WayofTime.bloodmagic.iface.IAlchemyArray; import WayofTime.bloodmagic.iface.IAlchemyArray;
public class AlchemyArrayEffectSpike extends AlchemyArrayEffect public class AlchemyArrayEffectSpike extends AlchemyArrayEffect {
{ public AlchemyArrayEffectSpike(String key) {
public AlchemyArrayEffectSpike(String key)
{
super(key); super(key);
} }
@Override @Override
public boolean update(TileEntity tile, int ticksActive) public boolean update(TileEntity tile, int ticksActive) {
{
return false; return false;
} }
@Override @Override
public void onEntityCollidedWithBlock(IAlchemyArray array, World world, BlockPos pos, IBlockState state, Entity entity) public void onEntityCollidedWithBlock(IAlchemyArray array, World world, BlockPos pos, IBlockState state, Entity entity) {
{ if (entity instanceof EntityLivingBase) {
if (entity instanceof EntityLivingBase)
{
entity.attackEntityFrom(DamageSource.CACTUS, 2); entity.attackEntityFrom(DamageSource.CACTUS, 2);
} }
} }
@Override @Override
public void writeToNBT(NBTTagCompound tag) public void writeToNBT(NBTTagCompound tag) {
{
} }
@Override @Override
public void readFromNBT(NBTTagCompound tag) public void readFromNBT(NBTTagCompound tag) {
{
} }
@Override @Override
public AlchemyArrayEffect getNewCopy() public AlchemyArrayEffect getNewCopy() {
{
return new AlchemyArrayEffectSpike(key); return new AlchemyArrayEffectSpike(key);
} }
} }

42
src/main/java/WayofTime/bloodmagic/alchemyArray/AlchemyArrayEffectTeleport.java
View file

@ -17,58 +17,47 @@ import net.minecraft.world.WorldServer;
import WayofTime.bloodmagic.core.RegistrarBloodMagicBlocks; import WayofTime.bloodmagic.core.RegistrarBloodMagicBlocks;
import WayofTime.bloodmagic.iface.IAlchemyArray; import WayofTime.bloodmagic.iface.IAlchemyArray;
public class AlchemyArrayEffectTeleport extends AlchemyArrayEffect public class AlchemyArrayEffectTeleport extends AlchemyArrayEffect {
{
public static final int MAX_SEARCH = 20; public static final int MAX_SEARCH = 20;
public static final int TELEPORT_DELAY = 40; public static final int TELEPORT_DELAY = 40;
public AlchemyArrayEffectTeleport(String key) public AlchemyArrayEffectTeleport(String key) {
{
super(key); super(key);
} }
@Override @Override
public boolean update(TileEntity tile, int ticksActive) public boolean update(TileEntity tile, int ticksActive) {
{
return false; return false;
} }
@Override @Override
public void onEntityCollidedWithBlock(IAlchemyArray array, World world, BlockPos pos, IBlockState state, Entity entity) public void onEntityCollidedWithBlock(IAlchemyArray array, World world, BlockPos pos, IBlockState state, Entity entity) {
{
EnumFacing direction = array.getRotation(); EnumFacing direction = array.getRotation();
teleportEntityInDirection(world, pos, entity, direction); teleportEntityInDirection(world, pos, entity, direction);
} }
public void teleportEntityInDirection(World world, BlockPos currentPos, Entity entity, EnumFacing direction) public void teleportEntityInDirection(World world, BlockPos currentPos, Entity entity, EnumFacing direction) {
{ if (entity != null && entity.timeUntilPortal <= 0) {
if (entity != null && entity.timeUntilPortal <= 0) for (int i = 1; i <= MAX_SEARCH; i++) {
{
for (int i = 1; i <= MAX_SEARCH; i++)
{
BlockPos offsetPos = currentPos.offset(direction, i); BlockPos offsetPos = currentPos.offset(direction, i);
Block testBlock = world.getBlockState(offsetPos).getBlock(); Block testBlock = world.getBlockState(offsetPos).getBlock();
if (testBlock == RegistrarBloodMagicBlocks.ALCHEMY_ARRAY) if (testBlock == RegistrarBloodMagicBlocks.ALCHEMY_ARRAY) {
{
int x = offsetPos.getX(); int x = offsetPos.getX();
int y = offsetPos.getY(); int y = offsetPos.getY();
int z = offsetPos.getZ(); int z = offsetPos.getZ();
entity.getEntityWorld().playSound(x, y, z, SoundEvents.ENTITY_ENDERMEN_TELEPORT, SoundCategory.AMBIENT, 1.0F, 1.0F, false); entity.getEntityWorld().playSound(x, y, z, SoundEvents.ENTITY_ENDERMEN_TELEPORT, SoundCategory.AMBIENT, 1.0F, 1.0F, false);
entity.timeUntilPortal = TELEPORT_DELAY; entity.timeUntilPortal = TELEPORT_DELAY;
if (!world.isRemote) if (!world.isRemote) {
{ if (entity instanceof EntityPlayer) {
if (entity instanceof EntityPlayer)
{
EntityPlayerMP player = (EntityPlayerMP) entity; EntityPlayerMP player = (EntityPlayerMP) entity;
player.setPositionAndUpdate(x + 0.5, y + 0.5, z + 0.5); player.setPositionAndUpdate(x + 0.5, y + 0.5, z + 0.5);
player.getEntityWorld().updateEntityWithOptionalForce(player, false); player.getEntityWorld().updateEntityWithOptionalForce(player, false);
player.connection.sendPacket(new SPacketUpdateHealth(player.getHealth(), player.getFoodStats().getFoodLevel(), player.getFoodStats().getSaturationLevel())); player.connection.sendPacket(new SPacketUpdateHealth(player.getHealth(), player.getFoodStats().getFoodLevel(), player.getFoodStats().getSaturationLevel()));
} else } else {
{
WorldServer worldServer = (WorldServer) entity.getEntityWorld(); WorldServer worldServer = (WorldServer) entity.getEntityWorld();
entity.setPosition(x + 0.5, y + 0.5, z + 0.5); entity.setPosition(x + 0.5, y + 0.5, z + 0.5);
@ -82,20 +71,17 @@ public class AlchemyArrayEffectTeleport extends AlchemyArrayEffect
} }
@Override @Override
public void writeToNBT(NBTTagCompound tag) public void writeToNBT(NBTTagCompound tag) {
{
} }
@Override @Override
public void readFromNBT(NBTTagCompound tag) public void readFromNBT(NBTTagCompound tag) {
{
} }
@Override @Override
public AlchemyArrayEffect getNewCopy() public AlchemyArrayEffect getNewCopy() {
{
return new AlchemyArrayEffectTeleport(key); return new AlchemyArrayEffectTeleport(key);
} }
} }

2
src/main/java/WayofTime/bloodmagic/altar/AltarTier.java
View file

@ -127,7 +127,7 @@ public enum AltarTier {
} }
}; };
public static final int MAXTIERS = ConfigHandler.general.enableTierSixEvenThoughThereIsNoContent ? values().length : values().length-1; public static final int MAXTIERS = ConfigHandler.general.enableTierSixEvenThoughThereIsNoContent ? values().length : values().length - 1;
private List<AltarComponent> altarComponents; private List<AltarComponent> altarComponents;

260
src/main/java/WayofTime/bloodmagic/altar/BloodAltar.java
View file

@ -31,8 +31,7 @@ import net.minecraftforge.fluids.capability.IFluidHandler;
import net.minecraftforge.fluids.capability.IFluidTankProperties; import net.minecraftforge.fluids.capability.IFluidTankProperties;
import net.minecraftforge.items.ItemHandlerHelper; import net.minecraftforge.items.ItemHandlerHelper;
public class BloodAltar implements IFluidHandler public class BloodAltar implements IFluidHandler {
{
public boolean isActive; public boolean isActive;
protected FluidStack fluidOutput = new FluidStack(BlockLifeEssence.getLifeEssence(), 0); protected FluidStack fluidOutput = new FluidStack(BlockLifeEssence.getLifeEssence(), 0);
@ -69,15 +68,12 @@ public class BloodAltar implements IFluidHandler
private RecipeBloodAltar recipe; private RecipeBloodAltar recipe;
private AltarTier currentTierDisplayed = AltarTier.ONE; private AltarTier currentTierDisplayed = AltarTier.ONE;
public BloodAltar(TileAltar tileAltar) public BloodAltar(TileAltar tileAltar) {
{
this.tileAltar = tileAltar; this.tileAltar = tileAltar;
} }
public void readFromNBT(NBTTagCompound tagCompound) public void readFromNBT(NBTTagCompound tagCompound) {
{ if (!tagCompound.hasKey(Constants.NBT.EMPTY)) {
if (!tagCompound.hasKey(Constants.NBT.EMPTY))
{
FluidStack fluid = FluidStack.loadFluidStackFromNBT(tagCompound); FluidStack fluid = FluidStack.loadFluidStackFromNBT(tagCompound);
if (fluid != null) if (fluid != null)
@ -120,8 +116,7 @@ public class BloodAltar implements IFluidHandler
currentTierDisplayed = Enums.getIfPresent(AltarTier.class, tagCompound.getString(Constants.NBT.ALTAR_CURRENT_TIER_DISPLAYED)).or(AltarTier.ONE); currentTierDisplayed = Enums.getIfPresent(AltarTier.class, tagCompound.getString(Constants.NBT.ALTAR_CURRENT_TIER_DISPLAYED)).or(AltarTier.ONE);
} }
public void writeToNBT(NBTTagCompound tagCompound) public void writeToNBT(NBTTagCompound tagCompound) {
{
if (fluid != null) if (fluid != null)
fluid.writeToNBT(tagCompound); fluid.writeToNBT(tagCompound);
@ -164,8 +159,7 @@ public class BloodAltar implements IFluidHandler
tagCompound.setString(Constants.NBT.ALTAR_CURRENT_TIER_DISPLAYED, currentTierDisplayed.name()); tagCompound.setString(Constants.NBT.ALTAR_CURRENT_TIER_DISPLAYED, currentTierDisplayed.name());
} }
public void startCycle() public void startCycle() {
{
if (tileAltar.getWorld() != null) if (tileAltar.getWorld() != null)
tileAltar.getWorld().notifyBlockUpdate(tileAltar.getPos(), tileAltar.getWorld().getBlockState(tileAltar.getPos()), tileAltar.getWorld().getBlockState(tileAltar.getPos()), 3); tileAltar.getWorld().notifyBlockUpdate(tileAltar.getPos(), tileAltar.getWorld().getBlockState(tileAltar.getPos()), tileAltar.getWorld().getBlockState(tileAltar.getPos()), 3);
@ -179,14 +173,11 @@ public class BloodAltar implements IFluidHandler
ItemStack input = tileAltar.getStackInSlot(0); ItemStack input = tileAltar.getStackInSlot(0);
if (!input.isEmpty()) if (!input.isEmpty()) {
{
// Do recipes // Do recipes
RecipeBloodAltar recipe = BloodMagicAPI.INSTANCE.getRecipeRegistrar().getBloodAltar(input); RecipeBloodAltar recipe = BloodMagicAPI.INSTANCE.getRecipeRegistrar().getBloodAltar(input);
if (recipe != null) if (recipe != null) {
{ if (recipe.getMinimumTier().ordinal() <= altarTier.ordinal()) {
if (recipe.getMinimumTier().ordinal() <= altarTier.ordinal())
{
this.isActive = true; this.isActive = true;
this.recipe = recipe; this.recipe = recipe;
this.liquidRequired = recipe.getSyphon(); this.liquidRequired = recipe.getSyphon();
@ -195,8 +186,7 @@ public class BloodAltar implements IFluidHandler
this.canBeFilled = false; this.canBeFilled = false;
return; return;
} }
} else if (input.getItem() instanceof IBloodOrb) } else if (input.getItem() instanceof IBloodOrb) {
{
BloodOrb orb = ((IBloodOrb) input.getItem()).getOrb(input); BloodOrb orb = ((IBloodOrb) input.getItem()).getOrb(input);
this.isActive = canBeFilled = orb != null && altarTier.toInt() >= orb.getTier(); this.isActive = canBeFilled = orb != null && altarTier.toInt() >= orb.getTier();
return; return;
@ -206,8 +196,7 @@ public class BloodAltar implements IFluidHandler
isActive = false; isActive = false;
} }
public void update() public void update() {
{
World world = tileAltar.getWorld(); World world = tileAltar.getWorld();
BlockPos pos = tileAltar.getPos(); BlockPos pos = tileAltar.getPos();
@ -220,17 +209,14 @@ public class BloodAltar implements IFluidHandler
if (lockdownDuration > 0) if (lockdownDuration > 0)
lockdownDuration--; lockdownDuration--;
if (internalCounter % 20 == 0) if (internalCounter % 20 == 0) {
{ for (EnumFacing facing : EnumFacing.VALUES) {
for (EnumFacing facing : EnumFacing.VALUES)
{
BlockPos newPos = pos.offset(facing); BlockPos newPos = pos.offset(facing);
IBlockState block = world.getBlockState(newPos); IBlockState block = world.getBlockState(newPos);
block.getBlock().onNeighborChange(world, newPos, pos); block.getBlock().onNeighborChange(world, newPos, pos);
} }
} }
if (internalCounter % (Math.max(20 - this.accelerationUpgrades, 1)) == 0) if (internalCounter % (Math.max(20 - this.accelerationUpgrades, 1)) == 0) {
{
int syphonMax = (int) (20 * this.dislocationMultiplier); int syphonMax = (int) (20 * this.dislocationMultiplier);
int fluidInputted; int fluidInputted;
int fluidOutputted; int fluidOutputted;
@ -245,8 +231,7 @@ public class BloodAltar implements IFluidHandler
tileAltar.getWorld().notifyBlockUpdate(tileAltar.getPos(), tileAltar.getWorld().getBlockState(tileAltar.getPos()), tileAltar.getWorld().getBlockState(tileAltar.getPos()), 3); tileAltar.getWorld().notifyBlockUpdate(tileAltar.getPos(), tileAltar.getWorld().getBlockState(tileAltar.getPos()), tileAltar.getWorld().getBlockState(tileAltar.getPos()), 3);
} }
if (internalCounter % this.getChargingFrequency() == 0 && !this.isActive) if (internalCounter % this.getChargingFrequency() == 0 && !this.isActive) {
{
int chargeInputted = Math.min(chargingRate, this.fluid.amount); int chargeInputted = Math.min(chargingRate, this.fluid.amount);
chargeInputted = Math.min(chargeInputted, maxCharge - totalCharge); chargeInputted = Math.min(chargeInputted, maxCharge - totalCharge);
totalCharge += chargeInputted; totalCharge += chargeInputted;
@ -260,17 +245,14 @@ public class BloodAltar implements IFluidHandler
updateAltar(); updateAltar();
} }
private void updateAltar() private void updateAltar() {
{ if (!isActive) {
if (!isActive)
{
if (cooldownAfterCrafting > 0) if (cooldownAfterCrafting > 0)
cooldownAfterCrafting--; cooldownAfterCrafting--;
return; return;
} }
if (!canBeFilled && recipe == null) if (!canBeFilled && recipe == null) {
{
startCycle(); startCycle();
return; return;
} }
@ -286,13 +268,11 @@ public class BloodAltar implements IFluidHandler
if (world.isRemote) if (world.isRemote)
return; return;
if (!canBeFilled) if (!canBeFilled) {
{
boolean hasOperated = false; boolean hasOperated = false;
int stackSize = input.getCount(); int stackSize = input.getCount();
if (totalCharge > 0) if (totalCharge > 0) {
{
int chargeDrained = Math.min(liquidRequired * stackSize - progress, totalCharge); int chargeDrained = Math.min(liquidRequired * stackSize - progress, totalCharge);
totalCharge -= chargeDrained; totalCharge -= chargeDrained;
@ -300,8 +280,7 @@ public class BloodAltar implements IFluidHandler
hasOperated = true; hasOperated = true;
} }
if (fluid != null && fluid.amount >= 1) if (fluid != null && fluid.amount >= 1) {
{
int liquidDrained = Math.min((int) (altarTier.ordinal() >= 2 ? consumptionRate * (1 + consumptionMultiplier) : consumptionRate), fluid.amount); int liquidDrained = Math.min((int) (altarTier.ordinal() >= 2 ? consumptionRate * (1 + consumptionMultiplier) : consumptionRate), fluid.amount);
if (liquidDrained > (liquidRequired * stackSize - progress)) if (liquidDrained > (liquidRequired * stackSize - progress))
@ -312,27 +291,22 @@ public class BloodAltar implements IFluidHandler
hasOperated = true; hasOperated = true;
if (internalCounter % 4 == 0 && world instanceof WorldServer) if (internalCounter % 4 == 0 && world instanceof WorldServer) {
{
WorldServer server = (WorldServer) world; WorldServer server = (WorldServer) world;
server.spawnParticle(EnumParticleTypes.REDSTONE, pos.getX() + 0.5, pos.getY() + 1, pos.getZ() + 0.5, 1, 0.2, 0, 0.2, 0); server.spawnParticle(EnumParticleTypes.REDSTONE, pos.getX() + 0.5, pos.getY() + 1, pos.getZ() + 0.5, 1, 0.2, 0, 0.2, 0);
} }
} else if (!hasOperated && progress > 0) } else if (!hasOperated && progress > 0) {
{
progress -= (int) (efficiencyMultiplier * drainRate); progress -= (int) (efficiencyMultiplier * drainRate);
if (internalCounter % 2 == 0 && world instanceof WorldServer) if (internalCounter % 2 == 0 && world instanceof WorldServer) {
{
WorldServer server = (WorldServer) world; WorldServer server = (WorldServer) world;
server.spawnParticle(EnumParticleTypes.SMOKE_NORMAL, pos.getX() + 0.5, pos.getY() + 1, pos.getZ() + 0.5, 1, 0.1, 0, 0.1, 0); server.spawnParticle(EnumParticleTypes.SMOKE_NORMAL, pos.getX() + 0.5, pos.getY() + 1, pos.getZ() + 0.5, 1, 0.1, 0, 0.1, 0);
} }
} }
if (hasOperated) if (hasOperated) {
{ if (progress >= liquidRequired * stackSize) {
if (progress >= liquidRequired * stackSize)
{
ItemStack result = ItemHandlerHelper.copyStackWithSize(recipe.getOutput(), stackSize); ItemStack result = ItemHandlerHelper.copyStackWithSize(recipe.getOutput(), stackSize);
BloodMagicCraftedEvent.Altar event = new BloodMagicCraftedEvent.Altar(result, input.copy()); BloodMagicCraftedEvent.Altar event = new BloodMagicCraftedEvent.Altar(result, input.copy());
@ -340,8 +314,7 @@ public class BloodAltar implements IFluidHandler
tileAltar.setInventorySlotContents(0, event.getOutput()); tileAltar.setInventorySlotContents(0, event.getOutput());
progress = 0; progress = 0;
if (world instanceof WorldServer) if (world instanceof WorldServer) {
{
WorldServer server = (WorldServer) world; WorldServer server = (WorldServer) world;
server.spawnParticle(EnumParticleTypes.REDSTONE, pos.getX() + 0.5, pos.getY() + 1, pos.getZ() + 0.5, 40, 0.3, 0, 0.3, 0); server.spawnParticle(EnumParticleTypes.REDSTONE, pos.getX() + 0.5, pos.getY() + 1, pos.getZ() + 0.5, 40, 0.3, 0, 0.3, 0);
} }
@ -350,8 +323,7 @@ public class BloodAltar implements IFluidHandler
this.isActive = false; this.isActive = false;
} }
} }
} else } else {
{
ItemStack contained = tileAltar.getStackInSlot(0); ItemStack contained = tileAltar.getStackInSlot(0);
if (contained.isEmpty() || !(contained.getItem() instanceof IBloodOrb) || !(contained.getItem() instanceof IBindable)) if (contained.isEmpty() || !(contained.getItem() instanceof IBloodOrb) || !(contained.getItem() instanceof IBindable))
@ -363,14 +335,12 @@ public class BloodAltar implements IFluidHandler
if (binding == null || orb == null) if (binding == null || orb == null)
return; return;
if (fluid != null && fluid.amount >= 1) if (fluid != null && fluid.amount >= 1) {
{
int liquidDrained = Math.min((int) (altarTier.ordinal() >= 2 ? orb.getFillRate() * (1 + consumptionMultiplier) : orb.getFillRate()), fluid.amount); int liquidDrained = Math.min((int) (altarTier.ordinal() >= 2 ? orb.getFillRate() * (1 + consumptionMultiplier) : orb.getFillRate()), fluid.amount);
int drain = NetworkHelper.getSoulNetwork(binding).add(SoulTicket.block(world, pos, liquidDrained), (int) (orb.getCapacity() * this.orbCapacityMultiplier)); int drain = NetworkHelper.getSoulNetwork(binding).add(SoulTicket.block(world, pos, liquidDrained), (int) (orb.getCapacity() * this.orbCapacityMultiplier));
fluid.amount = fluid.amount - drain; fluid.amount = fluid.amount - drain;
if (drain > 0 && internalCounter % 4 == 0 && world instanceof WorldServer) if (drain > 0 && internalCounter % 4 == 0 && world instanceof WorldServer) {
{
WorldServer server = (WorldServer) world; WorldServer server = (WorldServer) world;
server.spawnParticle(EnumParticleTypes.SPELL_WITCH, pos.getX() + 0.5, pos.getY() + 1, pos.getZ() + 0.5, 1, 0, 0, 0, 0.001); server.spawnParticle(EnumParticleTypes.SPELL_WITCH, pos.getX() + 0.5, pos.getY() + 1, pos.getZ() + 0.5, 1, 0, 0, 0, 0.001);
} }
@ -380,8 +350,7 @@ public class BloodAltar implements IFluidHandler
tileAltar.getWorld().notifyBlockUpdate(tileAltar.getPos(), tileAltar.getWorld().getBlockState(tileAltar.getPos()), tileAltar.getWorld().getBlockState(tileAltar.getPos()), 3); tileAltar.getWorld().notifyBlockUpdate(tileAltar.getPos(), tileAltar.getWorld().getBlockState(tileAltar.getPos()), tileAltar.getWorld().getBlockState(tileAltar.getPos()), 3);
} }
public void checkTier() public void checkTier() {
{
AltarTier tier = AltarUtil.getTier(tileAltar.getWorld(), tileAltar.getPos()); AltarTier tier = AltarUtil.getTier(tileAltar.getWorld(), tileAltar.getPos());
this.altarTier = tier; this.altarTier = tier;
@ -390,8 +359,7 @@ public class BloodAltar implements IFluidHandler
if (tier.equals(currentTierDisplayed)) if (tier.equals(currentTierDisplayed))
currentTierDisplayed = AltarTier.ONE; currentTierDisplayed = AltarTier.ONE;
if (tier.equals(AltarTier.ONE)) if (tier.equals(AltarTier.ONE)) {
{
upgrade = null; upgrade = null;
isUpgraded = false; isUpgraded = false;
this.consumptionMultiplier = 0; this.consumptionMultiplier = 0;
@ -407,8 +375,7 @@ public class BloodAltar implements IFluidHandler
this.maxCharge = 0; this.maxCharge = 0;
this.totalCharge = 0; this.totalCharge = 0;
return; return;
} else if (!tier.equals(AltarTier.ONE)) } else if (!tier.equals(AltarTier.ONE)) {
{
this.isUpgraded = true; this.isUpgraded = true;
this.accelerationUpgrades = upgrade.getLevel(BloodRuneType.ACCELERATION); this.accelerationUpgrades = upgrade.getLevel(BloodRuneType.ACCELERATION);
this.consumptionMultiplier = (float) (0.20 * upgrade.getLevel(BloodRuneType.SPEED)); this.consumptionMultiplier = (float) (0.20 * upgrade.getLevel(BloodRuneType.SPEED));
@ -438,128 +405,103 @@ public class BloodAltar implements IFluidHandler
tileAltar.getWorld().notifyBlockUpdate(tileAltar.getPos(), tileAltar.getWorld().getBlockState(tileAltar.getPos()), tileAltar.getWorld().getBlockState(tileAltar.getPos()), 3); tileAltar.getWorld().notifyBlockUpdate(tileAltar.getPos(), tileAltar.getWorld().getBlockState(tileAltar.getPos()), tileAltar.getWorld().getBlockState(tileAltar.getPos()), 3);
} }
public int fillMainTank(int amount) public int fillMainTank(int amount) {
{
int filledAmount = Math.min(capacity - fluid.amount, amount); int filledAmount = Math.min(capacity - fluid.amount, amount);
fluid.amount += filledAmount; fluid.amount += filledAmount;
return filledAmount; return filledAmount;
} }
public void sacrificialDaggerCall(int amount, boolean isSacrifice) public void sacrificialDaggerCall(int amount, boolean isSacrifice) {
{ if (this.lockdownDuration > 0) {
if (this.lockdownDuration > 0)
{
int amt = (int) Math.min(bufferCapacity - fluidInput.amount, (isSacrifice ? 1 + sacrificeEfficiencyMultiplier : 1 + selfSacrificeEfficiencyMultiplier) * amount); int amt = (int) Math.min(bufferCapacity - fluidInput.amount, (isSacrifice ? 1 + sacrificeEfficiencyMultiplier : 1 + selfSacrificeEfficiencyMultiplier) * amount);
fluidInput.amount += amt; fluidInput.amount += amt;
} else } else {
{
fluid.amount += Math.min(capacity - fluid.amount, (isSacrifice ? 1 + sacrificeEfficiencyMultiplier : 1 + selfSacrificeEfficiencyMultiplier) * amount); fluid.amount += Math.min(capacity - fluid.amount, (isSacrifice ? 1 + sacrificeEfficiencyMultiplier : 1 + selfSacrificeEfficiencyMultiplier) * amount);
} }
} }
public void setMainFluid(FluidStack fluid) public void setMainFluid(FluidStack fluid) {
{
this.fluid = fluid; this.fluid = fluid;
} }
public void setOutputFluid(FluidStack fluid) public void setOutputFluid(FluidStack fluid) {
{
this.fluidOutput = fluid; this.fluidOutput = fluid;
} }
public void setInputFluid(FluidStack fluid) public void setInputFluid(FluidStack fluid) {
{
this.fluidInput = fluid; this.fluidInput = fluid;
} }
public AltarUpgrade getUpgrade() public AltarUpgrade getUpgrade() {
{
return upgrade; return upgrade;
} }
public void setUpgrade(AltarUpgrade upgrade) public void setUpgrade(AltarUpgrade upgrade) {
{
this.upgrade = upgrade; this.upgrade = upgrade;
} }
public int getCapacity() public int getCapacity() {
{
return capacity; return capacity;
} }
public FluidStack getFluid() public FluidStack getFluid() {
{
return fluid; return fluid;
} }
public int getFluidAmount() public int getFluidAmount() {
{
return fluid.amount; return fluid.amount;
} }
public int getCurrentBlood() public int getCurrentBlood() {
{
return getFluidAmount(); return getFluidAmount();
} }
public AltarTier getTier() public AltarTier getTier() {
{
return altarTier; return altarTier;
} }
public void setTier(AltarTier tier) public void setTier(AltarTier tier) {
{
this.altarTier = tier; this.altarTier = tier;
} }
public int getProgress() public int getProgress() {
{
return progress; return progress;
} }
public float getSacrificeMultiplier() public float getSacrificeMultiplier() {
{
return sacrificeEfficiencyMultiplier; return sacrificeEfficiencyMultiplier;
} }
public float getSelfSacrificeMultiplier() public float getSelfSacrificeMultiplier() {
{
return selfSacrificeEfficiencyMultiplier; return selfSacrificeEfficiencyMultiplier;
} }
public float getOrbMultiplier() public float getOrbMultiplier() {
{
return orbCapacityMultiplier; return orbCapacityMultiplier;
} }
public float getDislocationMultiplier() public float getDislocationMultiplier() {
{
return dislocationMultiplier; return dislocationMultiplier;
} }
public float getConsumptionMultiplier() public float getConsumptionMultiplier() {
{
return consumptionMultiplier; return consumptionMultiplier;
} }
public float getConsumptionRate() public float getConsumptionRate() {
{
return consumptionRate; return consumptionRate;
} }
public int getLiquidRequired() public int getLiquidRequired() {
{
return liquidRequired; return liquidRequired;
} }
public int getBufferCapacity() public int getBufferCapacity() {
{
return bufferCapacity; return bufferCapacity;
} }
public boolean setCurrentTierDisplayed(AltarTier altarTier) public boolean setCurrentTierDisplayed(AltarTier altarTier) {
{
if (currentTierDisplayed == altarTier) if (currentTierDisplayed == altarTier)
return false; return false;
else else
@ -567,99 +509,79 @@ public class BloodAltar implements IFluidHandler
return true; return true;
} }
public void addToDemonBloodDuration(int dur) public void addToDemonBloodDuration(int dur) {
{
this.demonBloodDuration += dur; this.demonBloodDuration += dur;
} }
public boolean hasDemonBlood() public boolean hasDemonBlood() {
{
return this.demonBloodDuration > 0; return this.demonBloodDuration > 0;
} }
public void decrementDemonBlood() public void decrementDemonBlood() {
{
this.demonBloodDuration = Math.max(0, this.demonBloodDuration - 1); this.demonBloodDuration = Math.max(0, this.demonBloodDuration - 1);
} }
public void setActive() public void setActive() {
{ if (tileAltar.getStackInSlot(0).isEmpty()) {
if (tileAltar.getStackInSlot(0).isEmpty())
{
isActive = false; isActive = false;
} }
} }
public boolean isActive() public boolean isActive() {
{
return isActive; return isActive;
} }
public void requestPauseAfterCrafting(int amount) public void requestPauseAfterCrafting(int amount) {
{ if (this.isActive) {
if (this.isActive)
{
this.cooldownAfterCrafting = amount; this.cooldownAfterCrafting = amount;
} }
} }
public int getChargingRate() public int getChargingRate() {
{
return chargingRate; return chargingRate;
} }
public int getTotalCharge() public int getTotalCharge() {
{
return totalCharge; return totalCharge;
} }
public int getChargingFrequency() public int getChargingFrequency() {
{
return chargingFrequency == 0 ? 1 : chargingFrequency; return chargingFrequency == 0 ? 1 : chargingFrequency;
} }
@Override @Override
public int fill(FluidStack resource, boolean doFill) public int fill(FluidStack resource, boolean doFill) {
{ if (resource == null || resource.getFluid() != BlockLifeEssence.getLifeEssence()) {
if (resource == null || resource.getFluid() != BlockLifeEssence.getLifeEssence())
{
return 0; return 0;
} }
if (!doFill) if (!doFill) {
{ if (fluidInput == null) {
if (fluidInput == null)
{
return Math.min(bufferCapacity, resource.amount); return Math.min(bufferCapacity, resource.amount);
} }
if (!fluidInput.isFluidEqual(resource)) if (!fluidInput.isFluidEqual(resource)) {
{
return 0; return 0;
} }
return Math.min(bufferCapacity - fluidInput.amount, resource.amount); return Math.min(bufferCapacity - fluidInput.amount, resource.amount);
} }
if (fluidInput == null) if (fluidInput == null) {
{
fluidInput = new FluidStack(resource, Math.min(bufferCapacity, resource.amount)); fluidInput = new FluidStack(resource, Math.min(bufferCapacity, resource.amount));
return fluidInput.amount; return fluidInput.amount;
} }
if (!fluidInput.isFluidEqual(resource)) if (!fluidInput.isFluidEqual(resource)) {
{
return 0; return 0;
} }
int filled = bufferCapacity - fluidInput.amount; int filled = bufferCapacity - fluidInput.amount;
if (resource.amount < filled) if (resource.amount < filled) {
{
fluidInput.amount += resource.amount; fluidInput.amount += resource.amount;
filled = resource.amount; filled = resource.amount;
} else } else {
{
fluidInput.amount = bufferCapacity; fluidInput.amount = bufferCapacity;
} }
@ -667,45 +589,37 @@ public class BloodAltar implements IFluidHandler
} }
@Override @Override
public FluidStack drain(FluidStack resource, boolean doDrain) public FluidStack drain(FluidStack resource, boolean doDrain) {
{ if (resource == null || !resource.isFluidEqual(fluidOutput)) {
if (resource == null || !resource.isFluidEqual(fluidOutput))
{
return null; return null;
} }
return drain(resource.amount, doDrain); return drain(resource.amount, doDrain);
} }
@Override @Override
public FluidStack drain(int maxDrain, boolean doDrain) public FluidStack drain(int maxDrain, boolean doDrain) {
{ if (fluidOutput == null) {
if (fluidOutput == null)
{
return null; return null;
} }
int drained = maxDrain; int drained = maxDrain;
if (fluidOutput.amount < drained) if (fluidOutput.amount < drained) {
{
drained = fluidOutput.amount; drained = fluidOutput.amount;
} }
FluidStack stack = new FluidStack(fluidOutput, drained); FluidStack stack = new FluidStack(fluidOutput, drained);
if (doDrain) if (doDrain) {
{
fluidOutput.amount -= drained; fluidOutput.amount -= drained;
} }
return stack; return stack;
} }
@Override @Override
public IFluidTankProperties[] getTankProperties() public IFluidTankProperties[] getTankProperties() {
{ return new IFluidTankProperties[]{new FluidTankPropertiesWrapper(new FluidTank(fluid, capacity))};
return new IFluidTankProperties[] { new FluidTankPropertiesWrapper(new FluidTank(fluid, capacity)) };
} }
public AltarTier getCurrentTierDisplayed() public AltarTier getCurrentTierDisplayed() {
{
return currentTierDisplayed; return currentTierDisplayed;
} }
} }

33
src/main/java/WayofTime/bloodmagic/api/impl/BloodMagicCorePlugin.java
View file

@ -23,12 +23,10 @@ import net.minecraftforge.fml.common.registry.EntityEntry;
import net.minecraftforge.fml.common.registry.ForgeRegistries; import net.minecraftforge.fml.common.registry.ForgeRegistries;
@BloodMagicPlugin @BloodMagicPlugin
public class BloodMagicCorePlugin implements IBloodMagicPlugin public class BloodMagicCorePlugin implements IBloodMagicPlugin {
{
@Override @Override
public void register(IBloodMagicAPI apiInterface) public void register(IBloodMagicAPI apiInterface) {
{
BloodMagicAPI api = (BloodMagicAPI) apiInterface; BloodMagicAPI api = (BloodMagicAPI) apiInterface;
// Add forced blacklistings // Add forced blacklistings
api.getBlacklist().addTeleposer(RegistrarBloodMagicBlocks.INPUT_ROUTING_NODE); api.getBlacklist().addTeleposer(RegistrarBloodMagicBlocks.INPUT_ROUTING_NODE);
@ -84,8 +82,7 @@ public class BloodMagicCorePlugin implements IBloodMagicPlugin
} }
@Override @Override
public void registerRecipes(IBloodMagicRecipeRegistrar recipeRegistrar) public void registerRecipes(IBloodMagicRecipeRegistrar recipeRegistrar) {
{
RegistrarBloodMagicRecipes.registerAltarRecipes((BloodMagicRecipeRegistrar) recipeRegistrar); RegistrarBloodMagicRecipes.registerAltarRecipes((BloodMagicRecipeRegistrar) recipeRegistrar);
RegistrarBloodMagicRecipes.registerAlchemyTableRecipes((BloodMagicRecipeRegistrar) recipeRegistrar); RegistrarBloodMagicRecipes.registerAlchemyTableRecipes((BloodMagicRecipeRegistrar) recipeRegistrar);
RegistrarBloodMagicRecipes.registerTartaricForgeRecipes((BloodMagicRecipeRegistrar) recipeRegistrar); RegistrarBloodMagicRecipes.registerTartaricForgeRecipes((BloodMagicRecipeRegistrar) recipeRegistrar);
@ -93,10 +90,8 @@ public class BloodMagicCorePlugin implements IBloodMagicPlugin
RegistrarBloodMagicRecipes.registerSacrificeCraftRecipes((BloodMagicRecipeRegistrar) recipeRegistrar); RegistrarBloodMagicRecipes.registerSacrificeCraftRecipes((BloodMagicRecipeRegistrar) recipeRegistrar);
} }
private static void handleConfigValues(BloodMagicAPI api) private static void handleConfigValues(BloodMagicAPI api) {
{ for (String value : ConfigHandler.values.sacrificialValues) {
for (String value : ConfigHandler.values.sacrificialValues)
{
String[] split = value.split(";"); String[] split = value.split(";");
if (split.length != 2) // Not valid format if (split.length != 2) // Not valid format
continue; continue;
@ -104,18 +99,15 @@ public class BloodMagicCorePlugin implements IBloodMagicPlugin
api.getValueManager().setSacrificialValue(new ResourceLocation(split[0]), Integer.parseInt(split[1])); api.getValueManager().setSacrificialValue(new ResourceLocation(split[0]), Integer.parseInt(split[1]));
} }
for (String value : ConfigHandler.blacklist.teleposer) for (String value : ConfigHandler.blacklist.teleposer) {
{
EntityEntry entityEntry = ForgeRegistries.ENTITIES.getValue(new ResourceLocation(value)); EntityEntry entityEntry = ForgeRegistries.ENTITIES.getValue(new ResourceLocation(value));
if (entityEntry == null) if (entityEntry == null) { // It's not an entity (or at least not a valid one), so let's try a block.
{ // It's not an entity (or at least not a valid one), so let's try a block.
String[] blockData = value.split("\\["); String[] blockData = value.split("\\[");
Block block = ForgeRegistries.BLOCKS.getValue(new ResourceLocation(blockData[0])); Block block = ForgeRegistries.BLOCKS.getValue(new ResourceLocation(blockData[0]));
if (block == Blocks.AIR || block == null) // Not a valid block either if (block == Blocks.AIR || block == null) // Not a valid block either
continue; continue;
if (blockData.length > 1) if (blockData.length > 1) { // We have properties listed, so let's build a state.
{ // We have properties listed, so let's build a state.
api.getBlacklist().addTeleposer(StateUtil.parseState(value)); api.getBlacklist().addTeleposer(StateUtil.parseState(value));
continue; continue;
} }
@ -127,15 +119,13 @@ public class BloodMagicCorePlugin implements IBloodMagicPlugin
api.getBlacklist().addTeleposer(entityEntry.getRegistryName()); api.getBlacklist().addTeleposer(entityEntry.getRegistryName());
} }
for (String value : ConfigHandler.blacklist.transposer) for (String value : ConfigHandler.blacklist.transposer) {
{
String[] blockData = value.split("\\["); String[] blockData = value.split("\\[");
Block block = ForgeRegistries.BLOCKS.getValue(new ResourceLocation(blockData[0])); Block block = ForgeRegistries.BLOCKS.getValue(new ResourceLocation(blockData[0]));
if (block == Blocks.AIR || block == null) // Not a valid block if (block == Blocks.AIR || block == null) // Not a valid block
continue; continue;
if (blockData.length > 1) if (blockData.length > 1) { // We have properties listed, so let's build a state.
{ // We have properties listed, so let's build a state.
api.getBlacklist().addTeleposer(StateUtil.parseState(value)); api.getBlacklist().addTeleposer(StateUtil.parseState(value));
continue; continue;
} }
@ -143,8 +133,7 @@ public class BloodMagicCorePlugin implements IBloodMagicPlugin
api.getBlacklist().addTeleposer(block); api.getBlacklist().addTeleposer(block);
} }
for (String value : ConfigHandler.blacklist.wellOfSuffering) for (String value : ConfigHandler.blacklist.wellOfSuffering) {
{
EntityEntry entityEntry = ForgeRegistries.ENTITIES.getValue(new ResourceLocation(value)); EntityEntry entityEntry = ForgeRegistries.ENTITIES.getValue(new ResourceLocation(value));
if (entityEntry == null) // Not a valid entity if (entityEntry == null) // Not a valid entity
continue; continue;

135
src/main/java/WayofTime/bloodmagic/api/impl/BloodMagicRecipeRegistrar.java
View file

@ -27,8 +27,7 @@ import com.google.common.collect.ImmutableSet;
import com.google.common.collect.Lists; import com.google.common.collect.Lists;
import com.google.common.collect.Sets; import com.google.common.collect.Sets;
public class BloodMagicRecipeRegistrar implements IBloodMagicRecipeRegistrar public class BloodMagicRecipeRegistrar implements IBloodMagicRecipeRegistrar {
{
private final Set<RecipeBloodAltar> altarRecipes; private final Set<RecipeBloodAltar> altarRecipes;
private final Set<RecipeAlchemyTable> alchemyRecipes; private final Set<RecipeAlchemyTable> alchemyRecipes;
@ -36,8 +35,7 @@ public class BloodMagicRecipeRegistrar implements IBloodMagicRecipeRegistrar
private final Set<RecipeAlchemyArray> alchemyArrayRecipes; private final Set<RecipeAlchemyArray> alchemyArrayRecipes;
private final Set<RecipeSacrificeCraft> sacrificeCraftRecipes; private final Set<RecipeSacrificeCraft> sacrificeCraftRecipes;
public BloodMagicRecipeRegistrar() public BloodMagicRecipeRegistrar() {
{
this.altarRecipes = Sets.newHashSet(); this.altarRecipes = Sets.newHashSet();
this.alchemyRecipes = Sets.newHashSet(); this.alchemyRecipes = Sets.newHashSet();
this.tartaricForgeRecipes = Sets.newHashSet(); this.tartaricForgeRecipes = Sets.newHashSet();
@ -46,8 +44,7 @@ public class BloodMagicRecipeRegistrar implements IBloodMagicRecipeRegistrar
} }
@Override @Override
public void addBloodAltar(@Nonnull Ingredient input, @Nonnull ItemStack output, @Nonnegative int minimumTier, @Nonnegative int syphon, @Nonnegative int consumeRate, @Nonnegative int drainRate) public void addBloodAltar(@Nonnull Ingredient input, @Nonnull ItemStack output, @Nonnegative int minimumTier, @Nonnegative int syphon, @Nonnegative int consumeRate, @Nonnegative int drainRate) {
{
Preconditions.checkNotNull(input, "input cannot be null."); Preconditions.checkNotNull(input, "input cannot be null.");
Preconditions.checkNotNull(output, "output cannot be null."); Preconditions.checkNotNull(output, "output cannot be null.");
Preconditions.checkArgument(minimumTier >= 0, "minimumTier cannot be negative."); Preconditions.checkArgument(minimumTier >= 0, "minimumTier cannot be negative.");
@ -59,16 +56,14 @@ public class BloodMagicRecipeRegistrar implements IBloodMagicRecipeRegistrar
} }
@Override @Override
public boolean removeBloodAltar(@Nonnull ItemStack input) public boolean removeBloodAltar(@Nonnull ItemStack input) {
{
Preconditions.checkNotNull(input, "input cannot be null."); Preconditions.checkNotNull(input, "input cannot be null.");
return altarRecipes.remove(getBloodAltar(input)); return altarRecipes.remove(getBloodAltar(input));
} }
@Override @Override
public void addAlchemyTable(@Nonnull ItemStack output, @Nonnegative int syphon, @Nonnegative int ticks, @Nonnegative int minimumTier, @Nonnull Ingredient... input) public void addAlchemyTable(@Nonnull ItemStack output, @Nonnegative int syphon, @Nonnegative int ticks, @Nonnegative int minimumTier, @Nonnull Ingredient... input) {
{
Preconditions.checkNotNull(output, "output cannot be null."); Preconditions.checkNotNull(output, "output cannot be null.");
Preconditions.checkArgument(syphon >= 0, "syphon cannot be negative."); Preconditions.checkArgument(syphon >= 0, "syphon cannot be negative.");
Preconditions.checkArgument(ticks >= 0, "ticks cannot be negative."); Preconditions.checkArgument(ticks >= 0, "ticks cannot be negative.");
@ -79,8 +74,7 @@ public class BloodMagicRecipeRegistrar implements IBloodMagicRecipeRegistrar
alchemyRecipes.add(new RecipeAlchemyTable(inputs, output, syphon, ticks, minimumTier)); alchemyRecipes.add(new RecipeAlchemyTable(inputs, output, syphon, ticks, minimumTier));
} }
public void addAlchemyTable(@Nonnull ItemStack output, @Nonnegative int syphon, @Nonnegative int ticks, @Nonnegative int minimumTier, @Nonnull Object... input) public void addAlchemyTable(@Nonnull ItemStack output, @Nonnegative int syphon, @Nonnegative int ticks, @Nonnegative int minimumTier, @Nonnull Object... input) {
{
Preconditions.checkNotNull(output, "output cannot be null."); Preconditions.checkNotNull(output, "output cannot be null.");
Preconditions.checkArgument(syphon >= 0, "syphon cannot be negative."); Preconditions.checkArgument(syphon >= 0, "syphon cannot be negative.");
Preconditions.checkArgument(ticks >= 0, "ticks cannot be negative."); Preconditions.checkArgument(ticks >= 0, "ticks cannot be negative.");
@ -88,10 +82,8 @@ public class BloodMagicRecipeRegistrar implements IBloodMagicRecipeRegistrar
Preconditions.checkNotNull(input, "input cannot be null."); Preconditions.checkNotNull(input, "input cannot be null.");
List<Ingredient> ingredients = Lists.newArrayList(); List<Ingredient> ingredients = Lists.newArrayList();
for (Object object : input) for (Object object : input) {
{ if (object instanceof ItemStack && ((ItemStack) object).getItem() instanceof IBloodOrb) {
if (object instanceof ItemStack && ((ItemStack) object).getItem() instanceof IBloodOrb)
{
ingredients.add(new IngredientBloodOrb(((IBloodOrb) ((ItemStack) object).getItem()).getOrb((ItemStack) object))); ingredients.add(new IngredientBloodOrb(((IBloodOrb) ((ItemStack) object).getItem()).getOrb((ItemStack) object)));
continue; continue;
} }
@ -102,14 +94,12 @@ public class BloodMagicRecipeRegistrar implements IBloodMagicRecipeRegistrar
addAlchemyTable(output, syphon, ticks, minimumTier, ingredients.toArray(new Ingredient[0])); addAlchemyTable(output, syphon, ticks, minimumTier, ingredients.toArray(new Ingredient[0]));
} }
public void addAlchemyTable(RecipeAlchemyTable recipe) public void addAlchemyTable(RecipeAlchemyTable recipe) {
{
alchemyRecipes.add(recipe); alchemyRecipes.add(recipe);
} }
@Override @Override
public boolean removeAlchemyTable(@Nonnull ItemStack... input) public boolean removeAlchemyTable(@Nonnull ItemStack... input) {
{
Preconditions.checkNotNull(input, "inputs cannot be null."); Preconditions.checkNotNull(input, "inputs cannot be null.");
for (ItemStack stack : input) for (ItemStack stack : input)
@ -119,8 +109,7 @@ public class BloodMagicRecipeRegistrar implements IBloodMagicRecipeRegistrar
} }
@Override @Override
public void addTartaricForge(@Nonnull ItemStack output, @Nonnegative double minimumSouls, @Nonnegative double soulDrain, @Nonnull Ingredient... input) public void addTartaricForge(@Nonnull ItemStack output, @Nonnegative double minimumSouls, @Nonnegative double soulDrain, @Nonnull Ingredient... input) {
{
Preconditions.checkNotNull(output, "output cannot be null."); Preconditions.checkNotNull(output, "output cannot be null.");
Preconditions.checkArgument(minimumSouls >= 0, "minimumSouls cannot be negative."); Preconditions.checkArgument(minimumSouls >= 0, "minimumSouls cannot be negative.");
Preconditions.checkArgument(soulDrain >= 0, "soulDrain cannot be negative."); Preconditions.checkArgument(soulDrain >= 0, "soulDrain cannot be negative.");
@ -131,8 +120,7 @@ public class BloodMagicRecipeRegistrar implements IBloodMagicRecipeRegistrar
} }
@Override @Override
public boolean removeTartaricForge(@Nonnull ItemStack... input) public boolean removeTartaricForge(@Nonnull ItemStack... input) {
{
Preconditions.checkNotNull(input, "inputs cannot be null."); Preconditions.checkNotNull(input, "inputs cannot be null.");
for (ItemStack stack : input) for (ItemStack stack : input)
@ -141,18 +129,15 @@ public class BloodMagicRecipeRegistrar implements IBloodMagicRecipeRegistrar
return tartaricForgeRecipes.remove(getTartaricForge(Lists.newArrayList(input))); return tartaricForgeRecipes.remove(getTartaricForge(Lists.newArrayList(input)));
} }
public void addTartaricForge(@Nonnull ItemStack output, @Nonnegative double minimumSouls, @Nonnegative double soulDrain, @Nonnull Object... input) public void addTartaricForge(@Nonnull ItemStack output, @Nonnegative double minimumSouls, @Nonnegative double soulDrain, @Nonnull Object... input) {
{
Preconditions.checkNotNull(output, "output cannot be null."); Preconditions.checkNotNull(output, "output cannot be null.");
Preconditions.checkArgument(minimumSouls >= 0, "minimumSouls cannot be negative."); Preconditions.checkArgument(minimumSouls >= 0, "minimumSouls cannot be negative.");
Preconditions.checkArgument(soulDrain >= 0, "soulDrain cannot be negative."); Preconditions.checkArgument(soulDrain >= 0, "soulDrain cannot be negative.");
Preconditions.checkNotNull(input, "input cannot be null."); Preconditions.checkNotNull(input, "input cannot be null.");
List<Ingredient> ingredients = Lists.newArrayList(); List<Ingredient> ingredients = Lists.newArrayList();
for (Object object : input) for (Object object : input) {
{ if (object instanceof ItemStack && ((ItemStack) object).getItem() instanceof IBloodOrb) {
if (object instanceof ItemStack && ((ItemStack) object).getItem() instanceof IBloodOrb)
{
ingredients.add(new IngredientBloodOrb(((IBloodOrb) ((ItemStack) object).getItem()).getOrb((ItemStack) object))); ingredients.add(new IngredientBloodOrb(((IBloodOrb) ((ItemStack) object).getItem()).getOrb((ItemStack) object)));
continue; continue;
} }
@ -164,8 +149,7 @@ public class BloodMagicRecipeRegistrar implements IBloodMagicRecipeRegistrar
} }
@Override @Override
public void addAlchemyArray(@Nonnull Ingredient input, @Nonnull Ingredient catalyst, @Nonnull ItemStack output, @Nullable ResourceLocation circleTexture) public void addAlchemyArray(@Nonnull Ingredient input, @Nonnull Ingredient catalyst, @Nonnull ItemStack output, @Nullable ResourceLocation circleTexture) {
{
Preconditions.checkNotNull(input, "input cannot be null."); Preconditions.checkNotNull(input, "input cannot be null.");
Preconditions.checkNotNull(catalyst, "catalyst cannot be null."); Preconditions.checkNotNull(catalyst, "catalyst cannot be null.");
Preconditions.checkNotNull(output, "output cannot be null."); Preconditions.checkNotNull(output, "output cannot be null.");
@ -174,16 +158,14 @@ public class BloodMagicRecipeRegistrar implements IBloodMagicRecipeRegistrar
} }
@Override @Override
public boolean removeAlchemyArray(@Nonnull ItemStack input, @Nonnull ItemStack catalyst) public boolean removeAlchemyArray(@Nonnull ItemStack input, @Nonnull ItemStack catalyst) {
{
Preconditions.checkNotNull(input, "input cannot be null."); Preconditions.checkNotNull(input, "input cannot be null.");
Preconditions.checkNotNull(catalyst, "catalyst cannot be null."); Preconditions.checkNotNull(catalyst, "catalyst cannot be null.");
return alchemyArrayRecipes.remove(getAlchemyArray(input, catalyst)); return alchemyArrayRecipes.remove(getAlchemyArray(input, catalyst));
} }
public void addAlchemyArray(@Nonnull ItemStack input, @Nonnull ItemStack catalyst, @Nonnull ItemStack output, @Nullable ResourceLocation circleTexture) public void addAlchemyArray(@Nonnull ItemStack input, @Nonnull ItemStack catalyst, @Nonnull ItemStack output, @Nullable ResourceLocation circleTexture) {
{
Preconditions.checkNotNull(input, "input cannot be null."); Preconditions.checkNotNull(input, "input cannot be null.");
Preconditions.checkNotNull(catalyst, "catalyst cannot be null."); Preconditions.checkNotNull(catalyst, "catalyst cannot be null.");
Preconditions.checkNotNull(output, "output cannot be null."); Preconditions.checkNotNull(output, "output cannot be null.");
@ -191,17 +173,14 @@ public class BloodMagicRecipeRegistrar implements IBloodMagicRecipeRegistrar
addAlchemyArray(Ingredient.fromStacks(input), Ingredient.fromStacks(catalyst), output, circleTexture); addAlchemyArray(Ingredient.fromStacks(input), Ingredient.fromStacks(catalyst), output, circleTexture);
} }
public void addSacrificeCraft(@Nonnull ItemStack output, @Nonnegative double healthRequired, @Nonnull Object... input) public void addSacrificeCraft(@Nonnull ItemStack output, @Nonnegative double healthRequired, @Nonnull Object... input) {
{
Preconditions.checkNotNull(output, "output cannot be null."); Preconditions.checkNotNull(output, "output cannot be null.");
Preconditions.checkArgument(healthRequired >= 0, "healthRequired cannot be negative."); Preconditions.checkArgument(healthRequired >= 0, "healthRequired cannot be negative.");
Preconditions.checkNotNull(input, "input cannot be null."); Preconditions.checkNotNull(input, "input cannot be null.");
List<Ingredient> ingredients = Lists.newArrayList(); List<Ingredient> ingredients = Lists.newArrayList();
for (Object object : input) for (Object object : input) {
{ if (object instanceof ItemStack && ((ItemStack) object).getItem() instanceof IBloodOrb) {
if (object instanceof ItemStack && ((ItemStack) object).getItem() instanceof IBloodOrb)
{
ingredients.add(new IngredientBloodOrb(((IBloodOrb) ((ItemStack) object).getItem()).getOrb((ItemStack) object))); ingredients.add(new IngredientBloodOrb(((IBloodOrb) ((ItemStack) object).getItem()).getOrb((ItemStack) object)));
continue; continue;
} }
@ -213,8 +192,7 @@ public class BloodMagicRecipeRegistrar implements IBloodMagicRecipeRegistrar
} }
@Override @Override
public boolean removeSacrificeCraft(@Nonnull ItemStack... input) public boolean removeSacrificeCraft(@Nonnull ItemStack... input) {
{
Preconditions.checkNotNull(input, "inputs cannot be null."); Preconditions.checkNotNull(input, "inputs cannot be null.");
for (ItemStack stack : input) for (ItemStack stack : input)
@ -224,8 +202,7 @@ public class BloodMagicRecipeRegistrar implements IBloodMagicRecipeRegistrar
} }
@Override @Override
public void addSacrificeCraft(@Nonnull ItemStack output, @Nonnegative double healthRequired, @Nonnull Ingredient... input) public void addSacrificeCraft(@Nonnull ItemStack output, @Nonnegative double healthRequired, @Nonnull Ingredient... input) {
{
Preconditions.checkNotNull(output, "output cannot be null."); Preconditions.checkNotNull(output, "output cannot be null.");
Preconditions.checkArgument(healthRequired >= 0, "healthRequired cannot be negative."); Preconditions.checkArgument(healthRequired >= 0, "healthRequired cannot be negative.");
Preconditions.checkNotNull(input, "input cannot be null."); Preconditions.checkNotNull(input, "input cannot be null.");
@ -235,8 +212,7 @@ public class BloodMagicRecipeRegistrar implements IBloodMagicRecipeRegistrar
} }
@Nullable @Nullable
public RecipeBloodAltar getBloodAltar(@Nonnull ItemStack input) public RecipeBloodAltar getBloodAltar(@Nonnull ItemStack input) {
{
Preconditions.checkNotNull(input, "input cannot be null."); Preconditions.checkNotNull(input, "input cannot be null.");
if (input.isEmpty()) if (input.isEmpty())
return null; return null;
@ -249,27 +225,23 @@ public class BloodMagicRecipeRegistrar implements IBloodMagicRecipeRegistrar
} }
@Nullable @Nullable
public RecipeAlchemyTable getAlchemyTable(@Nonnull List<ItemStack> input) public RecipeAlchemyTable getAlchemyTable(@Nonnull List<ItemStack> input) {
{
Preconditions.checkNotNull(input, "input cannot be null."); Preconditions.checkNotNull(input, "input cannot be null.");
if (input.isEmpty()) if (input.isEmpty())
return null; return null;
mainLoop: for (RecipeAlchemyTable recipe : alchemyRecipes) mainLoop:
{ for (RecipeAlchemyTable recipe : alchemyRecipes) {
if (recipe.getInput().size() != input.size()) if (recipe.getInput().size() != input.size())
continue; continue;
List<Ingredient> recipeInput = new ArrayList<>(recipe.getInput()); List<Ingredient> recipeInput = new ArrayList<>(recipe.getInput());
for (int i = 0; i < input.size(); i++) for (int i = 0; i < input.size(); i++) {
{
boolean matched = false; boolean matched = false;
for (int j = 0; j < recipeInput.size(); j++) for (int j = 0; j < recipeInput.size(); j++) {
{
Ingredient ingredient = recipeInput.get(j); Ingredient ingredient = recipeInput.get(j);
if (ingredient.apply(input.get(i))) if (ingredient.apply(input.get(i))) {
{
matched = true; matched = true;
recipeInput.remove(j); recipeInput.remove(j);
break; break;
@ -287,27 +259,23 @@ public class BloodMagicRecipeRegistrar implements IBloodMagicRecipeRegistrar
} }
@Nullable @Nullable
public RecipeTartaricForge getTartaricForge(@Nonnull List<ItemStack> input) public RecipeTartaricForge getTartaricForge(@Nonnull List<ItemStack> input) {
{
Preconditions.checkNotNull(input, "input cannot be null."); Preconditions.checkNotNull(input, "input cannot be null.");
if (input.isEmpty()) if (input.isEmpty())
return null; return null;
mainLoop: for (RecipeTartaricForge recipe : tartaricForgeRecipes) mainLoop:
{ for (RecipeTartaricForge recipe : tartaricForgeRecipes) {
if (recipe.getInput().size() != input.size()) if (recipe.getInput().size() != input.size())
continue; continue;
List<Ingredient> recipeInput = new ArrayList<>(recipe.getInput()); List<Ingredient> recipeInput = new ArrayList<>(recipe.getInput());
for (int i = 0; i < input.size(); i++) for (int i = 0; i < input.size(); i++) {
{
boolean matched = false; boolean matched = false;
for (int j = 0; j < recipeInput.size(); j++) for (int j = 0; j < recipeInput.size(); j++) {
{
Ingredient ingredient = recipeInput.get(j); Ingredient ingredient = recipeInput.get(j);
if (ingredient.apply(input.get(i))) if (ingredient.apply(input.get(i))) {
{
matched = true; matched = true;
recipeInput.remove(j); recipeInput.remove(j);
break; break;
@ -325,27 +293,23 @@ public class BloodMagicRecipeRegistrar implements IBloodMagicRecipeRegistrar
} }
@Nullable @Nullable
public RecipeSacrificeCraft getSacrificeCraft(@Nonnull List<ItemStack> input) public RecipeSacrificeCraft getSacrificeCraft(@Nonnull List<ItemStack> input) {
{
Preconditions.checkNotNull(input, "input cannot be null."); Preconditions.checkNotNull(input, "input cannot be null.");
if (input.isEmpty()) if (input.isEmpty())
return null; return null;
mainLoop: for (RecipeSacrificeCraft recipe : sacrificeCraftRecipes) mainLoop:
{ for (RecipeSacrificeCraft recipe : sacrificeCraftRecipes) {
if (recipe.getInput().size() != input.size()) if (recipe.getInput().size() != input.size())
continue; continue;
List<Ingredient> recipeInput = new ArrayList<>(recipe.getInput()); List<Ingredient> recipeInput = new ArrayList<>(recipe.getInput());
for (int i = 0; i < input.size(); i++) for (int i = 0; i < input.size(); i++) {
{
boolean matched = false; boolean matched = false;
for (int j = 0; j < recipeInput.size(); j++) for (int j = 0; j < recipeInput.size(); j++) {
{
Ingredient ingredient = recipeInput.get(j); Ingredient ingredient = recipeInput.get(j);
if (ingredient.apply(input.get(i))) if (ingredient.apply(input.get(i))) {
{
matched = true; matched = true;
recipeInput.remove(j); recipeInput.remove(j);
break; break;
@ -363,8 +327,7 @@ public class BloodMagicRecipeRegistrar implements IBloodMagicRecipeRegistrar
} }
@Nullable @Nullable
public RecipeAlchemyArray getAlchemyArray(@Nonnull ItemStack input, @Nonnull ItemStack catalyst) public RecipeAlchemyArray getAlchemyArray(@Nonnull ItemStack input, @Nonnull ItemStack catalyst) {
{
Preconditions.checkNotNull(input, "input cannot be null."); Preconditions.checkNotNull(input, "input cannot be null.");
if (input.isEmpty()) if (input.isEmpty())
return null; return null;
@ -376,23 +339,19 @@ public class BloodMagicRecipeRegistrar implements IBloodMagicRecipeRegistrar
return null; return null;
} }
public Set<RecipeBloodAltar> getAltarRecipes() public Set<RecipeBloodAltar> getAltarRecipes() {
{
return ImmutableSet.copyOf(altarRecipes); return ImmutableSet.copyOf(altarRecipes);
} }
public Set<RecipeAlchemyTable> getAlchemyRecipes() public Set<RecipeAlchemyTable> getAlchemyRecipes() {
{
return ImmutableSet.copyOf(alchemyRecipes); return ImmutableSet.copyOf(alchemyRecipes);
} }
public Set<RecipeTartaricForge> getTartaricForgeRecipes() public Set<RecipeTartaricForge> getTartaricForgeRecipes() {
{
return ImmutableSet.copyOf(tartaricForgeRecipes); return ImmutableSet.copyOf(tartaricForgeRecipes);
} }
public Set<RecipeAlchemyArray> getAlchemyArrayRecipes() public Set<RecipeAlchemyArray> getAlchemyArrayRecipes() {
{
return ImmutableSet.copyOf(alchemyArrayRecipes); return ImmutableSet.copyOf(alchemyArrayRecipes);
} }
} }

15
src/main/java/WayofTime/bloodmagic/api/impl/recipe/RecipeSacrificeCraft.java
View file

@ -8,8 +8,7 @@ import net.minecraft.util.NonNullList;
import javax.annotation.Nonnegative; import javax.annotation.Nonnegative;
import javax.annotation.Nonnull; import javax.annotation.Nonnull;
public class RecipeSacrificeCraft public class RecipeSacrificeCraft {
{
@Nonnull @Nonnull
private final NonNullList<Ingredient> input; private final NonNullList<Ingredient> input;
@Nonnull @Nonnull
@ -17,8 +16,7 @@ public class RecipeSacrificeCraft
@Nonnegative @Nonnegative
private final double healthRequired; private final double healthRequired;
public RecipeSacrificeCraft(@Nonnull NonNullList<Ingredient> input, @Nonnull ItemStack output, @Nonnegative double healthRequired) public RecipeSacrificeCraft(@Nonnull NonNullList<Ingredient> input, @Nonnull ItemStack output, @Nonnegative double healthRequired) {
{
Preconditions.checkNotNull(input, "input cannot be null."); Preconditions.checkNotNull(input, "input cannot be null.");
Preconditions.checkNotNull(output, "output cannot be null."); Preconditions.checkNotNull(output, "output cannot be null.");
Preconditions.checkArgument(healthRequired >= 0, "healthRequired cannot be negative."); Preconditions.checkArgument(healthRequired >= 0, "healthRequired cannot be negative.");
@ -29,20 +27,17 @@ public class RecipeSacrificeCraft
} }
@Nonnull @Nonnull
public final NonNullList<Ingredient> getInput() public final NonNullList<Ingredient> getInput() {
{
return input; return input;
} }
@Nonnull @Nonnull
public final ItemStack getOutput() public final ItemStack getOutput() {
{
return output; return output;
} }
@Nonnegative @Nonnegative
public final double getHealthRequired() public final double getHealthRequired() {
{
return healthRequired; return healthRequired;
} }
} }

2
src/main/java/WayofTime/bloodmagic/block/BlockDecorative.java
View file

@ -24,7 +24,7 @@ public class BlockDecorative extends BlockEnum<EnumDecorative> {
@Override @Override
public void getSubBlocks(CreativeTabs tab, NonNullList<ItemStack> subBlocks) { public void getSubBlocks(CreativeTabs tab, NonNullList<ItemStack> subBlocks) {
for (EnumDecorative type : EnumDecorative.values()){ for (EnumDecorative type : EnumDecorative.values()) {
if (!ConfigHandler.general.enableTierSixEvenThoughThereIsNoContent && (type == EnumDecorative.CRYSTAL_TILE || type == EnumDecorative.CRYSTAL_BRICK)) if (!ConfigHandler.general.enableTierSixEvenThoughThereIsNoContent && (type == EnumDecorative.CRYSTAL_TILE || type == EnumDecorative.CRYSTAL_BRICK))
continue; continue;
subBlocks.add(new ItemStack(this, 1, type.ordinal())); subBlocks.add(new ItemStack(this, 1, type.ordinal()));

2
src/main/java/WayofTime/bloodmagic/block/BlockMimic.java
View file

@ -219,7 +219,7 @@ public class BlockMimic extends BlockEnum<EnumMimic> implements IAltarComponent
} }
return null; return null;
} }
@Override @Override
public ItemBlock getItem() { public ItemBlock getItem() {
return new ItemBlockMimic(this); return new ItemBlockMimic(this);

3
src/main/java/WayofTime/bloodmagic/block/enums/EnumRitualController.java
View file

@ -7,7 +7,8 @@ import java.util.Locale;
public enum EnumRitualController implements IStringSerializable { public enum EnumRitualController implements IStringSerializable {
MASTER, MASTER,
IMPERFECT, IMPERFECT,
INVERTED,; INVERTED,
;
@Override @Override
public String toString() { public String toString() {

3
src/main/java/WayofTime/bloodmagic/client/hud/ElementRegistry.java
View file

@ -98,7 +98,8 @@ public class ElementRegistry {
return; return;
try (FileReader reader = new FileReader(CONFIG)) { try (FileReader reader = new FileReader(CONFIG)) {
Map<String, Vector2f> toLoad = GSON.fromJson(reader, new TypeToken<Map<String, Vector2f>>() {}.getType()); Map<String, Vector2f> toLoad = GSON.fromJson(reader, new TypeToken<Map<String, Vector2f>>() {
}.getType());
for (Map.Entry<String, Vector2f> entry : toLoad.entrySet()) { for (Map.Entry<String, Vector2f> entry : toLoad.entrySet()) {
ElementInfo info = ELEMENT_INFO.get(new ResourceLocation(entry.getKey())); ElementInfo info = ELEMENT_INFO.get(new ResourceLocation(entry.getKey()));
if (info != null) if (info != null)

4
src/main/java/WayofTime/bloodmagic/client/hud/GuiEditHUD.java
View file

@ -34,7 +34,9 @@ public class GuiEditHUD extends GuiScreen {
public void initGui() { public void initGui() {
super.initGui(); super.initGui();
addButton(new GuiButtonExt(0, width / 2 - 155, height - 30, 70, 20, I18n.format("gui.bloodmagic.toggle")){{enabled = false;}}); addButton(new GuiButtonExt(0, width / 2 - 155, height - 30, 70, 20, I18n.format("gui.bloodmagic.toggle")) {{
enabled = false;
}});
addButton(new GuiButtonExt(1, width / 2 - 75, height - 30, 70, 20, I18n.format("gui.bloodmagic.default"))); addButton(new GuiButtonExt(1, width / 2 - 75, height - 30, 70, 20, I18n.format("gui.bloodmagic.default")));
addButton(new GuiButtonExt(2, width / 2 + 5, height - 30, 70, 20, I18n.format("gui.bloodmagic.save"))); addButton(new GuiButtonExt(2, width / 2 + 5, height - 30, 70, 20, I18n.format("gui.bloodmagic.save")));
addButton(new GuiButtonExt(3, width / 2 + 90, height - 30, 70, 20, I18n.format("gui.bloodmagic.cancel"))); addButton(new GuiButtonExt(3, width / 2 + 90, height - 30, 70, 20, I18n.format("gui.bloodmagic.cancel")));

2
src/main/java/WayofTime/bloodmagic/client/hud/element/ElementDivinedInformation.java
View file

@ -55,7 +55,7 @@ public abstract class ElementDivinedInformation<T extends TileEntity> extends El
if (sigilStack.getItem() instanceof ItemSigilHolding) { if (sigilStack.getItem() instanceof ItemSigilHolding) {
List<ItemStack> internalInv = ItemSigilHolding.getInternalInventory(sigilStack); List<ItemStack> internalInv = ItemSigilHolding.getInternalInventory(sigilStack);
int currentSlot = ItemSigilHolding.getCurrentItemOrdinal(sigilStack); int currentSlot = ItemSigilHolding.getCurrentItemOrdinal(sigilStack);
if(internalInv != null && !internalInv.get(currentSlot).isEmpty()) { if (internalInv != null && !internalInv.get(currentSlot).isEmpty()) {
return (internalInv.get(currentSlot).getItem() == RegistrarBloodMagicItems.SIGIL_SEER && !simple) || (internalInv.get(currentSlot).getItem() == RegistrarBloodMagicItems.SIGIL_DIVINATION && simple); return (internalInv.get(currentSlot).getItem() == RegistrarBloodMagicItems.SIGIL_SEER && !simple) || (internalInv.get(currentSlot).getItem() == RegistrarBloodMagicItems.SIGIL_DIVINATION && simple);
} }
} }

3
src/main/java/WayofTime/bloodmagic/client/key/KeyBindings.java
View file

@ -46,7 +46,8 @@ public enum KeyBindings {
if (player.getHeldItemMainhand().getItem() instanceof ItemSigilHolding) if (player.getHeldItemMainhand().getItem() instanceof ItemSigilHolding)
ClientHandler.cycleSigil(player.getHeldItemMainhand(), player, 1); ClientHandler.cycleSigil(player.getHeldItemMainhand(), player, 1);
} }
},; },
;
// @formatter:on // @formatter:on
private final IKeyConflictContext keyConflictContext; private final IKeyConflictContext keyConflictContext;

12
src/main/java/WayofTime/bloodmagic/client/render/alchemyArray/LowAlchemyCircleRenderer.java
View file

@ -2,21 +2,17 @@ package WayofTime.bloodmagic.client.render.alchemyArray;
import net.minecraft.util.ResourceLocation; import net.minecraft.util.ResourceLocation;
public class LowAlchemyCircleRenderer extends SingleAlchemyCircleRenderer public class LowAlchemyCircleRenderer extends SingleAlchemyCircleRenderer {
{ public LowAlchemyCircleRenderer() {
public LowAlchemyCircleRenderer()
{
this(new ResourceLocation("bloodmagic", "textures/models/AlchemyArrays/SkeletonTurret1.png")); this(new ResourceLocation("bloodmagic", "textures/models/AlchemyArrays/SkeletonTurret1.png"));
} }
public LowAlchemyCircleRenderer(ResourceLocation arrayResource) public LowAlchemyCircleRenderer(ResourceLocation arrayResource) {
{
super(arrayResource); super(arrayResource);
} }
@Override @Override
public float getVerticalOffset(float craftTime) public float getVerticalOffset(float craftTime) {
{
return 0; return 0;
} }
} }

15
src/main/java/WayofTime/bloodmagic/client/render/alchemyArray/LowStaticAlchemyCircleRenderer.java
View file

@ -2,25 +2,20 @@ package WayofTime.bloodmagic.client.render.alchemyArray;
import net.minecraft.util.ResourceLocation; import net.minecraft.util.ResourceLocation;
public class LowStaticAlchemyCircleRenderer extends LowAlchemyCircleRenderer public class LowStaticAlchemyCircleRenderer extends LowAlchemyCircleRenderer {
{ public LowStaticAlchemyCircleRenderer() {
public LowStaticAlchemyCircleRenderer()
{
this(new ResourceLocation("bloodmagic", "textures/models/AlchemyArrays/SkeletonTurret1.png")); this(new ResourceLocation("bloodmagic", "textures/models/AlchemyArrays/SkeletonTurret1.png"));
} }
public LowStaticAlchemyCircleRenderer(ResourceLocation arrayResource) public LowStaticAlchemyCircleRenderer(ResourceLocation arrayResource) {
{
super(arrayResource); super(arrayResource);
} }
@Override @Override
public float getRotation(float craftTime) public float getRotation(float craftTime) {
{
float offset = 2; float offset = 2;
float duration = 180; float duration = 180;
if (craftTime >= offset && craftTime < offset + duration) if (craftTime >= offset && craftTime < offset + duration) {
{
float modifier = (craftTime - offset) * 2f; float modifier = (craftTime - offset) * 2f;
return modifier * 1f; return modifier * 1f;
} }

160
src/main/java/WayofTime/bloodmagic/client/render/alchemyArray/MobSacrificeAlchemyCircleRenderer.java
View file

@ -13,41 +13,33 @@ import net.minecraft.world.World;
import WayofTime.bloodmagic.alchemyArray.AlchemyCircleRenderer; import WayofTime.bloodmagic.alchemyArray.AlchemyCircleRenderer;
import WayofTime.bloodmagic.tile.TileAlchemyArray; import WayofTime.bloodmagic.tile.TileAlchemyArray;
public class MobSacrificeAlchemyCircleRenderer extends AlchemyCircleRenderer public class MobSacrificeAlchemyCircleRenderer extends AlchemyCircleRenderer {
{
private ResourceLocation bottomArrayResource = new ResourceLocation("bloodmagic", "textures/models/AlchemyArrays/MovementArray.png"); private ResourceLocation bottomArrayResource = new ResourceLocation("bloodmagic", "textures/models/AlchemyArrays/MovementArray.png");
private ResourceLocation mobSacrificeSwirlResource = new ResourceLocation("bloodmagic", "textures/models/mobsacrificeswirl.png"); private ResourceLocation mobSacrificeSwirlResource = new ResourceLocation("bloodmagic", "textures/models/mobsacrificeswirl.png");
public MobSacrificeAlchemyCircleRenderer(ResourceLocation location) public MobSacrificeAlchemyCircleRenderer(ResourceLocation location) {
{
super(location); super(location);
} }
public MobSacrificeAlchemyCircleRenderer() public MobSacrificeAlchemyCircleRenderer() {
{
this(new ResourceLocation("bloodmagic", "textures/models/AlchemyArrays/mobsacrifice.png")); this(new ResourceLocation("bloodmagic", "textures/models/AlchemyArrays/mobsacrifice.png"));
} }
@Override @Override
public float getSizeModifier(float craftTime) public float getSizeModifier(float craftTime) {
{ if (craftTime < 40) {
if (craftTime < 40)
{
return 0; return 0;
} else if (craftTime > 40 && craftTime < 100) } else if (craftTime > 40 && craftTime < 100) {
{
return (craftTime - 40) / 60f; return (craftTime - 40) / 60f;
} }
return 1; return 1;
} }
@Override @Override
public float getRotation(float craftTime) public float getRotation(float craftTime) {
{
float offset = 50; float offset = 50;
if (craftTime >= offset) if (craftTime >= offset) {
{
float modifier = (craftTime - offset) * 5f; float modifier = (craftTime - offset) * 5f;
return modifier * 1f; return modifier * 1f;
} }
@ -55,16 +47,13 @@ public class MobSacrificeAlchemyCircleRenderer extends AlchemyCircleRenderer
} }
@Override @Override
public float getSecondaryRotation(float craftTime) public float getSecondaryRotation(float craftTime) {
{
return 0; return 0;
} }
@Override @Override
public void renderAt(TileEntity tile, double x, double y, double z, float craftTime) public void renderAt(TileEntity tile, double x, double y, double z, float craftTime) {
{ if (!(tile instanceof TileAlchemyArray)) {
if (!(tile instanceof TileAlchemyArray))
{
return; return;
} }
@ -94,30 +83,29 @@ public class MobSacrificeAlchemyCircleRenderer extends AlchemyCircleRenderer
GlStateManager.translate(sideHit.getXOffset() * offsetFromFace, sideHit.getYOffset() * offsetFromFace, sideHit.getZOffset() * offsetFromFace); GlStateManager.translate(sideHit.getXOffset() * offsetFromFace, sideHit.getYOffset() * offsetFromFace, sideHit.getZOffset() * offsetFromFace);
switch (sideHit) switch (sideHit) {
{ case DOWN:
case DOWN: GlStateManager.translate(0, 0, 1);
GlStateManager.translate(0, 0, 1); GlStateManager.rotate(-90.0f, 1, 0, 0);
GlStateManager.rotate(-90.0f, 1, 0, 0); break;
break; case EAST:
case EAST: GlStateManager.rotate(-90.0f, 0, 1, 0);
GlStateManager.rotate(-90.0f, 0, 1, 0); GlStateManager.translate(0, 0, -1);
GlStateManager.translate(0, 0, -1); break;
break; case NORTH:
case NORTH: break;
break; case SOUTH:
case SOUTH: GlStateManager.rotate(180.0f, 0, 1, 0);
GlStateManager.rotate(180.0f, 0, 1, 0); GlStateManager.translate(-1, 0, -1);
GlStateManager.translate(-1, 0, -1); break;
break; case UP:
case UP: GlStateManager.translate(0, 1, 0);
GlStateManager.translate(0, 1, 0); GlStateManager.rotate(90.0f, 1, 0, 0);
GlStateManager.rotate(90.0f, 1, 0, 0); break;
break; case WEST:
case WEST: GlStateManager.translate(0, 0, 1);
GlStateManager.translate(0, 0, 1); GlStateManager.rotate(90.0f, 0, 1, 0);
GlStateManager.rotate(90.0f, 0, 1, 0); break;
break;
} }
GlStateManager.pushMatrix(); GlStateManager.pushMatrix();
@ -136,8 +124,7 @@ public class MobSacrificeAlchemyCircleRenderer extends AlchemyCircleRenderer
// GlStateManager.rotate((float) (yaw + 360 * getStartupPitchYawRatio(craftTime)), 0, 0, 1); // GlStateManager.rotate((float) (yaw + 360 * getStartupPitchYawRatio(craftTime)), 0, 0, 1);
// GlStateManager.rotate((float) ((pitch + 90) * getStartupPitchYawRatio(craftTime)), 1, 0, 0); // GlStateManager.rotate((float) ((pitch + 90) * getStartupPitchYawRatio(craftTime)), 1, 0, 0);
for (int i = 1; i <= 3; i++) for (int i = 1; i <= 3; i++) {
{
GlStateManager.pushMatrix(); GlStateManager.pushMatrix();
Minecraft.getMinecraft().renderEngine.bindTexture(bottomArrayResource); Minecraft.getMinecraft().renderEngine.bindTexture(bottomArrayResource);
translateAndRotateFloatingArray(tessellator, wr, size, rot, craftTime, i); translateAndRotateFloatingArray(tessellator, wr, size, rot, craftTime, i);
@ -153,11 +140,9 @@ public class MobSacrificeAlchemyCircleRenderer extends AlchemyCircleRenderer
//Render the swirlz //Render the swirlz
float swirlSize = 3; float swirlSize = 3;
if (craftTime <= 40) if (craftTime <= 40) {
{
swirlSize = 0; swirlSize = 0;
} else if (craftTime <= 100) } else if (craftTime <= 100) {
{
swirlSize = 3 * (craftTime - 40) / 60; swirlSize = 3 * (craftTime - 40) / 60;
} }
GlStateManager.pushMatrix(); GlStateManager.pushMatrix();
@ -180,66 +165,58 @@ public class MobSacrificeAlchemyCircleRenderer extends AlchemyCircleRenderer
GlStateManager.popMatrix(); GlStateManager.popMatrix();
} }
public float getStartupPitchYawRatio(float craftTime) public float getStartupPitchYawRatio(float craftTime) {
{ if (craftTime <= 80) {
if (craftTime <= 80)
{
return 0; return 0;
} else if (craftTime > 80 && craftTime < 140) } else if (craftTime > 80 && craftTime < 140) {
{
return (craftTime - 80) / 60f; return (craftTime - 80) / 60f;
} }
return 1; return 1;
} }
private void translateAndRotateFloatingArray(Tessellator tessellator, BufferBuilder builder, double size, float rotation, float craftTime, int circle) private void translateAndRotateFloatingArray(Tessellator tessellator, BufferBuilder builder, double size, float rotation, float craftTime, int circle) {
{
double verticalOffset = 2; double verticalOffset = 2;
float primaryRotation = 0; float primaryRotation = 0;
float secondaryRotation = 0; float secondaryRotation = 0;
if (craftTime >= 40) if (craftTime >= 40) {
{
primaryRotation = (craftTime - 40) * 4f; primaryRotation = (craftTime - 40) * 4f;
secondaryRotation = (craftTime - 40) * 2f; secondaryRotation = (craftTime - 40) * 2f;
} }
float translationOffset = 1; float translationOffset = 1;
if (craftTime < 80) if (craftTime < 80) {
{
translationOffset = 0; translationOffset = 0;
} else if (craftTime < 140) } else if (craftTime < 140) {
{
translationOffset = (craftTime - 80) / 60; translationOffset = (craftTime - 80) / 60;
} }
switch (circle) switch (circle) {
{ case 1:
case 1: GlStateManager.translate(0, 0, -verticalOffset);
GlStateManager.translate(0, 0, -verticalOffset); GlStateManager.rotate(rotation / 200, 1, 0, 0);
GlStateManager.rotate(rotation / 200, 1, 0, 0); GlStateManager.rotate(rotation / 10, 0, 0, 1);
GlStateManager.rotate(rotation / 10, 0, 0, 1); GlStateManager.translate(1.7 * translationOffset, 0, 0);
GlStateManager.translate(1.7 * translationOffset, 0, 0); break;
break; case 2:
case 2: GlStateManager.translate(0, 0, -verticalOffset);
GlStateManager.translate(0, 0, -verticalOffset);
// GlStateManager.rotate(254, 0, 0, 1); // GlStateManager.rotate(254, 0, 0, 1);
GlStateManager.rotate((float) (rotation / 150 + 120), 1, 0, 0); GlStateManager.rotate((float) (rotation / 150 + 120), 1, 0, 0);
GlStateManager.rotate(120, 0, 1, 0); GlStateManager.rotate(120, 0, 1, 0);
GlStateManager.rotate(-rotation / 10, 0, 0, 1); GlStateManager.rotate(-rotation / 10, 0, 0, 1);
GlStateManager.translate(1.2 * translationOffset, 0, 0); GlStateManager.translate(1.2 * translationOffset, 0, 0);
break; break;
case 3: case 3:
GlStateManager.translate(0, 0, -verticalOffset); GlStateManager.translate(0, 0, -verticalOffset);
// GlStateManager.rotate(130, 0, 0, 1); // GlStateManager.rotate(130, 0, 0, 1);
GlStateManager.rotate((float) (rotation / 100 + 284), 1, 0, 0); GlStateManager.rotate((float) (rotation / 100 + 284), 1, 0, 0);
GlStateManager.rotate(240, 0, 1, 0); GlStateManager.rotate(240, 0, 1, 0);
GlStateManager.rotate(-rotation / 7 + 180, 0, 0, 1); GlStateManager.rotate(-rotation / 7 + 180, 0, 0, 1);
GlStateManager.translate(2 * translationOffset, 0, 0); GlStateManager.translate(2 * translationOffset, 0, 0);
break; break;
default: default:
//What are you doing, Way??? //What are you doing, Way???
} }
GlStateManager.rotate(primaryRotation, 0, 1, 0); GlStateManager.rotate(primaryRotation, 0, 1, 0);
@ -249,8 +226,7 @@ public class MobSacrificeAlchemyCircleRenderer extends AlchemyCircleRenderer
renderStandardCircle(tessellator, builder, size); renderStandardCircle(tessellator, builder, size);
} }
private void renderStandardCircle(Tessellator tessellator, BufferBuilder builder, double size) private void renderStandardCircle(Tessellator tessellator, BufferBuilder builder, double size) {
{
double var31 = 0.0D; double var31 = 0.0D;
double var33 = 1.0D; double var33 = 1.0D;
double var35 = 0; double var35 = 0;

143
src/main/java/WayofTime/bloodmagic/client/render/alchemyArray/TurretAlchemyCircleRenderer.java
View file

@ -15,33 +15,27 @@ import WayofTime.bloodmagic.alchemyArray.AlchemyArrayEffectArrowTurret;
import WayofTime.bloodmagic.alchemyArray.AlchemyCircleRenderer; import WayofTime.bloodmagic.alchemyArray.AlchemyCircleRenderer;
import WayofTime.bloodmagic.tile.TileAlchemyArray; import WayofTime.bloodmagic.tile.TileAlchemyArray;
public class TurretAlchemyCircleRenderer extends AlchemyCircleRenderer public class TurretAlchemyCircleRenderer extends AlchemyCircleRenderer {
{
private ResourceLocation bottomArrayResource = new ResourceLocation("bloodmagic", "textures/models/AlchemyArrays/MovementArray.png"); private ResourceLocation bottomArrayResource = new ResourceLocation("bloodmagic", "textures/models/AlchemyArrays/MovementArray.png");
private ResourceLocation middleArrayResource = new ResourceLocation("bloodmagic", "textures/models/AlchemyArrays/SkeletonTurret2.png"); private ResourceLocation middleArrayResource = new ResourceLocation("bloodmagic", "textures/models/AlchemyArrays/SkeletonTurret2.png");
public TurretAlchemyCircleRenderer(ResourceLocation location) public TurretAlchemyCircleRenderer(ResourceLocation location) {
{
super(location); super(location);
} }
public TurretAlchemyCircleRenderer() public TurretAlchemyCircleRenderer() {
{
this(new ResourceLocation("bloodmagic", "textures/models/AlchemyArrays/MovementArray.png")); this(new ResourceLocation("bloodmagic", "textures/models/AlchemyArrays/MovementArray.png"));
} }
@Override @Override
public float getSizeModifier(float craftTime) public float getSizeModifier(float craftTime) {
{
return 1; return 1;
} }
@Override @Override
public float getRotation(float craftTime) public float getRotation(float craftTime) {
{
float offset = 50; float offset = 50;
if (craftTime >= offset) if (craftTime >= offset) {
{
float modifier = (craftTime - offset) * 5f; float modifier = (craftTime - offset) * 5f;
return modifier * 1f; return modifier * 1f;
} }
@ -49,16 +43,13 @@ public class TurretAlchemyCircleRenderer extends AlchemyCircleRenderer
} }
@Override @Override
public float getSecondaryRotation(float craftTime) public float getSecondaryRotation(float craftTime) {
{
return 0; return 0;
} }
@Override @Override
public void renderAt(TileEntity tile, double x, double y, double z, float craftTime) public void renderAt(TileEntity tile, double x, double y, double z, float craftTime) {
{ if (!(tile instanceof TileAlchemyArray)) {
if (!(tile instanceof TileAlchemyArray))
{
return; return;
} }
@ -69,8 +60,7 @@ public class TurretAlchemyCircleRenderer extends AlchemyCircleRenderer
double pitch = 0; double pitch = 0;
double yaw = 0; double yaw = 0;
int arrowTimer = -1; int arrowTimer = -1;
if (effect instanceof AlchemyArrayEffectArrowTurret) if (effect instanceof AlchemyArrayEffectArrowTurret) {
{
AlchemyArrayEffectArrowTurret turretEffect = (AlchemyArrayEffectArrowTurret) effect; AlchemyArrayEffectArrowTurret turretEffect = (AlchemyArrayEffectArrowTurret) effect;
pitch = (turretEffect.getPitch() - turretEffect.getLastPitch()) * f + turretEffect.getLastPitch(); pitch = (turretEffect.getPitch() - turretEffect.getLastPitch()) * f + turretEffect.getLastPitch();
yaw = (turretEffect.getYaw() - turretEffect.getLastYaw()) * f + turretEffect.getLastYaw(); yaw = (turretEffect.getYaw() - turretEffect.getLastYaw()) * f + turretEffect.getLastYaw();
@ -103,30 +93,29 @@ public class TurretAlchemyCircleRenderer extends AlchemyCircleRenderer
GlStateManager.translate(sideHit.getXOffset() * offsetFromFace, sideHit.getYOffset() * offsetFromFace, sideHit.getZOffset() * offsetFromFace); GlStateManager.translate(sideHit.getXOffset() * offsetFromFace, sideHit.getYOffset() * offsetFromFace, sideHit.getZOffset() * offsetFromFace);
switch (sideHit) switch (sideHit) {
{ case DOWN:
case DOWN: GlStateManager.translate(0, 0, 1);
GlStateManager.translate(0, 0, 1); GlStateManager.rotate(-90.0f, 1, 0, 0);
GlStateManager.rotate(-90.0f, 1, 0, 0); break;
break; case EAST:
case EAST: GlStateManager.rotate(-90.0f, 0, 1, 0);
GlStateManager.rotate(-90.0f, 0, 1, 0); GlStateManager.translate(0, 0, -1);
GlStateManager.translate(0, 0, -1); break;
break; case NORTH:
case NORTH: break;
break; case SOUTH:
case SOUTH: GlStateManager.rotate(180.0f, 0, 1, 0);
GlStateManager.rotate(180.0f, 0, 1, 0); GlStateManager.translate(-1, 0, -1);
GlStateManager.translate(-1, 0, -1); break;
break; case UP:
case UP: GlStateManager.translate(0, 1, 0);
GlStateManager.translate(0, 1, 0); GlStateManager.rotate(90.0f, 1, 0, 0);
GlStateManager.rotate(90.0f, 1, 0, 0); break;
break; case WEST:
case WEST: GlStateManager.translate(0, 0, 1);
GlStateManager.translate(0, 0, 1); GlStateManager.rotate(90.0f, 0, 1, 0);
GlStateManager.rotate(90.0f, 0, 1, 0); break;
break;
} }
GlStateManager.pushMatrix(); GlStateManager.pushMatrix();
@ -177,93 +166,71 @@ public class TurretAlchemyCircleRenderer extends AlchemyCircleRenderer
GlStateManager.popMatrix(); GlStateManager.popMatrix();
} }
public float getStartupPitchYawRatio(float craftTime) public float getStartupPitchYawRatio(float craftTime) {
{ if (craftTime <= 80) {
if (craftTime <= 80)
{
return 0; return 0;
} else if (craftTime > 80 && craftTime < 140) } else if (craftTime > 80 && craftTime < 140) {
{
return (craftTime - 80) / 60f; return (craftTime - 80) / 60f;
} }
return 1; return 1;
} }
public double getBottomHeightOffset(double craftTime, double arrowAnimation) public double getBottomHeightOffset(double craftTime, double arrowAnimation) {
{ if (craftTime <= 40) {
if (craftTime <= 40)
{
return 0; return 0;
} else if (craftTime > 40 && craftTime < 100) } else if (craftTime > 40 && craftTime < 100) {
{
return -0.4 * (craftTime - 40) / 60d; return -0.4 * (craftTime - 40) / 60d;
} else if (craftTime >= 100 && craftTime < 140) } else if (craftTime >= 100 && craftTime < 140) {
{
return -0.4 * (140 - craftTime) / 40d; return -0.4 * (140 - craftTime) / 40d;
} }
if (arrowAnimation > 0 && arrowAnimation < 45) if (arrowAnimation > 0 && arrowAnimation < 45) {
{
return -0.4 * (arrowAnimation) / 45; return -0.4 * (arrowAnimation) / 45;
} else if (arrowAnimation >= 45 && arrowAnimation < 50) } else if (arrowAnimation >= 45 && arrowAnimation < 50) {
{
return -0.4 * (50 - arrowAnimation) / 5; return -0.4 * (50 - arrowAnimation) / 5;
} }
return 0; return 0;
} }
public double getMiddleHeightOffset(double craftTime, double arrowAnimation) public double getMiddleHeightOffset(double craftTime, double arrowAnimation) {
{ if (craftTime <= 40) {
if (craftTime <= 40)
{
return 0; return 0;
} else if (craftTime > 40 && craftTime < 100) } else if (craftTime > 40 && craftTime < 100) {
{
return 0.1 * (craftTime - 40) / 60d; return 0.1 * (craftTime - 40) / 60d;
} else if (craftTime >= 100 && craftTime < 140) } else if (craftTime >= 100 && craftTime < 140) {
{
return 0.1 * (140 - craftTime) / 40d; return 0.1 * (140 - craftTime) / 40d;
} }
if (arrowAnimation > 0 && arrowAnimation < 45) if (arrowAnimation > 0 && arrowAnimation < 45) {
{
return 0.1 * (arrowAnimation) / 45; return 0.1 * (arrowAnimation) / 45;
} else if (arrowAnimation >= 45 && arrowAnimation < 50) } else if (arrowAnimation >= 45 && arrowAnimation < 50) {
{
return 0.1 * (50 - arrowAnimation) / 5; return 0.1 * (50 - arrowAnimation) / 5;
} }
return 0; return 0;
} }
public double getTopHeightOffset(double craftTime, double arrowAnimation) public double getTopHeightOffset(double craftTime, double arrowAnimation) {
{ if (craftTime <= 40) {
if (craftTime <= 40)
{
return 0; return 0;
} else if (craftTime > 40 && craftTime < 100) } else if (craftTime > 40 && craftTime < 100) {
{
return 0.4 * (craftTime - 40) / 60d; return 0.4 * (craftTime - 40) / 60d;
} else if (craftTime >= 100 && craftTime < 140) } else if (craftTime >= 100 && craftTime < 140) {
{
return 0.4 * (140 - craftTime) / 40d; return 0.4 * (140 - craftTime) / 40d;
} }
if (arrowAnimation > 0 && arrowAnimation < 45) if (arrowAnimation > 0 && arrowAnimation < 45) {
{
return 0.4 * (arrowAnimation) / 45; return 0.4 * (arrowAnimation) / 45;
} else if (arrowAnimation >= 45 && arrowAnimation < 50) } else if (arrowAnimation >= 45 && arrowAnimation < 50) {
{
return 0.4 * (50 - arrowAnimation) / 5; return 0.4 * (50 - arrowAnimation) / 5;
} }
return 0; return 0;
} }
private void renderStandardCircle(Tessellator tessellator, BufferBuilder builder, double size) private void renderStandardCircle(Tessellator tessellator, BufferBuilder builder, double size) {
{
double var31 = 0.0D; double var31 = 0.0D;
double var33 = 1.0D; double var33 = 1.0D;
double var35 = 0; double var35 = 0;

1
src/main/java/WayofTime/bloodmagic/command/sub/SubCommandRitual.java
View file

@ -49,6 +49,7 @@ public class SubCommandRitual extends CommandTreeBase {
class RitualCreate extends CommandTreeBase { class RitualCreate extends CommandTreeBase {
public List<String> ritualList = new ArrayList<>(); public List<String> ritualList = new ArrayList<>();
public RitualCreate() { public RitualCreate() {
for (Ritual ritual : BloodMagic.RITUAL_MANAGER.getRituals()) { for (Ritual ritual : BloodMagic.RITUAL_MANAGER.getRituals()) {
ritualList.add(BloodMagic.RITUAL_MANAGER.getId(ritual)); ritualList.add(BloodMagic.RITUAL_MANAGER.getId(ritual));

4
src/main/java/WayofTime/bloodmagic/compress/BaseCompressionHandler.java
View file

@ -37,13 +37,13 @@ public class BaseCompressionHandler extends CompressionHandler {
public int getRemainingNeeded(ItemStack[] inv) { public int getRemainingNeeded(ItemStack[] inv) {
int needed = this.required.getCount(); int needed = this.required.getCount();
int kept = this.getLeftover(); int kept = this.getLeftover();
return iterateThroughInventory(this.required, kept, inv, needed, true); return iterateThroughInventory(this.required, kept, inv, needed, true);
} }
public int drainInventory(ItemStack[] inv) { public int drainInventory(ItemStack[] inv) {
int needed = this.required.getCount(); int needed = this.required.getCount();
int kept = this.getLeftover(); int kept = this.getLeftover();
return iterateThroughInventory(this.required, kept, inv, needed, true); return iterateThroughInventory(this.required, kept, inv, needed, true);
} }
public int getLeftover() { public int getLeftover() {

2
src/main/java/WayofTime/bloodmagic/compress/StorageBlockCraftingManager.java
View file

@ -16,7 +16,7 @@ public class StorageBlockCraftingManager {
private static final StorageBlockCraftingManager instance = new StorageBlockCraftingManager(); private static final StorageBlockCraftingManager instance = new StorageBlockCraftingManager();
private List<IRecipe> recipes = new LinkedList<>(); private List<IRecipe> recipes = new LinkedList<>();
public void addRecipe(IRecipe recipe){ public void addRecipe(IRecipe recipe) {
this.recipes.add(recipe); this.recipes.add(recipe);
} }

21
src/main/java/WayofTime/bloodmagic/core/RegistrarBloodMagic.java
View file

@ -29,8 +29,7 @@ import net.minecraftforge.registries.RegistryBuilder;
@Mod.EventBusSubscriber(modid = BloodMagic.MODID) @Mod.EventBusSubscriber(modid = BloodMagic.MODID)
@GameRegistry.ObjectHolder(BloodMagic.MODID) @GameRegistry.ObjectHolder(BloodMagic.MODID)
public class RegistrarBloodMagic public class RegistrarBloodMagic {
{
private static final BloodOrb ORB_DEF = new BloodOrb("", 0, 0, 0); private static final BloodOrb ORB_DEF = new BloodOrb("", 0, 0, 0);
@GameRegistry.ObjectHolder("weak") @GameRegistry.ObjectHolder("weak")
@ -67,8 +66,7 @@ public class RegistrarBloodMagic
public static IForgeRegistry<BloodOrb> BLOOD_ORBS = null; public static IForgeRegistry<BloodOrb> BLOOD_ORBS = null;
@SubscribeEvent @SubscribeEvent
public static void registerBloodOrbs(RegistryEvent.Register<BloodOrb> event) public static void registerBloodOrbs(RegistryEvent.Register<BloodOrb> event) {
{
ResourceLocation orb = RegistrarBloodMagicItems.BLOOD_ORB.getRegistryName(); ResourceLocation orb = RegistrarBloodMagicItems.BLOOD_ORB.getRegistryName();
event.getRegistry().registerAll( event.getRegistry().registerAll(
new BloodOrb("weak", 1, 5000, 2).withModel(new ModelResourceLocation(orb, "type=weak")).setRegistryName("weak"), new BloodOrb("weak", 1, 5000, 2).withModel(new ModelResourceLocation(orb, "type=weak")).setRegistryName("weak"),
@ -85,8 +83,7 @@ public class RegistrarBloodMagic
} }
@SubscribeEvent @SubscribeEvent
public static void registerPotions(RegistryEvent.Register<Potion> event) public static void registerPotions(RegistryEvent.Register<Potion> event) {
{
event.getRegistry().registerAll( event.getRegistry().registerAll(
new PotionBloodMagic("Boost", false, 0xFFFFFF, 0, 0).setRegistryName("boost"), new PotionBloodMagic("Boost", false, 0xFFFFFF, 0, 0).setRegistryName("boost"),
new PotionBloodMagic("Whirlwind", false, 0xFFFFFF, 0, 0).setRegistryName("whirlwind"), new PotionBloodMagic("Whirlwind", false, 0xFFFFFF, 0, 0).setRegistryName("whirlwind"),
@ -109,8 +106,7 @@ public class RegistrarBloodMagic
} }
@SubscribeEvent @SubscribeEvent
public static void registerEntities(RegistryEvent.Register<EntityEntry> event) public static void registerEntities(RegistryEvent.Register<EntityEntry> event) {
{
int entities = 0; int entities = 0;
event.getRegistry().registerAll( event.getRegistry().registerAll(
@ -128,8 +124,7 @@ public class RegistrarBloodMagic
} }
@SubscribeEvent @SubscribeEvent
public static void onRegistryCreation(RegistryEvent.NewRegistry event) public static void onRegistryCreation(RegistryEvent.NewRegistry event) {
{
BLOOD_ORBS = new RegistryBuilder<BloodOrb>() BLOOD_ORBS = new RegistryBuilder<BloodOrb>()
.setName(new ResourceLocation(BloodMagic.MODID, "blood_orb")) .setName(new ResourceLocation(BloodMagic.MODID, "blood_orb"))
.setIDRange(0, Short.MAX_VALUE) .setIDRange(0, Short.MAX_VALUE)
@ -140,10 +135,8 @@ public class RegistrarBloodMagic
@SideOnly(Side.CLIENT) @SideOnly(Side.CLIENT)
@SubscribeEvent @SubscribeEvent
public static void registerModels(ModelRegistryEvent event) public static void registerModels(ModelRegistryEvent event) {
{ for (BloodOrb orb : BLOOD_ORBS) {
for (BloodOrb orb : BLOOD_ORBS)
{
ModelResourceLocation modelLocation = orb.getModelLocation(); ModelResourceLocation modelLocation = orb.getModelLocation();
if (modelLocation == null) if (modelLocation == null)
modelLocation = new ModelResourceLocation(orb.getRegistryName(), "inventory"); modelLocation = new ModelResourceLocation(orb.getRegistryName(), "inventory");

11
src/main/java/WayofTime/bloodmagic/core/RegistrarBloodMagicItems.java
View file

@ -44,8 +44,7 @@ import java.util.Set;
@Mod.EventBusSubscriber(modid = BloodMagic.MODID) @Mod.EventBusSubscriber(modid = BloodMagic.MODID)
@GameRegistry.ObjectHolder(BloodMagic.MODID) @GameRegistry.ObjectHolder(BloodMagic.MODID)
@SuppressWarnings("unchecked") @SuppressWarnings("unchecked")
public class RegistrarBloodMagicItems public class RegistrarBloodMagicItems {
{
public static final Item BLOOD_ORB = Items.AIR; public static final Item BLOOD_ORB = Items.AIR;
public static final Item ACTIVATION_CRYSTAL = Items.AIR; public static final Item ACTIVATION_CRYSTAL = Items.AIR;
@ -129,8 +128,7 @@ public class RegistrarBloodMagicItems
public static List<Item> items; public static List<Item> items;
@SubscribeEvent @SubscribeEvent
public static void registerItems(RegistryEvent.Register<Item> event) public static void registerItems(RegistryEvent.Register<Item> event) {
{
items = Lists.newArrayList(); items = Lists.newArrayList();
RegistrarBloodMagicBlocks.blocks.stream().filter(block -> block instanceof IBMBlock && ((IBMBlock) block).getItem() != null).forEach(block -> RegistrarBloodMagicBlocks.blocks.stream().filter(block -> block instanceof IBMBlock && ((IBMBlock) block).getItem() != null).forEach(block ->
@ -215,15 +213,14 @@ public class RegistrarBloodMagicItems
new ItemPotionFlask().setRegistryName("potion_flask"), new ItemPotionFlask().setRegistryName("potion_flask"),
new ItemAlchemicVial().setRegistryName("alchemic_vial"), new ItemAlchemicVial().setRegistryName("alchemic_vial"),
new ItemFlightScroll().setRegistryName("icarus_scroll") new ItemFlightScroll().setRegistryName("icarus_scroll")
)); ));
event.getRegistry().registerAll(items.toArray(new Item[0])); event.getRegistry().registerAll(items.toArray(new Item[0]));
} }
@SideOnly(Side.CLIENT) @SideOnly(Side.CLIENT)
@SubscribeEvent @SubscribeEvent
public static void registerRenders(ModelRegistryEvent event) public static void registerRenders(ModelRegistryEvent event) {
{
items.stream().filter(i -> i instanceof IVariantProvider).forEach(i -> items.stream().filter(i -> i instanceof IVariantProvider).forEach(i ->
{ {
Int2ObjectMap<String> variants = new Int2ObjectOpenHashMap<>(); Int2ObjectMap<String> variants = new Int2ObjectOpenHashMap<>();

36
src/main/java/WayofTime/bloodmagic/core/RegistrarBloodMagicRecipes.java
View file

@ -37,16 +37,12 @@ import java.util.List;
import java.util.Set; import java.util.Set;
@Mod.EventBusSubscriber(modid = BloodMagic.MODID) @Mod.EventBusSubscriber(modid = BloodMagic.MODID)
public class RegistrarBloodMagicRecipes public class RegistrarBloodMagicRecipes {
{
@SubscribeEvent @SubscribeEvent
public static void registerRecipes(RegistryEvent.Register<IRecipe> event) public static void registerRecipes(RegistryEvent.Register<IRecipe> event) {
{ for (int i = 0; i < ItemSoulGem.names.length; i++) {
for (int i = 0; i < ItemSoulGem.names.length; i++) for (EnumDemonWillType willType : EnumDemonWillType.values()) {
{
for (EnumDemonWillType willType : EnumDemonWillType.values())
{
ItemStack baseGemStack = new ItemStack(RegistrarBloodMagicItems.SOUL_GEM, 1, i); ItemStack baseGemStack = new ItemStack(RegistrarBloodMagicItems.SOUL_GEM, 1, i);
ItemStack newGemStack = new ItemStack(RegistrarBloodMagicItems.SOUL_GEM, 1, i); ItemStack newGemStack = new ItemStack(RegistrarBloodMagicItems.SOUL_GEM, 1, i);
@ -65,8 +61,7 @@ public class RegistrarBloodMagicRecipes
RegistrarBloodMagicItems.SOUL_TOOL_MATERIAL.setRepairItem(EnumDemonWillType.DEFAULT.getStack()); RegistrarBloodMagicItems.SOUL_TOOL_MATERIAL.setRepairItem(EnumDemonWillType.DEFAULT.getStack());
} }
public static void registerAltarRecipes(BloodMagicRecipeRegistrar registrar) public static void registerAltarRecipes(BloodMagicRecipeRegistrar registrar) {
{
// ONE // ONE
registrar.addBloodAltar(new OreIngredient("gemDiamond"), OrbRegistry.getOrbStack(RegistrarBloodMagic.ORB_WEAK), AltarTier.ONE.ordinal(), 2000, 2, 1); registrar.addBloodAltar(new OreIngredient("gemDiamond"), OrbRegistry.getOrbStack(RegistrarBloodMagic.ORB_WEAK), AltarTier.ONE.ordinal(), 2000, 2, 1);
registrar.addBloodAltar(new OreIngredient("stone"), ItemSlate.SlateType.BLANK.getStack(), AltarTier.ONE.ordinal(), 1000, 5, 5); registrar.addBloodAltar(new OreIngredient("stone"), ItemSlate.SlateType.BLANK.getStack(), AltarTier.ONE.ordinal(), 1000, 5, 5);
@ -105,8 +100,7 @@ public class RegistrarBloodMagicRecipes
} }
} }
public static void registerAlchemyTableRecipes(BloodMagicRecipeRegistrar registrar) public static void registerAlchemyTableRecipes(BloodMagicRecipeRegistrar registrar) {
{
registrar.addAlchemyTable(new ItemStack(Items.STRING, 4), 0, 100, 0, Blocks.WOOL, Items.FLINT); registrar.addAlchemyTable(new ItemStack(Items.STRING, 4), 0, 100, 0, Blocks.WOOL, Items.FLINT);
registrar.addAlchemyTable(new ItemStack(Items.FLINT, 2), 0, 20, 0, Blocks.GRAVEL, Items.FLINT); registrar.addAlchemyTable(new ItemStack(Items.FLINT, 2), 0, 20, 0, Blocks.GRAVEL, Items.FLINT);
registrar.addAlchemyTable(new ItemStack(Items.LEATHER, 4), 100, 200, 1, Items.ROTTEN_FLESH, Items.ROTTEN_FLESH, Items.ROTTEN_FLESH, Items.ROTTEN_FLESH, Items.FLINT, Items.WATER_BUCKET); registrar.addAlchemyTable(new ItemStack(Items.LEATHER, 4), 100, 200, 1, Items.ROTTEN_FLESH, Items.ROTTEN_FLESH, Items.ROTTEN_FLESH, Items.ROTTEN_FLESH, Items.FLINT, Items.WATER_BUCKET);
@ -139,16 +133,13 @@ public class RegistrarBloodMagicRecipes
Set<String> addedOreRecipeList = Sets.newHashSet("oreIron", "oreGold", "oreCoal", "oreRedstone"); // We already added these above Set<String> addedOreRecipeList = Sets.newHashSet("oreIron", "oreGold", "oreCoal", "oreRedstone"); // We already added these above
String[] oreList = OreDictionary.getOreNames().clone(); String[] oreList = OreDictionary.getOreNames().clone();
for (String ore : oreList) for (String ore : oreList) {
{ if (ore.startsWith("ore") && !addedOreRecipeList.contains(ore)) {
if (ore.startsWith("ore") && !addedOreRecipeList.contains(ore))
{
String dustName = ore.replaceFirst("ore", "dust"); String dustName = ore.replaceFirst("ore", "dust");
List<ItemStack> discoveredOres = OreDictionary.getOres(ore); List<ItemStack> discoveredOres = OreDictionary.getOres(ore);
List<ItemStack> dustList = OreDictionary.getOres(dustName); List<ItemStack> dustList = OreDictionary.getOres(dustName);
if (dustList != null && !dustList.isEmpty() && discoveredOres != null && !discoveredOres.isEmpty()) if (dustList != null && !dustList.isEmpty() && discoveredOres != null && !discoveredOres.isEmpty()) {
{
ItemStack dustStack = dustList.get(0).copy(); ItemStack dustStack = dustList.get(0).copy();
dustStack.setCount(2); dustStack.setCount(2);
registrar.addAlchemyTable(dustStack, 400, 200, 1, ore, ItemCuttingFluid.FluidType.BASIC.getStack()); registrar.addAlchemyTable(dustStack, 400, 200, 1, ore, ItemCuttingFluid.FluidType.BASIC.getStack());
@ -158,8 +149,7 @@ public class RegistrarBloodMagicRecipes
} }
} }
public static void registerTartaricForgeRecipes(BloodMagicRecipeRegistrar registrar) public static void registerTartaricForgeRecipes(BloodMagicRecipeRegistrar registrar) {
{
registrar.addTartaricForge(new ItemStack(RegistrarBloodMagicItems.SOUL_GEM), 1, 1, "dustRedstone", "ingotGold", "blockGlass", "dyeBlue"); registrar.addTartaricForge(new ItemStack(RegistrarBloodMagicItems.SOUL_GEM), 1, 1, "dustRedstone", "ingotGold", "blockGlass", "dyeBlue");
registrar.addTartaricForge(new ItemStack(RegistrarBloodMagicItems.SOUL_GEM, 1, 1), 60, 20, new ItemStack(RegistrarBloodMagicItems.SOUL_GEM), "gemDiamond", "blockRedstone", "blockLapis"); registrar.addTartaricForge(new ItemStack(RegistrarBloodMagicItems.SOUL_GEM, 1, 1), 60, 20, new ItemStack(RegistrarBloodMagicItems.SOUL_GEM), "gemDiamond", "blockRedstone", "blockLapis");
registrar.addTartaricForge(new ItemStack(RegistrarBloodMagicItems.SOUL_GEM, 1, 2), 240, 50, new ItemStack(RegistrarBloodMagicItems.SOUL_GEM, 1, 1), "gemDiamond", "blockGold", ItemSlate.SlateType.IMBUED.getStack()); registrar.addTartaricForge(new ItemStack(RegistrarBloodMagicItems.SOUL_GEM, 1, 2), 240, 50, new ItemStack(RegistrarBloodMagicItems.SOUL_GEM, 1, 1), "gemDiamond", "blockGold", ItemSlate.SlateType.IMBUED.getStack());
@ -216,8 +206,7 @@ public class RegistrarBloodMagicRecipes
registrar.addTartaricForge(new ItemStack(RegistrarBloodMagicItems.RITUAL_DISMANTLER), 500, 100, new ItemStack(RegistrarBloodMagicItems.ITEM_DEMON_CRYSTAL, 1, 2), new ItemStack(RegistrarBloodMagicItems.ITEM_DEMON_CRYSTAL, 1, 2), new ItemStack(RegistrarBloodMagicItems.RITUAL_DIVINER), new ItemStack(RegistrarBloodMagicItems.BLOOD_SHARD)); registrar.addTartaricForge(new ItemStack(RegistrarBloodMagicItems.RITUAL_DISMANTLER), 500, 100, new ItemStack(RegistrarBloodMagicItems.ITEM_DEMON_CRYSTAL, 1, 2), new ItemStack(RegistrarBloodMagicItems.ITEM_DEMON_CRYSTAL, 1, 2), new ItemStack(RegistrarBloodMagicItems.RITUAL_DIVINER), new ItemStack(RegistrarBloodMagicItems.BLOOD_SHARD));
} }
public static void registerAlchemyArrayRecipes(BloodMagicRecipeRegistrar registrar) public static void registerAlchemyArrayRecipes(BloodMagicRecipeRegistrar registrar) {
{
registrar.addAlchemyArray(new ItemStack(Items.REDSTONE), ItemSlate.SlateType.BLANK.getStack(), new ItemStack(RegistrarBloodMagicItems.SIGIL_DIVINATION), new ResourceLocation("bloodmagic", "textures/models/AlchemyArrays/DivinationSigil.png")); registrar.addAlchemyArray(new ItemStack(Items.REDSTONE), ItemSlate.SlateType.BLANK.getStack(), new ItemStack(RegistrarBloodMagicItems.SIGIL_DIVINATION), new ResourceLocation("bloodmagic", "textures/models/AlchemyArrays/DivinationSigil.png"));
registrar.addAlchemyArray(ComponentTypes.REAGENT_WATER.getStack(), ItemSlate.SlateType.BLANK.getStack(), new ItemStack(RegistrarBloodMagicItems.SIGIL_WATER), new ResourceLocation("bloodmagic", "textures/models/AlchemyArrays/WaterSigil.png")); registrar.addAlchemyArray(ComponentTypes.REAGENT_WATER.getStack(), ItemSlate.SlateType.BLANK.getStack(), new ItemStack(RegistrarBloodMagicItems.SIGIL_WATER), new ResourceLocation("bloodmagic", "textures/models/AlchemyArrays/WaterSigil.png"));
@ -244,8 +233,7 @@ public class RegistrarBloodMagicRecipes
} }
public static void registerSacrificeCraftRecipes(BloodMagicRecipeRegistrar registrar) public static void registerSacrificeCraftRecipes(BloodMagicRecipeRegistrar registrar) {
{
registrar.addSacrificeCraft(new ItemStack(RegistrarBloodMagicBlocks.TELEPOSER), 10, Items.REDSTONE); registrar.addSacrificeCraft(new ItemStack(RegistrarBloodMagicBlocks.TELEPOSER), 10, Items.REDSTONE);
} }
} }

6
src/main/java/WayofTime/bloodmagic/entity/mob/EntitySentientSpecter.java
View file

@ -385,9 +385,9 @@ public class EntitySentientSpecter extends EntityDemonBase {
@Override @Override
public boolean shouldAttackEntity(EntityLivingBase attacker, EntityLivingBase owner) { public boolean shouldAttackEntity(EntityLivingBase attacker, EntityLivingBase owner) {
if (!(attacker instanceof EntityCreeper) && !(attacker instanceof EntityGhast)) { if (!(attacker instanceof EntityCreeper) && !(attacker instanceof EntityGhast)) {
return super.shouldAttackEntity(attacker, owner); return super.shouldAttackEntity(attacker, owner);
} }
return false; return false;
} }
@Override @Override

3
src/main/java/WayofTime/bloodmagic/item/ItemActivationCrystal.java
View file

@ -47,7 +47,8 @@ public class ItemActivationCrystal extends ItemEnum.Variant<ItemActivationCrysta
public enum CrystalType implements ISubItem { public enum CrystalType implements ISubItem {
WEAK, WEAK,
AWAKENED, AWAKENED,
CREATIVE,; CREATIVE,
;
@Nonnull @Nonnull
@Override @Override

9
src/main/java/WayofTime/bloodmagic/item/ItemAlchemicVial.java
View file

@ -3,16 +3,13 @@ package WayofTime.bloodmagic.item;
import WayofTime.bloodmagic.item.types.AlchemicVialType; import WayofTime.bloodmagic.item.types.AlchemicVialType;
import it.unimi.dsi.fastutil.ints.Int2ObjectMap; import it.unimi.dsi.fastutil.ints.Int2ObjectMap;
public class ItemAlchemicVial extends ItemEnum.Variant<AlchemicVialType> public class ItemAlchemicVial extends ItemEnum.Variant<AlchemicVialType> {
{ public ItemAlchemicVial() {
public ItemAlchemicVial()
{
super(AlchemicVialType.class, "alchemic_vial"); super(AlchemicVialType.class, "alchemic_vial");
} }
@Override @Override
public void gatherVariants(Int2ObjectMap<String> variants) public void gatherVariants(Int2ObjectMap<String> variants) {
{
for (AlchemicVialType type : types) for (AlchemicVialType type : types)
variants.put(type.ordinal(), "type=normal"); variants.put(type.ordinal(), "type=normal");
} }

2
src/main/java/WayofTime/bloodmagic/item/ItemBloodOrb.java
View file

@ -82,7 +82,7 @@ public class ItemBloodOrb extends ItemBindableBase implements IBloodOrb {
if (binding.getOwnerId().equals(player.getGameProfile().getId())) if (binding.getOwnerId().equals(player.getGameProfile().getId()))
ownerNetwork.setOrbTier(orb.getTier()); ownerNetwork.setOrbTier(orb.getTier());
ownerNetwork.add(SoulTicket.item(stack, world, player,200), orb.getCapacity()); // Add LP to owner's network ownerNetwork.add(SoulTicket.item(stack, world, player, 200), orb.getCapacity()); // Add LP to owner's network
ownerNetwork.hurtPlayer(player, 200); // Hurt whoever is using it ownerNetwork.hurtPlayer(player, 200); // Hurt whoever is using it
return super.onItemRightClick(world, player, hand); return super.onItemRightClick(world, player, hand);
} }

2
src/main/java/WayofTime/bloodmagic/item/ItemLavaCrystal.java
View file

@ -70,7 +70,7 @@ public class ItemLavaCrystal extends ItemBindableBase implements IVariantProvide
return null; return null;
NBTTagCompound nbt = (NBTTagCompound) bindingTag; NBTTagCompound nbt = (NBTTagCompound) bindingTag;
return new Binding(NBTUtil.getUUIDFromTag(nbt.getCompoundTag("id")),nbt.getString("name")); return new Binding(NBTUtil.getUUIDFromTag(nbt.getCompoundTag("id")), nbt.getString("name"));
} }
@Override @Override

12
src/main/java/WayofTime/bloodmagic/item/ItemSacrificialDagger.java
View file

@ -53,7 +53,7 @@ public class ItemSacrificialDagger extends ItemEnum<ItemSacrificialDagger.Dagger
@Override @Override
public void onPlayerStoppedUsing(ItemStack stack, World worldIn, EntityLivingBase entityLiving, int timeLeft) { public void onPlayerStoppedUsing(ItemStack stack, World worldIn, EntityLivingBase entityLiving, int timeLeft) {
if (entityLiving instanceof EntityPlayer && !entityLiving.getEntityWorld().isRemote) if (entityLiving instanceof EntityPlayer && !entityLiving.getEntityWorld().isRemote)
if(PlayerSacrificeHelper.sacrificePlayerHealth((EntityPlayer) entityLiving)) if (PlayerSacrificeHelper.sacrificePlayerHealth((EntityPlayer) entityLiving))
IncenseHelper.setHasMaxIncense(stack, (EntityPlayer) entityLiving, false); IncenseHelper.setHasMaxIncense(stack, (EntityPlayer) entityLiving, false);
} }
@ -132,9 +132,9 @@ public class ItemSacrificialDagger extends ItemEnum<ItemSacrificialDagger.Dagger
if (!world.isRemote && entity instanceof EntityPlayer) { if (!world.isRemote && entity instanceof EntityPlayer) {
boolean prepared = this.isPlayerPreparedForSacrifice(world, (EntityPlayer) entity); boolean prepared = this.isPlayerPreparedForSacrifice(world, (EntityPlayer) entity);
this.setUseForSacrifice(stack, prepared); this.setUseForSacrifice(stack, prepared);
if(IncenseHelper.getHasMaxIncense(stack) && !prepared) if (IncenseHelper.getHasMaxIncense(stack) && !prepared)
IncenseHelper.setHasMaxIncense(stack, (EntityPlayer) entity, false); IncenseHelper.setHasMaxIncense(stack, (EntityPlayer) entity, false);
if(prepared) { if (prepared) {
boolean isMax = IncenseHelper.getMaxIncense((EntityPlayer) entity) == IncenseHelper.getCurrentIncense((EntityPlayer) entity); boolean isMax = IncenseHelper.getMaxIncense((EntityPlayer) entity) == IncenseHelper.getCurrentIncense((EntityPlayer) entity);
IncenseHelper.setHasMaxIncense(stack, (EntityPlayer) entity, isMax); IncenseHelper.setHasMaxIncense(stack, (EntityPlayer) entity, isMax);
} }
@ -178,15 +178,15 @@ public class ItemSacrificialDagger extends ItemEnum<ItemSacrificialDagger.Dagger
} }
@Override @Override
public boolean hasEffect(ItemStack stack) public boolean hasEffect(ItemStack stack) {
{
return IncenseHelper.getHasMaxIncense(stack) || super.hasEffect(stack); return IncenseHelper.getHasMaxIncense(stack) || super.hasEffect(stack);
} }
public enum DaggerType implements ISubItem { public enum DaggerType implements ISubItem {
NORMAL, NORMAL,
CREATIVE,; CREATIVE,
;
@Nonnull @Nonnull
@Override @Override

3
src/main/java/WayofTime/bloodmagic/item/ItemSlate.java
View file

@ -32,7 +32,8 @@ public class ItemSlate extends ItemEnum.Variant<ItemSlate.SlateType> {
REINFORCED, REINFORCED,
IMBUED, IMBUED,
DEMONIC, DEMONIC,
ETHEREAL,; ETHEREAL,
;
@Nonnull @Nonnull
@Override @Override

3
src/main/java/WayofTime/bloodmagic/item/ItemTelepositionFocus.java
View file

@ -93,7 +93,8 @@ public class ItemTelepositionFocus extends ItemEnum.Variant<ItemTelepositionFocu
WEAK, WEAK,
ENHANCED, ENHANCED,
REINFORCED, REINFORCED,
DEMONIC,; DEMONIC,
;
@Nonnull @Nonnull
@Override @Override

73
src/main/java/WayofTime/bloodmagic/item/block/ItemBlockMimic.java
View file

@ -22,98 +22,86 @@ import WayofTime.bloodmagic.item.block.base.ItemBlockEnum;
import WayofTime.bloodmagic.util.ChatUtil; import WayofTime.bloodmagic.util.ChatUtil;
public class ItemBlockMimic extends ItemBlockEnum public class ItemBlockMimic extends ItemBlockEnum {
{ public ItemBlockMimic(BlockEnum block) {
public ItemBlockMimic(BlockEnum block)
{
super(block); super(block);
setHasSubtypes(true); setHasSubtypes(true);
} }
@Override @Override
public EnumActionResult onItemUse(EntityPlayer player, World world, BlockPos pos, EnumHand hand, EnumFacing facing, float hitX, float hitY, float hitZ) public EnumActionResult onItemUse(EntityPlayer player, World world, BlockPos pos, EnumHand hand, EnumFacing facing, float hitX, float hitY, float hitZ) {
{
ItemStack stack = player.getHeldItem(hand); ItemStack stack = player.getHeldItem(hand);
//If not sneaking, do normal item use //If not sneaking, do normal item use
if (!player.isSneaking()) if (!player.isSneaking()) {
{
return super.onItemUse(player, world, pos, hand, facing, hitX, hitY, hitZ); return super.onItemUse(player, world, pos, hand, facing, hitX, hitY, hitZ);
} }
//IF sneaking and player has permission, replace the targeted block //IF sneaking and player has permission, replace the targeted block
if (player.canPlayerEdit(pos, facing, stack)) if (player.canPlayerEdit(pos, facing, stack)) {
{
//Store information about the block being replaced and its appropriate itemstack //Store information about the block being replaced and its appropriate itemstack
IBlockState replacedBlockstate = world.getBlockState(pos); IBlockState replacedBlockstate = world.getBlockState(pos);
Block replacedBlock = replacedBlockstate.getBlock(); Block replacedBlock = replacedBlockstate.getBlock();
ItemStack replacedStack = replacedBlock.getItem(world, pos, replacedBlockstate); ItemStack replacedStack = replacedBlock.getItem(world, pos, replacedBlockstate);
//Get the state for the mimic //Get the state for the mimic
IBlockState mimicBlockstate = this.getBlock().getStateFromMeta(stack.getMetadata()); IBlockState mimicBlockstate = this.getBlock().getStateFromMeta(stack.getMetadata());
//Check if the block can be replaced //Check if the block can be replaced
if (!canReplaceBlock(world, pos, replacedBlockstate)) if (!canReplaceBlock(world, pos, replacedBlockstate)) {
{
return super.onItemUse(player, world, pos, hand, facing, hitX, hitY, hitZ); return super.onItemUse(player, world, pos, hand, facing, hitX, hitY, hitZ);
} }
//Check if the tile entity, if any, can be replaced //Check if the tile entity, if any, can be replaced
TileEntity tileReplaced = world.getTileEntity(pos); TileEntity tileReplaced = world.getTileEntity(pos);
if (!canReplaceTile(tileReplaced)) if (!canReplaceTile(tileReplaced)) {
{
return EnumActionResult.FAIL; return EnumActionResult.FAIL;
} }
//If tile can be replaced, store info about the tile //If tile can be replaced, store info about the tile
NBTTagCompound tileTag = getTagFromTileEntity(tileReplaced); NBTTagCompound tileTag = getTagFromTileEntity(tileReplaced);
if (tileReplaced != null) if (tileReplaced != null) {
{
NBTTagCompound voidTag = new NBTTagCompound(); NBTTagCompound voidTag = new NBTTagCompound();
voidTag.setInteger("x", pos.getX()); voidTag.setInteger("x", pos.getX());
voidTag.setInteger("y", pos.getY()); voidTag.setInteger("y", pos.getY());
voidTag.setInteger("z", pos.getZ()); voidTag.setInteger("z", pos.getZ());
tileReplaced.readFromNBT(voidTag); tileReplaced.readFromNBT(voidTag);
} }
//Remove one item from stack //Remove one item from stack
stack.shrink(1); stack.shrink(1);
//Replace the block //Replace the block
world.setBlockState(pos, mimicBlockstate, 3); world.setBlockState(pos, mimicBlockstate, 3);
//Make placing sound //Make placing sound
SoundType soundtype = this.block.getSoundType(); SoundType soundtype = this.block.getSoundType();
world.playSound(player, pos, soundtype.getPlaceSound(), SoundCategory.BLOCKS, (soundtype.getVolume() + 1.0F) / 2.0F, soundtype.getPitch() * 0.8F); world.playSound(player, pos, soundtype.getPlaceSound(), SoundCategory.BLOCKS, (soundtype.getVolume() + 1.0F) / 2.0F, soundtype.getPitch() * 0.8F);
//Replace the tile entity //Replace the tile entity
TileEntity tile = world.getTileEntity(pos); TileEntity tile = world.getTileEntity(pos);
if (tile instanceof TileMimic) if (tile instanceof TileMimic) {
{
TileMimic mimic = (TileMimic) tile; TileMimic mimic = (TileMimic) tile;
mimic.tileTag = tileTag; mimic.tileTag = tileTag;
mimic.setReplacedState(replacedBlockstate); mimic.setReplacedState(replacedBlockstate);
mimic.setInventorySlotContents(0, replacedStack); mimic.setInventorySlotContents(0, replacedStack);
mimic.refreshTileEntity(); mimic.refreshTileEntity();
if (player.capabilities.isCreativeMode) if (player.capabilities.isCreativeMode) {
{
mimic.dropItemsOnBreak = false; mimic.dropItemsOnBreak = false;
} }
} }
return EnumActionResult.SUCCESS; return EnumActionResult.SUCCESS;
} }
return EnumActionResult.FAIL; return EnumActionResult.FAIL;
} }
public boolean canReplaceTile(TileEntity tile) public boolean canReplaceTile(TileEntity tile) {
{ if (tile instanceof TileEntityChest) {
if (tile instanceof TileEntityChest)
{
return true; return true;
} }
@ -124,12 +112,10 @@ public class ItemBlockMimic extends ItemBlockEnum
return state.getBlockHardness(world, pos) != -1.0F; return state.getBlockHardness(world, pos) != -1.0F;
} }
public NBTTagCompound getTagFromTileEntity(TileEntity tile) public NBTTagCompound getTagFromTileEntity(TileEntity tile) {
{
NBTTagCompound tag = new NBTTagCompound(); NBTTagCompound tag = new NBTTagCompound();
if (tile != null) if (tile != null) {
{
return tile.writeToNBT(tag); return tile.writeToNBT(tag);
} }
@ -137,8 +123,7 @@ public class ItemBlockMimic extends ItemBlockEnum
} }
@Override @Override
public int getMetadata(int meta) public int getMetadata(int meta) {
{
return meta; return meta;
} }
} }

70
src/main/java/WayofTime/bloodmagic/item/routing/ItemFluidRouterFilter.java
View file

@ -23,12 +23,10 @@ import javax.annotation.Nonnull;
import java.util.ArrayList; import java.util.ArrayList;
import java.util.List; import java.util.List;
public class ItemFluidRouterFilter extends Item implements IFluidFilterProvider, IVariantProvider public class ItemFluidRouterFilter extends Item implements IFluidFilterProvider, IVariantProvider {
{ public static String[] names = {"exact"};
public static String[] names = { "exact" };
public ItemFluidRouterFilter() public ItemFluidRouterFilter() {
{
super(); super();
setTranslationKey(BloodMagic.MODID + ".fluidFilter."); setTranslationKey(BloodMagic.MODID + ".fluidFilter.");
@ -37,15 +35,13 @@ public class ItemFluidRouterFilter extends Item implements IFluidFilterProvider,
} }
@Override @Override
public String getTranslationKey(ItemStack stack) public String getTranslationKey(ItemStack stack) {
{
return super.getTranslationKey(stack) + names[stack.getItemDamage()]; return super.getTranslationKey(stack) + names[stack.getItemDamage()];
} }
@Override @Override
@SideOnly(Side.CLIENT) @SideOnly(Side.CLIENT)
public void getSubItems(CreativeTabs creativeTab, NonNullList<ItemStack> list) public void getSubItems(CreativeTabs creativeTab, NonNullList<ItemStack> list) {
{
if (!isInCreativeTab(creativeTab)) if (!isInCreativeTab(creativeTab))
return; return;
@ -55,35 +51,30 @@ public class ItemFluidRouterFilter extends Item implements IFluidFilterProvider,
@Override @Override
@SideOnly(Side.CLIENT) @SideOnly(Side.CLIENT)
public void addInformation(ItemStack stack, World world, List<String> tooltip, ITooltipFlag flag) public void addInformation(ItemStack stack, World world, List<String> tooltip, ITooltipFlag flag) {
{
tooltip.add(TextHelper.localize("tooltip.bloodmagic.fluidFilter." + names[stack.getItemDamage()])); tooltip.add(TextHelper.localize("tooltip.bloodmagic.fluidFilter." + names[stack.getItemDamage()]));
super.addInformation(stack, world, tooltip, flag); super.addInformation(stack, world, tooltip, flag);
} }
@Override @Override
public IFluidFilter getInputFluidFilter(ItemStack filterStack, TileEntity tile, IFluidHandler handler) public IFluidFilter getInputFluidFilter(ItemStack filterStack, TileEntity tile, IFluidHandler handler) {
{
IFluidFilter testFilter; IFluidFilter testFilter;
switch (filterStack.getMetadata()) switch (filterStack.getMetadata()) {
{ case 0:
case 0: testFilter = new RoutingFluidFilter();
testFilter = new RoutingFluidFilter(); break;
break;
default: default:
testFilter = new RoutingFluidFilter(); testFilter = new RoutingFluidFilter();
} }
List<ItemStack> filteredList = new ArrayList<>(); List<ItemStack> filteredList = new ArrayList<>();
ItemInventory inv = new ItemInventory(filterStack, 9, ""); ItemInventory inv = new ItemInventory(filterStack, 9, "");
for (int i = 0; i < inv.getSizeInventory(); i++) for (int i = 0; i < inv.getSizeInventory(); i++) {
{
ItemStack stack = inv.getStackInSlot(i); ItemStack stack = inv.getStackInSlot(i);
if (stack.isEmpty()) if (stack.isEmpty()) {
{
continue; continue;
} }
@ -96,32 +87,27 @@ public class ItemFluidRouterFilter extends Item implements IFluidFilterProvider,
} }
@Override @Override
public IFluidFilter getOutputFluidFilter(ItemStack filterStack, TileEntity tile, IFluidHandler handler) public IFluidFilter getOutputFluidFilter(ItemStack filterStack, TileEntity tile, IFluidHandler handler) {
{
IFluidFilter testFilter; IFluidFilter testFilter;
switch (filterStack.getMetadata()) switch (filterStack.getMetadata()) {
{ case 0:
case 0: testFilter = new RoutingFluidFilter();
testFilter = new RoutingFluidFilter(); break;
break;
default: default:
testFilter = new RoutingFluidFilter(); testFilter = new RoutingFluidFilter();
} }
List<ItemStack> filteredList = new ArrayList<>(); List<ItemStack> filteredList = new ArrayList<>();
ItemInventory inv = new ItemInventory(filterStack, 9, ""); //TODO: Change to grab the filter from the Item later. ItemInventory inv = new ItemInventory(filterStack, 9, ""); //TODO: Change to grab the filter from the Item later.
for (int i = 0; i < inv.getSizeInventory(); i++) for (int i = 0; i < inv.getSizeInventory(); i++) {
{
ItemStack stack = inv.getStackInSlot(i); ItemStack stack = inv.getStackInSlot(i);
if (stack.isEmpty()) if (stack.isEmpty()) {
{
continue; continue;
} }
ItemStack ghostStack = GhostItemHelper.getStackFromGhost(stack); ItemStack ghostStack = GhostItemHelper.getStackFromGhost(stack);
if (ghostStack.isEmpty()) if (ghostStack.isEmpty()) {
{
ghostStack.setCount(Integer.MAX_VALUE); ghostStack.setCount(Integer.MAX_VALUE);
} }
@ -133,14 +119,12 @@ public class ItemFluidRouterFilter extends Item implements IFluidFilterProvider,
} }
@Override @Override
public void gatherVariants(@Nonnull Int2ObjectMap<String> variants) public void gatherVariants(@Nonnull Int2ObjectMap<String> variants) {
{
variants.put(0, "type=exact"); variants.put(0, "type=exact");
} }
@Override @Override
public ItemStack getContainedStackForItem(ItemStack filterStack, ItemStack keyStack) public ItemStack getContainedStackForItem(ItemStack filterStack, ItemStack keyStack) {
{
ItemStack copyStack = keyStack.copy(); ItemStack copyStack = keyStack.copy();
GhostItemHelper.setItemGhostAmount(copyStack, 0); GhostItemHelper.setItemGhostAmount(copyStack, 0);
copyStack.setCount(1); copyStack.setCount(1);

106
src/main/java/WayofTime/bloodmagic/item/routing/ItemRouterFilter.java
View file

@ -22,12 +22,10 @@ import javax.annotation.Nonnull;
import java.util.ArrayList; import java.util.ArrayList;
import java.util.List; import java.util.List;
public class ItemRouterFilter extends Item implements IItemFilterProvider, IVariantProvider public class ItemRouterFilter extends Item implements IItemFilterProvider, IVariantProvider {
{ public static String[] names = {"exact", "ignoreNBT", "modItems", "oreDict"};
public static String[] names = { "exact", "ignoreNBT", "modItems", "oreDict" };
public ItemRouterFilter() public ItemRouterFilter() {
{
super(); super();
setTranslationKey(BloodMagic.MODID + ".itemFilter."); setTranslationKey(BloodMagic.MODID + ".itemFilter.");
@ -36,15 +34,13 @@ public class ItemRouterFilter extends Item implements IItemFilterProvider, IVari
} }
@Override @Override
public String getTranslationKey(ItemStack stack) public String getTranslationKey(ItemStack stack) {
{
return super.getTranslationKey(stack) + names[stack.getItemDamage()]; return super.getTranslationKey(stack) + names[stack.getItemDamage()];
} }
@Override @Override
@SideOnly(Side.CLIENT) @SideOnly(Side.CLIENT)
public void getSubItems(CreativeTabs creativeTab, NonNullList<ItemStack> list) public void getSubItems(CreativeTabs creativeTab, NonNullList<ItemStack> list) {
{
if (!isInCreativeTab(creativeTab)) if (!isInCreativeTab(creativeTab))
return; return;
@ -54,44 +50,39 @@ public class ItemRouterFilter extends Item implements IItemFilterProvider, IVari
@Override @Override
@SideOnly(Side.CLIENT) @SideOnly(Side.CLIENT)
public void addInformation(ItemStack stack, World world, List<String> tooltip, ITooltipFlag flag) public void addInformation(ItemStack stack, World world, List<String> tooltip, ITooltipFlag flag) {
{
tooltip.add(TextHelper.localize("tooltip.bloodmagic.itemFilter." + names[stack.getItemDamage()])); tooltip.add(TextHelper.localize("tooltip.bloodmagic.itemFilter." + names[stack.getItemDamage()]));
super.addInformation(stack, world, tooltip, flag); super.addInformation(stack, world, tooltip, flag);
} }
@Override @Override
public IItemFilter getInputItemFilter(ItemStack filterStack, TileEntity tile, IItemHandler handler) public IItemFilter getInputItemFilter(ItemStack filterStack, TileEntity tile, IItemHandler handler) {
{
IItemFilter testFilter = new TestItemFilter(); IItemFilter testFilter = new TestItemFilter();
switch (filterStack.getMetadata()) switch (filterStack.getMetadata()) {
{ case 0:
case 0: testFilter = new TestItemFilter();
testFilter = new TestItemFilter(); break;
break; case 1:
case 1: testFilter = new IgnoreNBTItemFilter();
testFilter = new IgnoreNBTItemFilter(); break;
break; case 2:
case 2: testFilter = new ModIdItemFilter();
testFilter = new ModIdItemFilter(); break;
break; case 3:
case 3: testFilter = new OreDictItemFilter();
testFilter = new OreDictItemFilter(); break;
break;
default: default:
testFilter = new DefaultItemFilter(); testFilter = new DefaultItemFilter();
} }
List<ItemStack> filteredList = new ArrayList<>(); List<ItemStack> filteredList = new ArrayList<>();
ItemInventory inv = new ItemInventory(filterStack, 9, ""); ItemInventory inv = new ItemInventory(filterStack, 9, "");
for (int i = 0; i < inv.getSizeInventory(); i++) for (int i = 0; i < inv.getSizeInventory(); i++) {
{
ItemStack stack = inv.getStackInSlot(i); ItemStack stack = inv.getStackInSlot(i);
if (stack.isEmpty()) if (stack.isEmpty()) {
{
continue; continue;
} }
@ -105,42 +96,37 @@ public class ItemRouterFilter extends Item implements IItemFilterProvider, IVari
} }
@Override @Override
public IItemFilter getOutputItemFilter(ItemStack filterStack, TileEntity tile, IItemHandler handler) public IItemFilter getOutputItemFilter(ItemStack filterStack, TileEntity tile, IItemHandler handler) {
{
IItemFilter testFilter; IItemFilter testFilter;
switch (filterStack.getMetadata()) switch (filterStack.getMetadata()) {
{ case 0:
case 0: testFilter = new TestItemFilter();
testFilter = new TestItemFilter(); break;
break; case 1:
case 1: testFilter = new IgnoreNBTItemFilter();
testFilter = new IgnoreNBTItemFilter(); break;
break; case 2:
case 2: testFilter = new ModIdItemFilter();
testFilter = new ModIdItemFilter(); break;
break; case 3:
case 3: testFilter = new OreDictItemFilter();
testFilter = new OreDictItemFilter(); break;
break;
default: default:
testFilter = new DefaultItemFilter(); testFilter = new DefaultItemFilter();
} }
List<ItemStack> filteredList = new ArrayList<>(); List<ItemStack> filteredList = new ArrayList<>();
ItemInventory inv = new ItemInventory(filterStack, 9, ""); //TODO: Change to grab the filter from the Item later. ItemInventory inv = new ItemInventory(filterStack, 9, ""); //TODO: Change to grab the filter from the Item later.
for (int i = 0; i < inv.getSizeInventory(); i++) for (int i = 0; i < inv.getSizeInventory(); i++) {
{
ItemStack stack = inv.getStackInSlot(i); ItemStack stack = inv.getStackInSlot(i);
if (stack.isEmpty()) if (stack.isEmpty()) {
{
continue; continue;
} }
ItemStack ghostStack = GhostItemHelper.getStackFromGhost(stack); ItemStack ghostStack = GhostItemHelper.getStackFromGhost(stack);
if (ghostStack.isEmpty()) if (ghostStack.isEmpty()) {
{
ghostStack.setCount(Integer.MAX_VALUE); ghostStack.setCount(Integer.MAX_VALUE);
} }
@ -152,8 +138,7 @@ public class ItemRouterFilter extends Item implements IItemFilterProvider, IVari
} }
@Override @Override
public void gatherVariants(@Nonnull Int2ObjectMap<String> variants) public void gatherVariants(@Nonnull Int2ObjectMap<String> variants) {
{
variants.put(0, "type=exact"); variants.put(0, "type=exact");
variants.put(1, "type=ignorenbt"); variants.put(1, "type=ignorenbt");
variants.put(2, "type=moditems"); variants.put(2, "type=moditems");
@ -161,8 +146,7 @@ public class ItemRouterFilter extends Item implements IItemFilterProvider, IVari
} }
@Override @Override
public ItemStack getContainedStackForItem(ItemStack filterStack, ItemStack keyStack) public ItemStack getContainedStackForItem(ItemStack filterStack, ItemStack keyStack) {
{
ItemStack copyStack = keyStack.copy(); ItemStack copyStack = keyStack.copy();
GhostItemHelper.setItemGhostAmount(copyStack, 0); GhostItemHelper.setItemGhostAmount(copyStack, 0);
copyStack.setCount(1); copyStack.setCount(1);

39
src/main/java/WayofTime/bloodmagic/item/sigil/ItemSigilBloodLight.java
View file

@ -15,23 +15,19 @@ import net.minecraft.util.math.BlockPos;
import net.minecraft.util.math.RayTraceResult; import net.minecraft.util.math.RayTraceResult;
import net.minecraft.world.World; import net.minecraft.world.World;
public class ItemSigilBloodLight extends ItemSigilBase public class ItemSigilBloodLight extends ItemSigilBase {
{ public ItemSigilBloodLight() {
public ItemSigilBloodLight()
{
super("blood_light", 10); super("blood_light", 10);
} }
@Override @Override
public void onUpdate(ItemStack stack, World worldIn, Entity entityIn, int itemSlot, boolean isSelected) public void onUpdate(ItemStack stack, World worldIn, Entity entityIn, int itemSlot, boolean isSelected) {
{
if (getCooldownRemainder(stack) > 0) if (getCooldownRemainder(stack) > 0)
reduceCooldown(stack); reduceCooldown(stack);
} }
@Override @Override
public ActionResult<ItemStack> onItemRightClick(World world, EntityPlayer player, EnumHand hand) public ActionResult<ItemStack> onItemRightClick(World world, EntityPlayer player, EnumHand hand) {
{
ItemStack stack = player.getHeldItem(hand); ItemStack stack = player.getHeldItem(hand);
if (stack.getItem() instanceof ISigil.Holding) if (stack.getItem() instanceof ISigil.Holding)
stack = ((Holding) stack.getItem()).getHeldItem(stack, player); stack = ((Holding) stack.getItem()).getHeldItem(stack, player);
@ -43,15 +39,12 @@ public class ItemSigilBloodLight extends ItemSigilBase
if (getCooldownRemainder(stack) > 0) if (getCooldownRemainder(stack) > 0)
return super.onItemRightClick(world, player, hand); return super.onItemRightClick(world, player, hand);
if (mop != null && mop.typeOfHit == RayTraceResult.Type.BLOCK) if (mop != null && mop.typeOfHit == RayTraceResult.Type.BLOCK) {
{
BlockPos blockPos = mop.getBlockPos().offset(mop.sideHit); BlockPos blockPos = mop.getBlockPos().offset(mop.sideHit);
if (world.isAirBlock(blockPos)) if (world.isAirBlock(blockPos)) {
{
world.setBlockState(blockPos, RegistrarBloodMagicBlocks.BLOOD_LIGHT.getDefaultState()); world.setBlockState(blockPos, RegistrarBloodMagicBlocks.BLOOD_LIGHT.getDefaultState());
if (!world.isRemote) if (!world.isRemote) {
{
SoulNetwork network = NetworkHelper.getSoulNetwork(getBinding(stack)); SoulNetwork network = NetworkHelper.getSoulNetwork(getBinding(stack));
network.syphonAndDamage(player, SoulTicket.item(stack, world, player, getLpUsed())); network.syphonAndDamage(player, SoulTicket.item(stack, world, player, getLpUsed()));
} }
@ -59,10 +52,8 @@ public class ItemSigilBloodLight extends ItemSigilBase
player.swingArm(hand); player.swingArm(hand);
return super.onItemRightClick(world, player, hand); return super.onItemRightClick(world, player, hand);
} }
} else } else {
{ if (!world.isRemote) {
if (!world.isRemote)
{
SoulNetwork network = NetworkHelper.getSoulNetwork(getBinding(stack)); SoulNetwork network = NetworkHelper.getSoulNetwork(getBinding(stack));
world.spawnEntity(new EntityBloodLight(world, player)); world.spawnEntity(new EntityBloodLight(world, player));
network.syphonAndDamage(player, SoulTicket.item(stack, world, player, getLpUsed())); network.syphonAndDamage(player, SoulTicket.item(stack, world, player, getLpUsed()));
@ -74,23 +65,19 @@ public class ItemSigilBloodLight extends ItemSigilBase
} }
@Override @Override
public boolean shouldCauseReequipAnimation(ItemStack oldStack, ItemStack newStack, boolean slotChanged) public boolean shouldCauseReequipAnimation(ItemStack oldStack, ItemStack newStack, boolean slotChanged) {
{
return oldStack.getItem() != newStack.getItem(); return oldStack.getItem() != newStack.getItem();
} }
public int getCooldownRemainder(ItemStack stack) public int getCooldownRemainder(ItemStack stack) {
{
return NBTHelper.checkNBT(stack).getTagCompound().getInteger(Constants.NBT.TICKS_REMAINING); return NBTHelper.checkNBT(stack).getTagCompound().getInteger(Constants.NBT.TICKS_REMAINING);
} }
public void reduceCooldown(ItemStack stack) public void reduceCooldown(ItemStack stack) {
{
NBTHelper.checkNBT(stack).getTagCompound().setInteger(Constants.NBT.TICKS_REMAINING, getCooldownRemainder(stack) - 1); NBTHelper.checkNBT(stack).getTagCompound().setInteger(Constants.NBT.TICKS_REMAINING, getCooldownRemainder(stack) - 1);
} }
public void resetCooldown(ItemStack stack) public void resetCooldown(ItemStack stack) {
{
NBTHelper.checkNBT(stack).getTagCompound().setInteger(Constants.NBT.TICKS_REMAINING, 10); NBTHelper.checkNBT(stack).getTagCompound().setInteger(Constants.NBT.TICKS_REMAINING, 10);
} }
} }

2
src/main/java/WayofTime/bloodmagic/item/sigil/ItemSigilTeleposition.java
View file

@ -71,8 +71,8 @@ public class ItemSigilTeleposition extends ItemSigilBase {
TeleportQueue.getInstance().addITeleport(new Teleports.TeleportToDim(blockPos, player, bindingOwnerID, world, tile.getWorld().provider.getDimension(), true)); TeleportQueue.getInstance().addITeleport(new Teleports.TeleportToDim(blockPos, player, bindingOwnerID, world, tile.getWorld().provider.getDimension(), true));
} }
} }
}
} }
}
return super.onItemRightClick(world, player, hand); return super.onItemRightClick(world, player, hand);
} }

3
src/main/java/WayofTime/bloodmagic/item/soul/ItemMonsterSoul.java
View file

@ -104,7 +104,8 @@ public class ItemMonsterSoul extends ItemEnum.Variant<ItemMonsterSoul.WillType>
CORROSIVE, CORROSIVE,
DESTRUCTIVE, DESTRUCTIVE,
VENGEFUL, VENGEFUL,
STEADFAST,; STEADFAST,
;
@Nonnull @Nonnull
@Override @Override

21
src/main/java/WayofTime/bloodmagic/item/soul/ItemSentientBow.java
View file

@ -44,12 +44,12 @@ import java.util.Locale;
public class ItemSentientBow extends ItemBow implements IMultiWillTool, ISentientTool, IVariantProvider//, IMeshProvider public class ItemSentientBow extends ItemBow implements IMultiWillTool, ISentientTool, IVariantProvider//, IMeshProvider
{ {
public static int[] soulBracket = new int[] {16, 60, 200, 400, 1000, 2000, 4000}; public static int[] soulBracket = new int[]{16, 60, 200, 400, 1000, 2000, 4000};
public static double[] defaultDamageAdded = new double[] {0.25, 0.5, 0.75, 1, 1.25, 1.5, 1.75}; public static double[] defaultDamageAdded = new double[]{0.25, 0.5, 0.75, 1, 1.25, 1.5, 1.75};
public static float[] velocityAdded = new float[] {0.25f, 0.5f, 0.75f, 1, 1.25f, 1.5f, 1.75f}; public static float[] velocityAdded = new float[]{0.25f, 0.5f, 0.75f, 1, 1.25f, 1.5f, 1.75f};
public static double[] soulDrainPerSwing = new double[] {0.05, 0.1, 0.2, 0.4, 0.75, 1, 1.5}; //TODO public static double[] soulDrainPerSwing = new double[]{0.05, 0.1, 0.2, 0.4, 0.75, 1, 1.5}; //TODO
public static double[] soulDrop = new double[] {2, 4, 7, 10, 13, 16, 24}; public static double[] soulDrop = new double[]{2, 4, 7, 10, 13, 16, 24};
public static double[] staticDrop = new double[] {1, 1, 2, 3, 3, 3, 4}; public static double[] staticDrop = new double[]{1, 1, 2, 3, 3, 3, 4};
public static float soullessShotVelocity = 2.5F; public static float soullessShotVelocity = 2.5F;
public ItemSentientBow() { public ItemSentientBow() {
@ -331,7 +331,7 @@ public class ItemSentientBow extends ItemBow implements IMultiWillTool, ISentien
player.addStat(StatList.getObjectUseStats(this)); player.addStat(StatList.getObjectUseStats(this));
return entityArrow; return entityArrow;
} }
@Override @Override
public void onPlayerStoppedUsing(ItemStack stack, World world, EntityLivingBase entityLiving, int timeLeft) { public void onPlayerStoppedUsing(ItemStack stack, World world, EntityLivingBase entityLiving, int timeLeft) {
if (entityLiving instanceof EntityPlayer) { if (entityLiving instanceof EntityPlayer) {
@ -361,9 +361,9 @@ public class ItemSentientBow extends ItemBow implements IMultiWillTool, ISentien
ItemArrow itemarrow = ((ItemArrow) (itemstack.getItem() instanceof ItemArrow ? itemstack.getItem() : Items.ARROW)); ItemArrow itemarrow = ((ItemArrow) (itemstack.getItem() instanceof ItemArrow ? itemstack.getItem() : Items.ARROW));
EntityArrow entityArrow; EntityArrow entityArrow;
double amount = (this.getDropOfActivatedBow(stack) * world.rand.nextDouble() + this.getStaticDropOfActivatedBow(stack)); double amount = (this.getDropOfActivatedBow(stack) * world.rand.nextDouble() + this.getStaticDropOfActivatedBow(stack));
float newArrowVelocity = arrowVelocity * getVelocityOfArrow(stack); float newArrowVelocity = arrowVelocity * getVelocityOfArrow(stack);
if (getLevel(PlayerDemonWillHandler.getTotalDemonWill(type, player)) <= 0) { if (getLevel(PlayerDemonWillHandler.getTotalDemonWill(type, player)) <= 0) {
entityArrow = itemarrow.createArrow(world, itemstack, entityLiving); entityArrow = itemarrow.createArrow(world, itemstack, entityLiving);
} else if (itemarrow == Items.ARROW) { } else if (itemarrow == Items.ARROW) {
@ -382,8 +382,7 @@ public class ItemSentientBow extends ItemBow implements IMultiWillTool, ISentien
entityArrow.shoot(player, player.rotationPitch, player.rotationYaw, 0.0F, newArrowVelocity, 1.0F); entityArrow.shoot(player, player.rotationPitch, player.rotationYaw, 0.0F, newArrowVelocity, 1.0F);
if (Float.compare(getVelocityOfArrow(stack), soullessShotVelocity) < Float.MIN_NORMAL) if (Float.compare(getVelocityOfArrow(stack), soullessShotVelocity) < Float.MIN_NORMAL) {
{
world.playSound(null, player.getPosition(), SoundEvents.BLOCK_FIRE_EXTINGUISH, SoundCategory.NEUTRAL, 0.4F, 1.0F); world.playSound(null, player.getPosition(), SoundEvents.BLOCK_FIRE_EXTINGUISH, SoundCategory.NEUTRAL, 0.4F, 1.0F);
} }

159
src/main/java/WayofTime/bloodmagic/item/soulBreath/ItemFlightScroll.java
View file

@ -32,31 +32,26 @@ import WayofTime.bloodmagic.iface.IActivatable;
import WayofTime.bloodmagic.util.Constants; import WayofTime.bloodmagic.util.Constants;
import WayofTime.bloodmagic.util.helper.NBTHelper; import WayofTime.bloodmagic.util.helper.NBTHelper;
public class ItemFlightScroll extends ItemSoulBreathContainer implements IMeshProvider, IActivatable public class ItemFlightScroll extends ItemSoulBreathContainer implements IMeshProvider, IActivatable {
{
public static Map<EntityPlayer, Map<EntityLivingBase, Vector3d>> floatMap = new HashMap<EntityPlayer, Map<EntityLivingBase, Vector3d>>(); public static Map<EntityPlayer, Map<EntityLivingBase, Vector3d>> floatMap = new HashMap<EntityPlayer, Map<EntityLivingBase, Vector3d>>();
public static Map<EntityPlayer, EntityLivingBase> heldEntityMap = new HashMap<EntityPlayer, EntityLivingBase>(); public static Map<EntityPlayer, EntityLivingBase> heldEntityMap = new HashMap<EntityPlayer, EntityLivingBase>();
public static Map<EntityPlayer, Double> heldEntityOffsetMap = new HashMap<EntityPlayer, Double>(); public static Map<EntityPlayer, Double> heldEntityOffsetMap = new HashMap<EntityPlayer, Double>();
//TODO: A lot of this stuff could be moved to a toggle-able variant //TODO: A lot of this stuff could be moved to a toggle-able variant
public ItemFlightScroll() public ItemFlightScroll() {
{
super(); super();
setTranslationKey(BloodMagic.MODID + ".icarusScroll"); setTranslationKey(BloodMagic.MODID + ".icarusScroll");
setCreativeTab(BloodMagic.TAB_BM); setCreativeTab(BloodMagic.TAB_BM);
} }
@Override @Override
public boolean getActivated(ItemStack stack) public boolean getActivated(ItemStack stack) {
{
return !stack.isEmpty() && NBTHelper.checkNBT(stack).getTagCompound().getBoolean(Constants.NBT.ACTIVATED); return !stack.isEmpty() && NBTHelper.checkNBT(stack).getTagCompound().getBoolean(Constants.NBT.ACTIVATED);
} }
@Override @Override
public ItemStack setActivatedState(ItemStack stack, boolean activated) public ItemStack setActivatedState(ItemStack stack, boolean activated) {
{ if (!stack.isEmpty()) {
if (!stack.isEmpty())
{
NBTHelper.checkNBT(stack).getTagCompound().setBoolean(Constants.NBT.ACTIVATED, activated); NBTHelper.checkNBT(stack).getTagCompound().setBoolean(Constants.NBT.ACTIVATED, activated);
return stack; return stack;
} }
@ -65,27 +60,20 @@ public class ItemFlightScroll extends ItemSoulBreathContainer implements IMeshPr
} }
@Override @Override
public ActionResult<ItemStack> onItemRightClick(World world, EntityPlayer player, EnumHand hand) public ActionResult<ItemStack> onItemRightClick(World world, EntityPlayer player, EnumHand hand) {
{
ItemStack stack = player.getHeldItem(hand); ItemStack stack = player.getHeldItem(hand);
if (!world.isRemote) if (!world.isRemote) {
{ if (player.isSneaking()) {
if (player.isSneaking()) if (!getActivated(stack)) {
{
if (!getActivated(stack))
{
double drainNeeded = getBreathCostPerSecond(stack); double drainNeeded = getBreathCostPerSecond(stack);
if (this.drainBreath(stack, drainNeeded, false) >= drainNeeded) if (this.drainBreath(stack, drainNeeded, false) >= drainNeeded) {
{
setActivatedState(stack, true); setActivatedState(stack, true);
} }
} else } else {
{
setActivatedState(stack, false); setActivatedState(stack, false);
} }
} else } else {
{
//TODO: Add an effect where it "draws back" like a bow in order to cast Levitation on a mob. //TODO: Add an effect where it "draws back" like a bow in order to cast Levitation on a mob.
//Only Levitated mobs can be grabbed. //Only Levitated mobs can be grabbed.
} }
@ -95,27 +83,21 @@ public class ItemFlightScroll extends ItemSoulBreathContainer implements IMeshPr
} }
@Override @Override
public boolean itemInteractionForEntity(ItemStack stack, EntityPlayer player, EntityLivingBase entity, EnumHand hand) public boolean itemInteractionForEntity(ItemStack stack, EntityPlayer player, EntityLivingBase entity, EnumHand hand) {
{ if (entity.world.isRemote) {
if (entity.world.isRemote)
{
return false; return false;
} }
//TODO: Do check to see if the entity is levitating - will only "ensnare" a mob that is levitating. //TODO: Do check to see if the entity is levitating - will only "ensnare" a mob that is levitating.
if (player.isSneaking()) if (player.isSneaking()) {
{
//TODO: Release entity completely? //TODO: Release entity completely?
removeEntity(player, entity); removeEntity(player, entity);
} else } else {
{
EntityLivingBase heldEntity = getHeldEntity(player); EntityLivingBase heldEntity = getHeldEntity(player);
if (heldEntity != null && heldEntity.equals(entity)) if (heldEntity != null && heldEntity.equals(entity)) {
{
heldEntityMap.remove(player); heldEntityMap.remove(player);
} else } else {
{
holdEntity(player, entity); //Hold the entity so you can place it around yourself where needed. holdEntity(player, entity); //Hold the entity so you can place it around yourself where needed.
} }
} }
@ -124,18 +106,13 @@ public class ItemFlightScroll extends ItemSoulBreathContainer implements IMeshPr
} }
@Override @Override
public void onUpdate(ItemStack stack, World world, Entity entity, int itemSlot, boolean isSelected) public void onUpdate(ItemStack stack, World world, Entity entity, int itemSlot, boolean isSelected) {
{ if (!world.isRemote && entity instanceof EntityPlayerMP && getActivated(stack)) {
if (!world.isRemote && entity instanceof EntityPlayerMP && getActivated(stack)) if (entity.ticksExisted % 20 == 0) {
{
if (entity.ticksExisted % 20 == 0)
{
double drainNeeded = getBreathCostPerSecond(stack); double drainNeeded = getBreathCostPerSecond(stack);
if (this.drainBreath(stack, drainNeeded, false) >= drainNeeded) if (this.drainBreath(stack, drainNeeded, false) >= drainNeeded) {
{
this.drainBreath(stack, drainNeeded, true); this.drainBreath(stack, drainNeeded, true);
} else } else {
{
this.setActivatedState(stack, false); this.setActivatedState(stack, false);
} }
} }
@ -143,40 +120,32 @@ public class ItemFlightScroll extends ItemSoulBreathContainer implements IMeshPr
onEffectUpdate(stack, world, (EntityPlayer) entity, itemSlot, isSelected); onEffectUpdate(stack, world, (EntityPlayer) entity, itemSlot, isSelected);
} }
if (!world.isRemote) if (!world.isRemote) {
{ if (entity instanceof EntityPlayer) {
if (entity instanceof EntityPlayer)
{
EntityPlayer player = (EntityPlayer) entity; EntityPlayer player = (EntityPlayer) entity;
updateHeldEntityPosition(player); updateHeldEntityPosition(player);
if (floatMap.containsKey(player)) if (floatMap.containsKey(player)) {
{
Map<EntityLivingBase, Vector3d> entityMap = floatMap.get(player); Map<EntityLivingBase, Vector3d> entityMap = floatMap.get(player);
if (entityMap == null) if (entityMap == null) {
{
return; return;
} }
List<EntityLivingBase> removalList = new ArrayList<EntityLivingBase>(); List<EntityLivingBase> removalList = new ArrayList<EntityLivingBase>();
for (Entry<EntityLivingBase, Vector3d> entry : entityMap.entrySet()) for (Entry<EntityLivingBase, Vector3d> entry : entityMap.entrySet()) {
{
EntityLivingBase floatingEntity = entry.getKey(); EntityLivingBase floatingEntity = entry.getKey();
if (floatingEntity == null || floatingEntity.isDead || floatingEntity.dimension != player.dimension) if (floatingEntity == null || floatingEntity.isDead || floatingEntity.dimension != player.dimension) {
{
removalList.add(floatingEntity); removalList.add(floatingEntity);
} }
followOwner(player, floatingEntity, entry.getValue()); followOwner(player, floatingEntity, entry.getValue());
} }
for (EntityLivingBase livingEntity : removalList) for (EntityLivingBase livingEntity : removalList) {
{
entityMap.remove(livingEntity); entityMap.remove(livingEntity);
} }
if (entityMap.isEmpty()) if (entityMap.isEmpty()) {
{
floatMap.remove(player); floatMap.remove(player);
} }
@ -185,16 +154,13 @@ public class ItemFlightScroll extends ItemSoulBreathContainer implements IMeshPr
} }
} }
public static boolean updateEntityOffset(EntityPlayer player, EntityLivingBase living, Vector3d updatedOffset) public static boolean updateEntityOffset(EntityPlayer player, EntityLivingBase living, Vector3d updatedOffset) {
{
//TODO: Check if this entity is contained in another player's map to prevent weird things. //TODO: Check if this entity is contained in another player's map to prevent weird things.
if (floatMap.containsKey(player)) if (floatMap.containsKey(player)) {
{
Map<EntityLivingBase, Vector3d> entityMap = floatMap.get(player); Map<EntityLivingBase, Vector3d> entityMap = floatMap.get(player);
entityMap.put(living, updatedOffset); entityMap.put(living, updatedOffset);
return true; return true;
} else } else {
{
Map<EntityLivingBase, Vector3d> entityMap = new HashMap<EntityLivingBase, Vector3d>(); Map<EntityLivingBase, Vector3d> entityMap = new HashMap<EntityLivingBase, Vector3d>();
entityMap.put(living, updatedOffset); entityMap.put(living, updatedOffset);
floatMap.put(player, entityMap); floatMap.put(player, entityMap);
@ -203,28 +169,23 @@ public class ItemFlightScroll extends ItemSoulBreathContainer implements IMeshPr
} }
@Nullable @Nullable
public static EntityLivingBase getHeldEntity(EntityPlayer player) public static EntityLivingBase getHeldEntity(EntityPlayer player) {
{ if (heldEntityMap.containsKey(player)) {
if (heldEntityMap.containsKey(player))
{
return heldEntityMap.get(player); return heldEntityMap.get(player);
} }
return null; return null;
} }
public static double getHeldEntityOffset(EntityPlayer player) public static double getHeldEntityOffset(EntityPlayer player) {
{ if (heldEntityMap.containsKey(player)) {
if (heldEntityMap.containsKey(player))
{
return heldEntityOffsetMap.get(player); return heldEntityOffsetMap.get(player);
} }
return 1; return 1;
} }
public static void holdEntity(EntityPlayer player, EntityLivingBase entityLiving) public static void holdEntity(EntityPlayer player, EntityLivingBase entityLiving) {
{
float distance = player.getDistance(entityLiving); float distance = player.getDistance(entityLiving);
Vec3d lookVec = player.getLookVec(); Vec3d lookVec = player.getLookVec();
heldEntityMap.put(player, entityLiving); heldEntityMap.put(player, entityLiving);
@ -232,41 +193,33 @@ public class ItemFlightScroll extends ItemSoulBreathContainer implements IMeshPr
updateEntityOffset(player, entityLiving, new Vector3d(lookVec.x * distance, lookVec.y * distance, lookVec.z * distance)); updateEntityOffset(player, entityLiving, new Vector3d(lookVec.x * distance, lookVec.y * distance, lookVec.z * distance));
} }
public static void updateHeldEntityPosition(EntityPlayer player) public static void updateHeldEntityPosition(EntityPlayer player) {
{
EntityLivingBase entityLiving = getHeldEntity(player); EntityLivingBase entityLiving = getHeldEntity(player);
if (entityLiving != null) if (entityLiving != null) {
{
double offset = getHeldEntityOffset(player); double offset = getHeldEntityOffset(player);
Vec3d lookVec = player.getLookVec(); Vec3d lookVec = player.getLookVec();
updateEntityOffset(player, entityLiving, new Vector3d(lookVec.x * offset, lookVec.y * offset, lookVec.z * offset)); updateEntityOffset(player, entityLiving, new Vector3d(lookVec.x * offset, lookVec.y * offset, lookVec.z * offset));
} }
} }
public static void removeEntity(EntityPlayer player, EntityLivingBase living) public static void removeEntity(EntityPlayer player, EntityLivingBase living) {
{ if (living == null) {
if (living == null)
{
return; return;
} }
if (floatMap.containsKey(player)) if (floatMap.containsKey(player)) {
{
Map<EntityLivingBase, Vector3d> entityMap = floatMap.get(player); Map<EntityLivingBase, Vector3d> entityMap = floatMap.get(player);
if (entityMap.containsKey(living)) if (entityMap.containsKey(living)) {
{
entityMap.remove(living); entityMap.remove(living);
} }
if (entityMap.isEmpty()) if (entityMap.isEmpty()) {
{
floatMap.remove(player); floatMap.remove(player);
} }
} }
} }
public void followOwner(EntityPlayer owner, EntityLivingBase livingEntity, Vector3d offset) public void followOwner(EntityPlayer owner, EntityLivingBase livingEntity, Vector3d offset) {
{
double offsetX = offset.x; double offsetX = offset.x;
double offsetY = offset.y; double offsetY = offset.y;
double offsetZ = offset.z; double offsetZ = offset.z;
@ -287,40 +240,34 @@ public class ItemFlightScroll extends ItemSoulBreathContainer implements IMeshPr
vec.normalize(); vec.normalize();
if (speed <= 0.00001) if (speed <= 0.00001) {
{
return; return;
} }
livingEntity.setVelocity(vec.x * speed, vec.y * speed, vec.z * speed); livingEntity.setVelocity(vec.x * speed, vec.y * speed, vec.z * speed);
} }
public void onEffectUpdate(ItemStack stack, World world, EntityPlayer player, int itemSlot, boolean isSelected) public void onEffectUpdate(ItemStack stack, World world, EntityPlayer player, int itemSlot, boolean isSelected) {
{
player.addPotionEffect(new PotionEffect(RegistrarBloodMagic.FLIGHT, 2, 0)); player.addPotionEffect(new PotionEffect(RegistrarBloodMagic.FLIGHT, 2, 0));
} }
@Override @Override
public int getMaxBreath(ItemStack stack) public int getMaxBreath(ItemStack stack) {
{
return 20; return 20;
} }
public double getBreathCostPerSecond(ItemStack stack) public double getBreathCostPerSecond(ItemStack stack) {
{
return 0.01; return 0.01;
} }
@Override @Override
@SideOnly(Side.CLIENT) @SideOnly(Side.CLIENT)
public ItemMeshDefinition getMeshDefinition() public ItemMeshDefinition getMeshDefinition() {
{
return new CustomMeshDefinitionActivatable("icarus_scroll"); return new CustomMeshDefinitionActivatable("icarus_scroll");
} }
@Override @Override
public void gatherVariants(Consumer<String> variants) public void gatherVariants(Consumer<String> variants) {
{
variants.accept("active=false"); variants.accept("active=false");
variants.accept("active=true"); variants.accept("active=true");
} }

30
src/main/java/WayofTime/bloodmagic/item/soulBreath/ItemSoulBreathContainer.java
View file

@ -6,33 +6,28 @@ import net.minecraft.nbt.NBTTagCompound;
import WayofTime.bloodmagic.soul.ISoulBreathContainer; import WayofTime.bloodmagic.soul.ISoulBreathContainer;
import WayofTime.bloodmagic.util.Constants; import WayofTime.bloodmagic.util.Constants;
public abstract class ItemSoulBreathContainer extends Item implements ISoulBreathContainer public abstract class ItemSoulBreathContainer extends Item implements ISoulBreathContainer {
{
@Override @Override
public double getBreath(ItemStack stack) public double getBreath(ItemStack stack) {
{
NBTTagCompound tag = stack.getTagCompound(); NBTTagCompound tag = stack.getTagCompound();
return tag.getDouble(Constants.NBT.BREATH); return tag.getDouble(Constants.NBT.BREATH);
} }
@Override @Override
public void setBreath(ItemStack stack, double amount) public void setBreath(ItemStack stack, double amount) {
{
NBTTagCompound tag = stack.getTagCompound(); NBTTagCompound tag = stack.getTagCompound();
tag.setDouble(Constants.NBT.BREATH, amount); tag.setDouble(Constants.NBT.BREATH, amount);
} }
@Override @Override
public double drainBreath(ItemStack stack, double drainAmount, boolean doDrain) public double drainBreath(ItemStack stack, double drainAmount, boolean doDrain) {
{
double breath = getBreath(stack); double breath = getBreath(stack);
double breathDrained = Math.min(drainAmount, breath); double breathDrained = Math.min(drainAmount, breath);
if (doDrain) if (doDrain) {
{
setBreath(stack, breath - breathDrained); setBreath(stack, breath - breathDrained);
} }
@ -40,15 +35,13 @@ public abstract class ItemSoulBreathContainer extends Item implements ISoulBreat
} }
@Override @Override
public double fillBreath(ItemStack stack, double fillAmount, boolean doFill) public double fillBreath(ItemStack stack, double fillAmount, boolean doFill) {
{
double current = this.getBreath(stack); double current = this.getBreath(stack);
double maxBreath = this.getMaxBreath(stack); double maxBreath = this.getMaxBreath(stack);
double filled = Math.min(fillAmount, maxBreath - current); double filled = Math.min(fillAmount, maxBreath - current);
if (doFill) if (doFill) {
{
this.setBreath(stack, filled + current); this.setBreath(stack, filled + current);
} }
@ -56,17 +49,14 @@ public abstract class ItemSoulBreathContainer extends Item implements ISoulBreat
} }
@Override @Override
public boolean showDurabilityBar(ItemStack stack) public boolean showDurabilityBar(ItemStack stack) {
{
return true; return true;
} }
@Override @Override
public double getDurabilityForDisplay(ItemStack stack) public double getDurabilityForDisplay(ItemStack stack) {
{
double maxWill = getMaxBreath(stack); double maxWill = getMaxBreath(stack);
if (maxWill <= 0) if (maxWill <= 0) {
{
return 1; return 1;
} }
return 1.0 - (getBreath(stack) / maxWill); return 1.0 - (getBreath(stack) / maxWill);

24
src/main/java/WayofTime/bloodmagic/item/types/AlchemicVialType.java
View file

@ -6,44 +6,36 @@ import net.minecraft.item.ItemStack;
import javax.annotation.Nonnull; import javax.annotation.Nonnull;
import java.util.Locale; import java.util.Locale;
public enum AlchemicVialType implements ISubItem public enum AlchemicVialType implements ISubItem {
{
BASE(0x2e35ff); BASE(0x2e35ff);
final int potionColour; final int potionColour;
AlchemicVialType(int colour1) AlchemicVialType(int colour1) {
{
potionColour = colour1; potionColour = colour1;
} }
@Nonnull @Nonnull
@Override @Override
public String getInternalName() public String getInternalName() {
{
return name().toLowerCase(Locale.ROOT); return name().toLowerCase(Locale.ROOT);
} }
@Nonnull @Nonnull
@Override @Override
public ItemStack getStack(int count) public ItemStack getStack(int count) {
{
return new ItemStack(RegistrarBloodMagicItems.ALCHEMIC_VIAL, count, ordinal()); return new ItemStack(RegistrarBloodMagicItems.ALCHEMIC_VIAL, count, ordinal());
} }
public int getColourForLayer(int layer) public int getColourForLayer(int layer) {
{ if (layer == 0) {
if (layer == 0)
{
return potionColour; return potionColour;
} }
return -1; return -1;
} }
public static int getColourForLayer(int variant, int layer) public static int getColourForLayer(int variant, int layer) {
{ if (variant >= AlchemicVialType.values().length) {
if (variant >= AlchemicVialType.values().length)
{
return -1; return -1;
} }

3
src/main/java/WayofTime/bloodmagic/item/types/ComponentTypes.java
View file

@ -40,7 +40,8 @@ public enum ComponentTypes implements ISubItem {
CATALYST_POWER_1, CATALYST_POWER_1,
REAGENT_CLAW, REAGENT_CLAW,
REAGENT_BOUNCE, REAGENT_BOUNCE,
REAGENT_FROST,; REAGENT_FROST,
;
@Nonnull @Nonnull
@Override @Override

3
src/main/java/WayofTime/bloodmagic/item/types/ShardType.java
View file

@ -9,7 +9,8 @@ import java.util.Locale;
public enum ShardType implements ISubItem { public enum ShardType implements ISubItem {
WEAK, WEAK,
DEMONIC,; DEMONIC,
;
@Nonnull @Nonnull
@Override @Override

2
src/main/java/WayofTime/bloodmagic/livingArmour/upgrade/LivingArmourUpgradeFallProtect.java
View file

@ -14,7 +14,7 @@ public class LivingArmourUpgradeFallProtect extends LivingArmourUpgrade {
super(level); super(level);
} }
public float getDamageMultiplier() { public float getDamageMultiplier() {
return 1 - protectionLevel[this.level]; return 1 - protectionLevel[this.level];
} }

54
src/main/java/WayofTime/bloodmagic/livingArmour/upgrade/LivingArmourUpgradeSpeed.java
View file

@ -16,45 +16,37 @@ import org.apache.commons.codec.binary.StringUtils;
import java.util.UUID; import java.util.UUID;
public class LivingArmourUpgradeSpeed extends LivingArmourUpgrade public class LivingArmourUpgradeSpeed extends LivingArmourUpgrade {
{ public static final int[] costs = new int[]{3, 7, 13, 26, 42, 60, 90, 130, 180, 250};
public static final int[] costs = new int[] { 3, 7, 13, 26, 42, 60, 90, 130, 180, 250 }; public static final double[] speedModifier = new double[]{0.1, 0.2, 0.3, 0.4, 0.5, 0.7, 0.9, 1.1, 1.3, 1.5};
public static final double[] speedModifier = new double[] { 0.1, 0.2, 0.3, 0.4, 0.5, 0.7, 0.9, 1.1, 1.3, 1.5 }; public static final int[] sprintSpeedTime = new int[]{0, 0, 0, 0, 0, 20, 60, 60, 100, 200};
public static final int[] sprintSpeedTime = new int[] { 0, 0, 0, 0, 0, 20, 60, 60, 100, 200 }; public static final int[] sprintSpeedLevel = new int[]{0, 0, 0, 0, 0, 0, 0, 1, 1, 2};
public static final int[] sprintSpeedLevel = new int[] { 0, 0, 0, 0, 0, 0, 0, 1, 1, 2 }; public static final int[] healthModifier = new int[]{0, 0, 0, 0, 0, 0, 0, 4, 10, 20};
public static final int[] healthModifier = new int[] { 0, 0, 0, 0, 0, 0, 0, 4, 10, 20 }; public static final int[] sprintRegenTime = new int[]{0, 0, 0, 0, 0, 0, 0, 0, 0, 25};
public static final int[] sprintRegenTime = new int[] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 25 };
public LivingArmourUpgradeSpeed(int level) public LivingArmourUpgradeSpeed(int level) {
{
super(level); super(level);
} }
public double getSpeedModifier() public double getSpeedModifier() {
{
return speedModifier[this.level]; return speedModifier[this.level];
} }
@Override @Override
public void onTick(World world, EntityPlayer player, ILivingArmour livingArmour) public void onTick(World world, EntityPlayer player, ILivingArmour livingArmour) {
{ if (player.isSprinting()) {
if (player.isSprinting()) if (sprintSpeedTime[this.level] > 0) {
{
if (sprintSpeedTime[this.level] > 0)
{
player.addPotionEffect(new PotionEffect(MobEffects.SPEED, sprintSpeedTime[this.level], sprintSpeedLevel[this.level], false, false)); player.addPotionEffect(new PotionEffect(MobEffects.SPEED, sprintSpeedTime[this.level], sprintSpeedLevel[this.level], false, false));
} }
if (sprintRegenTime[this.level] > 0 && !player.isPotionActive(MobEffects.REGENERATION)) if (sprintRegenTime[this.level] > 0 && !player.isPotionActive(MobEffects.REGENERATION)) {
{
player.addPotionEffect(new PotionEffect(MobEffects.REGENERATION, sprintRegenTime[this.level], 0, false, false)); player.addPotionEffect(new PotionEffect(MobEffects.REGENERATION, sprintRegenTime[this.level], 0, false, false));
} }
} }
} }
@Override @Override
public Multimap<String, AttributeModifier> getAttributeModifiers() public Multimap<String, AttributeModifier> getAttributeModifiers() {
{
Multimap<String, AttributeModifier> modifierMap = HashMultimap.create(); Multimap<String, AttributeModifier> modifierMap = HashMultimap.create();
// modifierMap.put(SharedMonsterAttributes.movementSpeed.getAttributeUnlocalizedName(), new AttributeModifier(new UUID(895132, 1), "Speed modifier" + 1, speedModifier[this.level], 1)); // modifierMap.put(SharedMonsterAttributes.movementSpeed.getAttributeUnlocalizedName(), new AttributeModifier(new UUID(895132, 1), "Speed modifier" + 1, speedModifier[this.level], 1));
@ -68,38 +60,32 @@ public class LivingArmourUpgradeSpeed extends LivingArmourUpgrade
} }
@Override @Override
public String getUniqueIdentifier() public String getUniqueIdentifier() {
{
return BloodMagic.MODID + ".upgrade.movement"; return BloodMagic.MODID + ".upgrade.movement";
} }
@Override @Override
public int getMaxTier() public int getMaxTier() {
{
return 10; return 10;
} }
@Override @Override
public int getCostOfUpgrade() public int getCostOfUpgrade() {
{
return costs[this.level]; return costs[this.level];
} }
@Override @Override
public void writeToNBT(NBTTagCompound tag) public void writeToNBT(NBTTagCompound tag) {
{
// EMPTY // EMPTY
} }
@Override @Override
public void readFromNBT(NBTTagCompound tag) public void readFromNBT(NBTTagCompound tag) {
{
// EMPTY // EMPTY
} }
@Override @Override
public String getTranslationKey() public String getTranslationKey() {
{
return tooltipBase + "speed"; return tooltipBase + "speed";
} }
} }

39
src/main/java/WayofTime/bloodmagic/proxy/ClientProxy.java
View file

@ -40,22 +40,18 @@ import net.minecraftforge.fml.common.ObfuscationReflectionHelper;
import java.awt.Color; import java.awt.Color;
import java.util.Map; import java.util.Map;
public class ClientProxy extends CommonProxy public class ClientProxy extends CommonProxy {
{
public static DemonWillHolder currentAura = new DemonWillHolder(); public static DemonWillHolder currentAura = new DemonWillHolder();
@Override @Override
public void preInit() public void preInit() {
{
super.preInit(); super.preInit();
OBJLoader.INSTANCE.addDomain(BloodMagic.MODID); OBJLoader.INSTANCE.addDomain(BloodMagic.MODID);
ClientRegistry.bindTileEntitySpecialRenderer(TileInversionPillar.class, new AnimationTESR<TileInversionPillar>() ClientRegistry.bindTileEntitySpecialRenderer(TileInversionPillar.class, new AnimationTESR<TileInversionPillar>() {
{
@Override @Override
public void handleEvents(TileInversionPillar chest, float time, Iterable<Event> pastEvents) public void handleEvents(TileInversionPillar chest, float time, Iterable<Event> pastEvents) {
{
chest.handleEvents(time, pastEvents); chest.handleEvents(time, pastEvents);
} }
}); });
@ -73,8 +69,7 @@ public class ClientProxy extends CommonProxy
} }
@Override @Override
public void registerRenderers() public void registerRenderers() {
{
RenderingRegistry.registerEntityRenderingHandler(EntitySoulSnare.class, new SoulSnareRenderFactory()); RenderingRegistry.registerEntityRenderingHandler(EntitySoulSnare.class, new SoulSnareRenderFactory());
RenderingRegistry.registerEntityRenderingHandler(EntitySentientArrow.class, new SentientArrowRenderFactory()); RenderingRegistry.registerEntityRenderingHandler(EntitySentientArrow.class, new SentientArrowRenderFactory());
RenderingRegistry.registerEntityRenderingHandler(EntityBloodLight.class, new BloodLightRenderFactory()); RenderingRegistry.registerEntityRenderingHandler(EntityBloodLight.class, new BloodLightRenderFactory());
@ -90,18 +85,15 @@ public class ClientProxy extends CommonProxy
} }
@Override @Override
public void init() public void init() {
{
super.init(); super.init();
Minecraft.getMinecraft().getItemColors().registerItemColorHandler((stack, tintIndex) -> Minecraft.getMinecraft().getItemColors().registerItemColorHandler((stack, tintIndex) ->
{ {
try try {
{
if (stack.hasTagCompound() && stack.getTagCompound().hasKey(Constants.NBT.COLOR)) if (stack.hasTagCompound() && stack.getTagCompound().hasKey(Constants.NBT.COLOR))
if (tintIndex == 1) if (tintIndex == 1)
return Color.decode(stack.getTagCompound().getString(Constants.NBT.COLOR)).getRGB(); return Color.decode(stack.getTagCompound().getString(Constants.NBT.COLOR)).getRGB();
} catch (NumberFormatException e) } catch (NumberFormatException e) {
{
return -1; return -1;
} }
return -1; return -1;
@ -130,29 +122,24 @@ public class ClientProxy extends CommonProxy
} }
@Override @Override
public void postInit() public void postInit() {
{
Elements.registerElements(); Elements.registerElements();
} }
private void addElytraLayer() private void addElytraLayer() {
{
RenderManager renderManager = Minecraft.getMinecraft().getRenderManager(); RenderManager renderManager = Minecraft.getMinecraft().getRenderManager();
try try {
{
Map<String, RenderPlayer> skinMap = ObfuscationReflectionHelper.getPrivateValue(RenderManager.class, renderManager, "skinMap", "field_178636_l"); Map<String, RenderPlayer> skinMap = ObfuscationReflectionHelper.getPrivateValue(RenderManager.class, renderManager, "skinMap", "field_178636_l");
skinMap.get("default").addLayer(new LayerBloodElytra(skinMap.get("default"))); skinMap.get("default").addLayer(new LayerBloodElytra(skinMap.get("default")));
skinMap.get("slim").addLayer(new LayerBloodElytra(skinMap.get("slim"))); skinMap.get("slim").addLayer(new LayerBloodElytra(skinMap.get("slim")));
BMLog.DEBUG.info("Elytra layer added"); BMLog.DEBUG.info("Elytra layer added");
} catch (Exception e) } catch (Exception e) {
{
BMLog.DEBUG.error("Failed to set custom Elytra Layer for Elytra Living Armour Upgrade: {}", e.getMessage()); BMLog.DEBUG.error("Failed to set custom Elytra Layer for Elytra Living Armour Upgrade: {}", e.getMessage());
} }
} }
@Override @Override
public IAnimationStateMachine load(ResourceLocation location, ImmutableMap<String, ITimeValue> parameters) public IAnimationStateMachine load(ResourceLocation location, ImmutableMap<String, ITimeValue> parameters) {
{
return ModelLoaderRegistry.loadASM(location, parameters); return ModelLoaderRegistry.loadASM(location, parameters);
} }
} }

114
src/main/java/WayofTime/bloodmagic/registry/ModRecipes.java
View file

@ -70,14 +70,12 @@ import WayofTime.bloodmagic.util.Utils;
import com.google.common.base.Stopwatch; import com.google.common.base.Stopwatch;
public class ModRecipes public class ModRecipes {
{
static ItemStack mundaneLengtheningStack = ComponentTypes.CATALYST_LENGTH_1.getStack(); static ItemStack mundaneLengtheningStack = ComponentTypes.CATALYST_LENGTH_1.getStack();
static ItemStack mundanePowerStack = ComponentTypes.CATALYST_POWER_1.getStack(); static ItemStack mundanePowerStack = ComponentTypes.CATALYST_POWER_1.getStack();
public static void init() public static void init() {
{
initOreDict(); initOreDict();
addFurnaceRecipes(); addFurnaceRecipes();
addAltarRecipes(); addAltarRecipes();
@ -88,8 +86,7 @@ public class ModRecipes
addCompressionHandlers(); addCompressionHandlers();
} }
public static void initOreDict() public static void initOreDict() {
{
OreDictionary.registerOre("dustIron", ComponentTypes.SAND_IRON.getStack()); OreDictionary.registerOre("dustIron", ComponentTypes.SAND_IRON.getStack());
OreDictionary.registerOre("dustGold", ComponentTypes.SAND_GOLD.getStack()); OreDictionary.registerOre("dustGold", ComponentTypes.SAND_GOLD.getStack());
OreDictionary.registerOre("dustCoal", ComponentTypes.SAND_COAL.getStack()); OreDictionary.registerOre("dustCoal", ComponentTypes.SAND_COAL.getStack());
@ -97,19 +94,16 @@ public class ModRecipes
OreDictionary.registerOre("dustSaltpeter", ComponentTypes.SALTPETER.getStack()); OreDictionary.registerOre("dustSaltpeter", ComponentTypes.SALTPETER.getStack());
} }
public static void addFurnaceRecipes() public static void addFurnaceRecipes() {
{
FurnaceRecipes.instance().addSmeltingRecipe(ComponentTypes.SAND_IRON.getStack(), new ItemStack(Items.IRON_INGOT), (float) 0.15); FurnaceRecipes.instance().addSmeltingRecipe(ComponentTypes.SAND_IRON.getStack(), new ItemStack(Items.IRON_INGOT), (float) 0.15);
FurnaceRecipes.instance().addSmeltingRecipe(ComponentTypes.SAND_GOLD.getStack(), new ItemStack(Items.GOLD_INGOT), (float) 0.15); FurnaceRecipes.instance().addSmeltingRecipe(ComponentTypes.SAND_GOLD.getStack(), new ItemStack(Items.GOLD_INGOT), (float) 0.15);
} }
public static void addAltarRecipes() public static void addAltarRecipes() {
{
} }
public static void addAlchemyArrayRecipes() public static void addAlchemyArrayRecipes() {
{
AlchemyArrayRecipeRegistry.registerRecipe(ComponentTypes.REAGENT_BINDING.getStack(), new ItemStack(Items.DIAMOND_SWORD), new AlchemyArrayEffectBinding("boundSword", Utils.setUnbreakable(new ItemStack(RegistrarBloodMagicItems.BOUND_SWORD))), new BindingAlchemyCircleRenderer()); AlchemyArrayRecipeRegistry.registerRecipe(ComponentTypes.REAGENT_BINDING.getStack(), new ItemStack(Items.DIAMOND_SWORD), new AlchemyArrayEffectBinding("boundSword", Utils.setUnbreakable(new ItemStack(RegistrarBloodMagicItems.BOUND_SWORD))), new BindingAlchemyCircleRenderer());
AlchemyArrayRecipeRegistry.registerRecipe(ComponentTypes.REAGENT_BINDING.getStack(), new ItemStack(Items.DIAMOND_AXE), new AlchemyArrayEffectBinding("boundAxe", Utils.setUnbreakable(new ItemStack(RegistrarBloodMagicItems.BOUND_AXE)))); AlchemyArrayRecipeRegistry.registerRecipe(ComponentTypes.REAGENT_BINDING.getStack(), new ItemStack(Items.DIAMOND_AXE), new AlchemyArrayEffectBinding("boundAxe", Utils.setUnbreakable(new ItemStack(RegistrarBloodMagicItems.BOUND_AXE))));
AlchemyArrayRecipeRegistry.registerRecipe(ComponentTypes.REAGENT_BINDING.getStack(), new ItemStack(Items.DIAMOND_PICKAXE), new AlchemyArrayEffectBinding("boundPickaxe", Utils.setUnbreakable(new ItemStack(RegistrarBloodMagicItems.BOUND_PICKAXE)))); AlchemyArrayRecipeRegistry.registerRecipe(ComponentTypes.REAGENT_BINDING.getStack(), new ItemStack(Items.DIAMOND_PICKAXE), new AlchemyArrayEffectBinding("boundPickaxe", Utils.setUnbreakable(new ItemStack(RegistrarBloodMagicItems.BOUND_PICKAXE))));
@ -137,8 +131,7 @@ public class ModRecipes
} }
public static void addCompressionHandlers() public static void addCompressionHandlers() {
{
Stopwatch stopwatch = Stopwatch.createStarted(); Stopwatch stopwatch = Stopwatch.createStarted();
StorageBlockCraftingManager.getInstance().addStorageBlockRecipes(); StorageBlockCraftingManager.getInstance().addStorageBlockRecipes();
@ -151,13 +144,11 @@ public class ModRecipes
BMLog.DEBUG.info("Added compression recipes in {}", stopwatch); BMLog.DEBUG.info("Added compression recipes in {}", stopwatch);
} }
public static void addAlchemyTableRecipes() public static void addAlchemyTableRecipes() {
{
AlchemyTableRecipeRegistry.registerRecipe(new AlchemyTableDyeableRecipe(0, 100, 0, new ItemStack(RegistrarBloodMagicItems.SIGIL_HOLDING))); AlchemyTableRecipeRegistry.registerRecipe(new AlchemyTableDyeableRecipe(0, 100, 0, new ItemStack(RegistrarBloodMagicItems.SIGIL_HOLDING)));
} }
public static void addPotionRecipes() public static void addPotionRecipes() {
{
addPotionRecipe(1000, 1, new ItemStack(Items.GHAST_TEAR), new PotionEffect(MobEffects.REGENERATION, 450)); addPotionRecipe(1000, 1, new ItemStack(Items.GHAST_TEAR), new PotionEffect(MobEffects.REGENERATION, 450));
addPotionRecipe(1000, 1, new ItemStack(Items.GOLDEN_CARROT), new PotionEffect(MobEffects.NIGHT_VISION, 2 * 60 * 20)); addPotionRecipe(1000, 1, new ItemStack(Items.GOLDEN_CARROT), new PotionEffect(MobEffects.NIGHT_VISION, 2 * 60 * 20));
addPotionRecipe(1000, 1, new ItemStack(Items.MAGMA_CREAM), new PotionEffect(MobEffects.FIRE_RESISTANCE, 2 * 60 * 20)); addPotionRecipe(1000, 1, new ItemStack(Items.MAGMA_CREAM), new PotionEffect(MobEffects.FIRE_RESISTANCE, 2 * 60 * 20));
@ -181,8 +172,7 @@ public class ModRecipes
addPotionRecipe(1000, 1, new ItemStack(Items.BEETROOT), new PotionEffect(RegistrarBloodMagic.DEAFNESS, 450)); addPotionRecipe(1000, 1, new ItemStack(Items.BEETROOT), new PotionEffect(RegistrarBloodMagic.DEAFNESS, 450));
} }
public static void addPotionRecipe(int lpDrained, int tier, ItemStack inputStack, PotionEffect baseEffect) public static void addPotionRecipe(int lpDrained, int tier, ItemStack inputStack, PotionEffect baseEffect) {
{
AlchemyTableRecipeRegistry.registerRecipe(new AlchemyTablePotionRecipe(lpDrained, 100, tier, inputStack, baseEffect)); AlchemyTableRecipeRegistry.registerRecipe(new AlchemyTablePotionRecipe(lpDrained, 100, tier, inputStack, baseEffect));
List<ItemStack> lengtheningList = new ArrayList<>(); List<ItemStack> lengtheningList = new ArrayList<>();
@ -196,8 +186,7 @@ public class ModRecipes
AlchemyTableRecipeRegistry.registerRecipe(BMPotionUtils.getPowerAugmentRecipe(lpDrained, 100, tier, powerList, baseEffect, 1)); AlchemyTableRecipeRegistry.registerRecipe(BMPotionUtils.getPowerAugmentRecipe(lpDrained, 100, tier, powerList, baseEffect, 1));
} }
public static void addLivingArmourDowngradeRecipes() public static void addLivingArmourDowngradeRecipes() {
{
String messageBase = "ritual.bloodmagic.downgradeRitual.dialogue."; String messageBase = "ritual.bloodmagic.downgradeRitual.dialogue.";
ItemStack bowStack = new ItemStack(Items.BOW); ItemStack bowStack = new ItemStack(Items.BOW);
@ -211,18 +200,16 @@ public class ModRecipes
ItemStack stringStack = new ItemStack(Items.STRING); ItemStack stringStack = new ItemStack(Items.STRING);
Map<ItemStack, Pair<String, int[]>> dialogueMap = new HashMap<>(); Map<ItemStack, Pair<String, int[]>> dialogueMap = new HashMap<>();
dialogueMap.put(bowStack, Pair.of("bow", new int[] { 1, 100, 300, 500 })); dialogueMap.put(bowStack, Pair.of("bow", new int[]{1, 100, 300, 500}));
dialogueMap.put(bottleStack, Pair.of("quenched", new int[] { 1, 100, 300, 500 })); dialogueMap.put(bottleStack, Pair.of("quenched", new int[]{1, 100, 300, 500}));
dialogueMap.put(swordStack, Pair.of("dulledBlade", new int[] { 1, 100, 300, 500, 700 })); dialogueMap.put(swordStack, Pair.of("dulledBlade", new int[]{1, 100, 300, 500, 700}));
dialogueMap.put(goldenAppleStack, Pair.of("slowHeal", new int[] { 1, 100, 300, 500, 700 })); dialogueMap.put(goldenAppleStack, Pair.of("slowHeal", new int[]{1, 100, 300, 500, 700}));
for (Entry<ItemStack, Pair<String, int[]>> entry : dialogueMap.entrySet()) for (Entry<ItemStack, Pair<String, int[]>> entry : dialogueMap.entrySet()) {
{
ItemStack keyStack = entry.getKey(); ItemStack keyStack = entry.getKey();
String str = entry.getValue().getKey(); String str = entry.getValue().getKey();
Map<Integer, List<ITextComponent>> textMap = new HashMap<>(); Map<Integer, List<ITextComponent>> textMap = new HashMap<>();
for (int tick : entry.getValue().getValue()) for (int tick : entry.getValue().getValue()) {
{
List<ITextComponent> textList = new ArrayList<>(); List<ITextComponent> textList = new ArrayList<>();
textList.add(new TextComponentTranslation("\u00A74%s", new TextComponentTranslation(messageBase + str + "." + tick))); textList.add(new TextComponentTranslation("\u00A74%s", new TextComponentTranslation(messageBase + str + "." + tick)));
textMap.put(tick, textList); textMap.put(tick, textList);
@ -240,8 +227,7 @@ public class ModRecipes
LivingArmourDowngradeRecipeRegistry.registerRecipe(new LivingArmourUpgradeQuenched(0), bottleStack, Items.DRAGON_BREATH); LivingArmourDowngradeRecipeRegistry.registerRecipe(new LivingArmourUpgradeQuenched(0), bottleStack, Items.DRAGON_BREATH);
LivingArmourDowngradeRecipeRegistry.registerRecipe(new LivingArmourUpgradeCrippledArm(0), shieldStack, "gemDiamond"); LivingArmourDowngradeRecipeRegistry.registerRecipe(new LivingArmourUpgradeCrippledArm(0), shieldStack, "gemDiamond");
for (int i = 0; i < 10; i++) for (int i = 0; i < 10; i++) {
{
addRecipeForTieredDowngrade(new LivingArmourUpgradeMeleeDecrease(i), swordStack, i); addRecipeForTieredDowngrade(new LivingArmourUpgradeMeleeDecrease(i), swordStack, i);
addRecipeForTieredDowngrade(new LivingArmourUpgradeSlowHeal(i), goldenAppleStack, i); addRecipeForTieredDowngrade(new LivingArmourUpgradeSlowHeal(i), goldenAppleStack, i);
addRecipeForTieredDowngrade(new LivingArmourUpgradeBattleHungry(i), fleshStack, i); addRecipeForTieredDowngrade(new LivingArmourUpgradeBattleHungry(i), fleshStack, i);
@ -251,39 +237,37 @@ public class ModRecipes
} }
} }
public static void addRecipeForTieredDowngrade(LivingArmourUpgrade upgrade, ItemStack stack, int tier) public static void addRecipeForTieredDowngrade(LivingArmourUpgrade upgrade, ItemStack stack, int tier) {
{ switch (tier) {
switch (tier) case 0:
{ LivingArmourDowngradeRecipeRegistry.registerRecipe(upgrade, stack, "ingotIron", new ItemStack(RegistrarBloodMagicItems.SLATE, 1, 0));
case 0: break;
LivingArmourDowngradeRecipeRegistry.registerRecipe(upgrade, stack, "ingotIron", new ItemStack(RegistrarBloodMagicItems.SLATE, 1, 0)); case 1:
break; LivingArmourDowngradeRecipeRegistry.registerRecipe(upgrade, stack, "dustRedstone", "dustRedstone", "ingotIron", new ItemStack(RegistrarBloodMagicItems.SLATE, 1, 0));
case 1: break;
LivingArmourDowngradeRecipeRegistry.registerRecipe(upgrade, stack, "dustRedstone", "dustRedstone", "ingotIron", new ItemStack(RegistrarBloodMagicItems.SLATE, 1, 0)); case 2:
break; LivingArmourDowngradeRecipeRegistry.registerRecipe(upgrade, stack, "ingotGold", "gemLapis", "gemLapis", new ItemStack(RegistrarBloodMagicItems.SLATE, 1, 1));
case 2: break;
LivingArmourDowngradeRecipeRegistry.registerRecipe(upgrade, stack, "ingotGold", "gemLapis", "gemLapis", new ItemStack(RegistrarBloodMagicItems.SLATE, 1, 1)); case 3:
break; LivingArmourDowngradeRecipeRegistry.registerRecipe(upgrade, stack, Blocks.VINE, "dyeRed", Items.GOLDEN_CARROT, new ItemStack(RegistrarBloodMagicItems.SLATE, 1, 1));
case 3: break;
LivingArmourDowngradeRecipeRegistry.registerRecipe(upgrade, stack, Blocks.VINE, "dyeRed", Items.GOLDEN_CARROT, new ItemStack(RegistrarBloodMagicItems.SLATE, 1, 1)); case 4:
break; LivingArmourDowngradeRecipeRegistry.registerRecipe(upgrade, stack, Items.GOLDEN_APPLE, "treeSapling", "treeSapling", new ItemStack(RegistrarBloodMagicItems.SLATE, 1, 2));
case 4: break;
LivingArmourDowngradeRecipeRegistry.registerRecipe(upgrade, stack, Items.GOLDEN_APPLE, "treeSapling", "treeSapling", new ItemStack(RegistrarBloodMagicItems.SLATE, 1, 2)); case 5:
break; LivingArmourDowngradeRecipeRegistry.registerRecipe(upgrade, stack, Blocks.IRON_BLOCK, Blocks.REDSTONE_BLOCK, new ItemStack(RegistrarBloodMagicItems.SLATE, 1, 2));
case 5: break;
LivingArmourDowngradeRecipeRegistry.registerRecipe(upgrade, stack, Blocks.IRON_BLOCK, Blocks.REDSTONE_BLOCK, new ItemStack(RegistrarBloodMagicItems.SLATE, 1, 2)); case 6:
break; LivingArmourDowngradeRecipeRegistry.registerRecipe(upgrade, stack, Blocks.IRON_BLOCK, Blocks.GLOWSTONE, "ingotGold", "ingotGold", new ItemStack(RegistrarBloodMagicItems.SLATE, 1, 3));
case 6: break;
LivingArmourDowngradeRecipeRegistry.registerRecipe(upgrade, stack, Blocks.IRON_BLOCK, Blocks.GLOWSTONE, "ingotGold", "ingotGold", new ItemStack(RegistrarBloodMagicItems.SLATE, 1, 3)); case 7:
break; LivingArmourDowngradeRecipeRegistry.registerRecipe(upgrade, stack, Blocks.GOLD_BLOCK, Blocks.LAPIS_BLOCK, "gemDiamond", new ItemStack(RegistrarBloodMagicItems.SLATE, 1, 3));
case 7: break;
LivingArmourDowngradeRecipeRegistry.registerRecipe(upgrade, stack, Blocks.GOLD_BLOCK, Blocks.LAPIS_BLOCK, "gemDiamond", new ItemStack(RegistrarBloodMagicItems.SLATE, 1, 3)); case 8:
break; LivingArmourDowngradeRecipeRegistry.registerRecipe(upgrade, stack, Items.DRAGON_BREATH, "gemDiamond", new ItemStack(RegistrarBloodMagicItems.SLATE, 1, 4));
case 8: break;
LivingArmourDowngradeRecipeRegistry.registerRecipe(upgrade, stack, Items.DRAGON_BREATH, "gemDiamond", new ItemStack(RegistrarBloodMagicItems.SLATE, 1, 4)); case 9:
break; LivingArmourDowngradeRecipeRegistry.registerRecipe(upgrade, stack, Items.NETHER_STAR, "gemDiamond", "gemDiamond", new ItemStack(RegistrarBloodMagicItems.SLATE, 1, 4));
case 9:
LivingArmourDowngradeRecipeRegistry.registerRecipe(upgrade, stack, Items.NETHER_STAR, "gemDiamond", "gemDiamond", new ItemStack(RegistrarBloodMagicItems.SLATE, 1, 4));
} }
} }
} }

9
src/main/java/WayofTime/bloodmagic/registry/ModRituals.java
View file

@ -9,11 +9,9 @@ import WayofTime.bloodmagic.ritual.harvest.HarvestHandlerStem;
import WayofTime.bloodmagic.ritual.harvest.HarvestHandlerTall; import WayofTime.bloodmagic.ritual.harvest.HarvestHandlerTall;
import net.minecraft.init.Blocks; import net.minecraft.init.Blocks;
public class ModRituals public class ModRituals {
{
// TODO Move elsewhere // TODO Move elsewhere
public static void initHarvestHandlers() public static void initHarvestHandlers() {
{
HarvestRegistry.registerRangeAmplifier(Blocks.DIAMOND_BLOCK.getDefaultState(), 15); HarvestRegistry.registerRangeAmplifier(Blocks.DIAMOND_BLOCK.getDefaultState(), 15);
HarvestRegistry.registerRangeAmplifier(Blocks.GOLD_BLOCK.getDefaultState(), 10); HarvestRegistry.registerRangeAmplifier(Blocks.GOLD_BLOCK.getDefaultState(), 10);
HarvestRegistry.registerRangeAmplifier(Blocks.IRON_BLOCK.getDefaultState(), 6); HarvestRegistry.registerRangeAmplifier(Blocks.IRON_BLOCK.getDefaultState(), 6);
@ -23,8 +21,7 @@ public class ModRituals
HarvestRegistry.registerHandler(new HarvestHandlerStem()); HarvestRegistry.registerHandler(new HarvestHandlerStem());
} }
public static void initCuttingFluids() public static void initCuttingFluids() {
{
CrushingRegistry.registerCuttingFluid(new CrushingHandlerCuttingFluid(ItemCuttingFluid.FluidType.BASIC.getStack(), 250, 0.5)); CrushingRegistry.registerCuttingFluid(new CrushingHandlerCuttingFluid(ItemCuttingFluid.FluidType.BASIC.getStack(), 250, 0.5));
CrushingRegistry.registerCuttingFluid(new CrushingHandlerCuttingFluid(ItemCuttingFluid.FluidType.EXPLOSIVE.getStack(), 25, 0.05)); CrushingRegistry.registerCuttingFluid(new CrushingHandlerCuttingFluid(ItemCuttingFluid.FluidType.EXPLOSIVE.getStack(), 25, 0.05));
} }

2
src/main/java/WayofTime/bloodmagic/ritual/crushing/ICrushingHandler.java
View file

@ -9,6 +9,8 @@ import javax.annotation.Nonnull;
public interface ICrushingHandler { public interface ICrushingHandler {
@Nonnull @Nonnull
ItemStack getRecipeOutput(ItemStack input, World world, BlockPos pos); ItemStack getRecipeOutput(ItemStack input, World world, BlockPos pos);
int getLpDrain(); int getLpDrain();
double getWillDrain(); double getWillDrain();
} }

2
src/main/java/WayofTime/bloodmagic/ritual/types/RitualAltarBuilder.java
View file

@ -160,7 +160,7 @@ public class RitualAltarBuilder extends Ritual {
} }
/* /*
* *
* These methods are utilities for this ritual. They support both the old * These methods are utilities for this ritual. They support both the old
* forge inventory system, and the new one. * forge inventory system, and the new one.
*/ */

10
src/main/java/WayofTime/bloodmagic/ritual/types/RitualCobblestone.java
View file

@ -53,11 +53,11 @@ public class RitualCobblestone extends Ritual {
alchemyArray.decrStackSize(0, 1); alchemyArray.decrStackSize(0, 1);
world.setBlockToAir(alchemyArray.getPos()); world.setBlockToAir(alchemyArray.getPos());
break; break;
/* /*
* case 4: block = Blocks.end_stone; * case 4: block = Blocks.end_stone;
* alchemyArray.decrStackSize(0, 1); * alchemyArray.decrStackSize(0, 1);
* world.setBlockToAir(alchemyArray.getPos()); break; * world.setBlockToAir(alchemyArray.getPos()); break;
*/ */
default: default:
break; break;
} }

18
src/main/java/WayofTime/bloodmagic/ritual/types/RitualCrushing.java
View file

@ -120,18 +120,18 @@ public class RitualCrushing extends Ritual {
ItemStack copyStack = checkStack.copy(); ItemStack copyStack = checkStack.copy();
for (ICrushingHandler handler : CrushingRegistry.getCrushingHandlerList()) { for (ICrushingHandler handler : CrushingRegistry.getCrushingHandlerList()) {
int lpDrain = handler.getLpDrain(); int lpDrain = handler.getLpDrain();
double willDrain = handler.getWillDrain(); double willDrain = handler.getWillDrain();
if (corrosiveWill < willDrain || currentEssence < lpDrain + getRefreshCost()) { if (corrosiveWill < willDrain || currentEssence < lpDrain + getRefreshCost()) {
continue; continue;
} }
ItemStack result = handler.getRecipeOutput(copyStack, world, pos); ItemStack result = handler.getRecipeOutput(copyStack, world, pos);
if (result.isEmpty()) { if (result.isEmpty()) {
continue; continue;
} }
if (tile != null) { if (tile != null) {
result = Utils.insertStackIntoTile(result, tile, EnumFacing.DOWN); result = Utils.insertStackIntoTile(result, tile, EnumFacing.DOWN);

104
src/main/java/WayofTime/bloodmagic/ritual/types/RitualCrystalSplit.java
View file

@ -17,21 +17,17 @@ import WayofTime.bloodmagic.soul.EnumDemonWillType;
import WayofTime.bloodmagic.tile.TileDemonCrystal; import WayofTime.bloodmagic.tile.TileDemonCrystal;
@RitualRegister("crystal_split") @RitualRegister("crystal_split")
public class RitualCrystalSplit extends Ritual public class RitualCrystalSplit extends Ritual {
{ public RitualCrystalSplit() {
public RitualCrystalSplit()
{
super("ritualCrystalSplit", 0, 20000, "ritual." + BloodMagic.MODID + ".crystalSplitRitual"); super("ritualCrystalSplit", 0, 20000, "ritual." + BloodMagic.MODID + ".crystalSplitRitual");
} }
@Override @Override
public void performRitual(IMasterRitualStone masterRitualStone) public void performRitual(IMasterRitualStone masterRitualStone) {
{
World world = masterRitualStone.getWorldObj(); World world = masterRitualStone.getWorldObj();
int currentEssence = masterRitualStone.getOwnerNetwork().getCurrentEssence(); int currentEssence = masterRitualStone.getOwnerNetwork().getCurrentEssence();
if (currentEssence < getRefreshCost()) if (currentEssence < getRefreshCost()) {
{
masterRitualStone.getOwnerNetwork().causeNausea(); masterRitualStone.getOwnerNetwork().causeNausea();
return; return;
} }
@ -41,16 +37,14 @@ public class RitualCrystalSplit extends Ritual
BlockPos rawPos = pos.up(2); BlockPos rawPos = pos.up(2);
TileEntity tile = world.getTileEntity(rawPos); TileEntity tile = world.getTileEntity(rawPos);
if (!(tile instanceof TileDemonCrystal) || ((TileDemonCrystal) tile).getType() != EnumDemonWillType.DEFAULT) if (!(tile instanceof TileDemonCrystal) || ((TileDemonCrystal) tile).getType() != EnumDemonWillType.DEFAULT) {
{
return; return;
} }
IBlockState rawState = world.getBlockState(rawPos); IBlockState rawState = world.getBlockState(rawPos);
TileDemonCrystal rawTile = (TileDemonCrystal) tile; TileDemonCrystal rawTile = (TileDemonCrystal) tile;
if (rawTile.crystalCount >= 5) if (rawTile.crystalCount >= 5) {
{
BlockPos vengefulPos = pos.offset(rotateFacing(EnumFacing.NORTH, direction)).up(); BlockPos vengefulPos = pos.offset(rotateFacing(EnumFacing.NORTH, direction)).up();
BlockPos corrosivePos = pos.offset(rotateFacing(EnumFacing.EAST, direction)).up(); BlockPos corrosivePos = pos.offset(rotateFacing(EnumFacing.EAST, direction)).up();
BlockPos steadfastPos = pos.offset(rotateFacing(EnumFacing.SOUTH, direction)).up(); BlockPos steadfastPos = pos.offset(rotateFacing(EnumFacing.SOUTH, direction)).up();
@ -62,50 +56,38 @@ public class RitualCrystalSplit extends Ritual
int destructiveCrystals = 0; int destructiveCrystals = 0;
tile = world.getTileEntity(vengefulPos); tile = world.getTileEntity(vengefulPos);
if (tile instanceof TileDemonCrystal && ((TileDemonCrystal) tile).getType() == EnumDemonWillType.VENGEFUL && ((TileDemonCrystal) tile).crystalCount < 7) if (tile instanceof TileDemonCrystal && ((TileDemonCrystal) tile).getType() == EnumDemonWillType.VENGEFUL && ((TileDemonCrystal) tile).crystalCount < 7) {
{
vengefulCrystals = ((TileDemonCrystal) tile).crystalCount; vengefulCrystals = ((TileDemonCrystal) tile).crystalCount;
} else if (!(tile instanceof TileDemonCrystal) && world.isAirBlock(vengefulPos)) } else if (!(tile instanceof TileDemonCrystal) && world.isAirBlock(vengefulPos)) {
{
// #donothing, no point setting the crystal to 0 again // #donothing, no point setting the crystal to 0 again
} else } else {
{
return; return;
} }
tile = world.getTileEntity(corrosivePos); tile = world.getTileEntity(corrosivePos);
if (tile instanceof TileDemonCrystal && ((TileDemonCrystal) tile).getType() == EnumDemonWillType.CORROSIVE && ((TileDemonCrystal) tile).crystalCount < 7) if (tile instanceof TileDemonCrystal && ((TileDemonCrystal) tile).getType() == EnumDemonWillType.CORROSIVE && ((TileDemonCrystal) tile).crystalCount < 7) {
{
corrosiveCrystals = ((TileDemonCrystal) tile).crystalCount; corrosiveCrystals = ((TileDemonCrystal) tile).crystalCount;
} else if (!(tile instanceof TileDemonCrystal) && world.isAirBlock(corrosivePos)) } else if (!(tile instanceof TileDemonCrystal) && world.isAirBlock(corrosivePos)) {
{
} else } else {
{
return; return;
} }
tile = world.getTileEntity(steadfastPos); tile = world.getTileEntity(steadfastPos);
if (tile instanceof TileDemonCrystal && ((TileDemonCrystal) tile).getType() == EnumDemonWillType.STEADFAST && ((TileDemonCrystal) tile).crystalCount < 7) if (tile instanceof TileDemonCrystal && ((TileDemonCrystal) tile).getType() == EnumDemonWillType.STEADFAST && ((TileDemonCrystal) tile).crystalCount < 7) {
{
steadfastCrystals = ((TileDemonCrystal) tile).crystalCount; steadfastCrystals = ((TileDemonCrystal) tile).crystalCount;
} else if (!(tile instanceof TileDemonCrystal) && world.isAirBlock(steadfastPos)) } else if (!(tile instanceof TileDemonCrystal) && world.isAirBlock(steadfastPos)) {
{
} else } else {
{
return; return;
} }
tile = world.getTileEntity(destructivePos); tile = world.getTileEntity(destructivePos);
if (tile instanceof TileDemonCrystal && ((TileDemonCrystal) tile).getType() == EnumDemonWillType.DESTRUCTIVE && ((TileDemonCrystal) tile).crystalCount < 7) if (tile instanceof TileDemonCrystal && ((TileDemonCrystal) tile).getType() == EnumDemonWillType.DESTRUCTIVE && ((TileDemonCrystal) tile).crystalCount < 7) {
{
destructiveCrystals = ((TileDemonCrystal) tile).crystalCount; destructiveCrystals = ((TileDemonCrystal) tile).crystalCount;
} else if (!(tile instanceof TileDemonCrystal) && world.isAirBlock(destructivePos)) } else if (!(tile instanceof TileDemonCrystal) && world.isAirBlock(destructivePos)) {
{
} else } else {
{
return; return;
} }
@ -120,29 +102,24 @@ public class RitualCrystalSplit extends Ritual
} }
} }
public EnumFacing rotateFacing(EnumFacing facing, EnumFacing rotation) public EnumFacing rotateFacing(EnumFacing facing, EnumFacing rotation) {
{ switch (rotation) {
switch (rotation) case EAST:
{ return facing.rotateY();
case EAST: case SOUTH:
return facing.rotateY(); return facing.rotateY().rotateY();
case SOUTH: case WEST:
return facing.rotateY().rotateY(); return facing.rotateYCCW();
case WEST: case NORTH:
return facing.rotateYCCW(); default:
case NORTH: return facing;
default:
return facing;
} }
} }
public void growCrystal(World world, BlockPos pos, EnumDemonWillType type, int currentCrystalCount) public void growCrystal(World world, BlockPos pos, EnumDemonWillType type, int currentCrystalCount) {
{ if (currentCrystalCount <= 0) {
if (currentCrystalCount <= 0)
{
world.setBlockState(pos, RegistrarBloodMagicBlocks.DEMON_CRYSTAL.getStateFromMeta(type.ordinal()), 3); world.setBlockState(pos, RegistrarBloodMagicBlocks.DEMON_CRYSTAL.getStateFromMeta(type.ordinal()), 3);
} else } else {
{
TileDemonCrystal tile = (TileDemonCrystal) world.getTileEntity(pos); TileDemonCrystal tile = (TileDemonCrystal) world.getTileEntity(pos);
tile.crystalCount++; tile.crystalCount++;
tile.markDirty(); tile.markDirty();
@ -152,20 +129,17 @@ public class RitualCrystalSplit extends Ritual
} }
@Override @Override
public int getRefreshTime() public int getRefreshTime() {
{
return 20; return 20;
} }
@Override @Override
public int getRefreshCost() public int getRefreshCost() {
{
return 1000; return 1000;
} }
@Override @Override
public void gatherComponents(Consumer<RitualComponent> components) public void gatherComponents(Consumer<RitualComponent> components) {
{
addRune(components, 0, 0, -1, EnumRuneType.FIRE); addRune(components, 0, 0, -1, EnumRuneType.FIRE);
addRune(components, 1, 0, 0, EnumRuneType.EARTH); addRune(components, 1, 0, 0, EnumRuneType.EARTH);
addRune(components, 0, 0, 1, EnumRuneType.WATER); addRune(components, 0, 0, 1, EnumRuneType.WATER);
@ -177,14 +151,12 @@ public class RitualCrystalSplit extends Ritual
} }
@Override @Override
public Ritual getNewCopy() public Ritual getNewCopy() {
{
return new RitualCrystalSplit(); return new RitualCrystalSplit();
} }
@Override @Override
public ITextComponent[] provideInformationOfRitualToPlayer(EntityPlayer player) public ITextComponent[] provideInformationOfRitualToPlayer(EntityPlayer player) {
{ return new ITextComponent[]{new TextComponentTranslation(this.getTranslationKey() + ".info")};
return new ITextComponent[] { new TextComponentTranslation(this.getTranslationKey() + ".info") };
} }
} }

69
src/main/java/WayofTime/bloodmagic/ritual/types/RitualEllipsoid.java
View file

@ -17,16 +17,14 @@ import net.minecraftforge.items.IItemHandler;
import java.util.function.Consumer; import java.util.function.Consumer;
@RitualRegister("ellipsoid") @RitualRegister("ellipsoid")
public class RitualEllipsoid extends Ritual public class RitualEllipsoid extends Ritual {
{
public static final String SPHEROID_RANGE = "spheroidRange"; public static final String SPHEROID_RANGE = "spheroidRange";
public static final String CHEST_RANGE = "chest"; public static final String CHEST_RANGE = "chest";
private boolean cached = false; private boolean cached = false;
private BlockPos currentPos; //Offset private BlockPos currentPos; //Offset
public RitualEllipsoid() public RitualEllipsoid() {
{
super("ritualEllipsoid", 0, 20000, "ritual." + BloodMagic.MODID + ".ellipseRitual"); super("ritualEllipsoid", 0, 20000, "ritual." + BloodMagic.MODID + ".ellipseRitual");
addBlockRange(SPHEROID_RANGE, new AreaDescriptor.Rectangle(new BlockPos(-10, -10, -10), new BlockPos(11, 11, 11))); addBlockRange(SPHEROID_RANGE, new AreaDescriptor.Rectangle(new BlockPos(-10, -10, -10), new BlockPos(11, 11, 11)));
addBlockRange(CHEST_RANGE, new AreaDescriptor.Rectangle(new BlockPos(0, 1, 0), 1)); addBlockRange(CHEST_RANGE, new AreaDescriptor.Rectangle(new BlockPos(0, 1, 0), 1));
@ -36,8 +34,7 @@ public class RitualEllipsoid extends Ritual
} }
@Override @Override
public void performRitual(IMasterRitualStone masterRitualStone) public void performRitual(IMasterRitualStone masterRitualStone) {
{
World world = masterRitualStone.getWorldObj(); World world = masterRitualStone.getWorldObj();
int currentEssence = masterRitualStone.getOwnerNetwork().getCurrentEssence(); int currentEssence = masterRitualStone.getOwnerNetwork().getCurrentEssence();
@ -45,8 +42,7 @@ public class RitualEllipsoid extends Ritual
AreaDescriptor chestRange = masterRitualStone.getBlockRange(CHEST_RANGE); AreaDescriptor chestRange = masterRitualStone.getBlockRange(CHEST_RANGE);
TileEntity tileInventory = world.getTileEntity(chestRange.getContainedPositions(masterPos).get(0)); TileEntity tileInventory = world.getTileEntity(chestRange.getContainedPositions(masterPos).get(0));
if (currentEssence < getRefreshCost()) if (currentEssence < getRefreshCost()) {
{
masterRitualStone.getOwnerNetwork().causeNausea(); masterRitualStone.getOwnerNetwork().causeNausea();
return; return;
} }
@ -60,20 +56,16 @@ public class RitualEllipsoid extends Ritual
int minZ = (int) (masterPos.getZ() - sphereBB.minZ); int minZ = (int) (masterPos.getZ() - sphereBB.minZ);
int maxZ = (int) (sphereBB.maxZ - masterPos.getZ()) - 1; int maxZ = (int) (sphereBB.maxZ - masterPos.getZ()) - 1;
if (tileInventory != null) if (tileInventory != null) {
{ if (tileInventory.hasCapability(CapabilityItemHandler.ITEM_HANDLER_CAPABILITY, EnumFacing.DOWN)) {
if (tileInventory.hasCapability(CapabilityItemHandler.ITEM_HANDLER_CAPABILITY, EnumFacing.DOWN))
{
IItemHandler itemHandler = tileInventory.getCapability(CapabilityItemHandler.ITEM_HANDLER_CAPABILITY, EnumFacing.DOWN); IItemHandler itemHandler = tileInventory.getCapability(CapabilityItemHandler.ITEM_HANDLER_CAPABILITY, EnumFacing.DOWN);
if (itemHandler.getSlots() <= 0) if (itemHandler.getSlots() <= 0) {
{
return; return;
} }
int blockSlot = -1; int blockSlot = -1;
for (int invSlot = 0; invSlot < itemHandler.getSlots(); invSlot++) for (int invSlot = 0; invSlot < itemHandler.getSlots(); invSlot++) {
{
ItemStack stack = itemHandler.extractItem(invSlot, 1, true); ItemStack stack = itemHandler.extractItem(invSlot, 1, true);
if (stack.isEmpty() || !(stack.getItem() instanceof ItemBlock)) if (stack.isEmpty() || !(stack.getItem() instanceof ItemBlock))
continue; continue;
@ -82,8 +74,7 @@ public class RitualEllipsoid extends Ritual
break; break;
} }
if (blockSlot == -1) if (blockSlot == -1) {
{
return; return;
} }
@ -95,8 +86,7 @@ public class RitualEllipsoid extends Ritual
int i = -minY; int i = -minY;
int k = -minZ; int k = -minZ;
if (currentPos != null) if (currentPos != null) {
{
j = currentPos.getY(); j = currentPos.getY();
i = Math.min(xR, Math.max(-minX, currentPos.getX())); i = Math.min(xR, Math.max(-minX, currentPos.getX()));
k = Math.min(zR, Math.max(-minZ, currentPos.getZ())); k = Math.min(zR, Math.max(-minZ, currentPos.getZ()));
@ -104,25 +94,19 @@ public class RitualEllipsoid extends Ritual
int checks = 0; int checks = 0;
int maxChecks = 100; int maxChecks = 100;
while (j <= maxY) while (j <= maxY) {
{ while (i <= maxX) {
while (i <= maxX) while (k <= maxZ) {
{
while (k <= maxZ)
{
checks++; checks++;
if (checks >= maxChecks) if (checks >= maxChecks) {
{
this.currentPos = new BlockPos(i, j, k); this.currentPos = new BlockPos(i, j, k);
return; return;
} }
if (checkIfEllipsoidShell(xR, yR, zR, i, j, k)) if (checkIfEllipsoidShell(xR, yR, zR, i, j, k)) {
{
BlockPos newPos = masterPos.add(i, j, k); BlockPos newPos = masterPos.add(i, j, k);
// //
if (!world.getBlockState(newPos).getBlock().isReplaceable(world, newPos)) if (!world.getBlockState(newPos).getBlock().isReplaceable(world, newPos)) {
{
k++; k++;
continue; continue;
} }
@ -156,11 +140,9 @@ public class RitualEllipsoid extends Ritual
} }
} }
public boolean checkIfEllipsoidShell(int xR, int yR, int zR, int xOff, int yOff, int zOff) public boolean checkIfEllipsoidShell(int xR, int yR, int zR, int xOff, int yOff, int zOff) {
{
//Checking shell in the x-direction //Checking shell in the x-direction
if (!checkIfEllipsoid(xR, yR, zR, xOff, yOff, zOff)) if (!checkIfEllipsoid(xR, yR, zR, xOff, yOff, zOff)) {
{
return false; return false;
} }
@ -186,21 +168,18 @@ public class RitualEllipsoid extends Ritual
// return false; // return false;
} }
public boolean checkIfEllipsoid(float xR, float yR, float zR, float xOff, float yOff, float zOff) public boolean checkIfEllipsoid(float xR, float yR, float zR, float xOff, float yOff, float zOff) {
{
float possOffset = 0.5f; float possOffset = 0.5f;
return xOff * xOff / ((xR + possOffset) * (xR + possOffset)) + yOff * yOff / ((yR + possOffset) * (yR + possOffset)) + zOff * zOff / ((zR + possOffset) * (zR + possOffset)) <= 1; return xOff * xOff / ((xR + possOffset) * (xR + possOffset)) + yOff * yOff / ((yR + possOffset) * (yR + possOffset)) + zOff * zOff / ((zR + possOffset) * (zR + possOffset)) <= 1;
} }
@Override @Override
public int getRefreshCost() public int getRefreshCost() {
{
return 5; return 5;
} }
@Override @Override
public int getRefreshTime() public int getRefreshTime() {
{
return 1; return 1;
} }
@ -212,8 +191,7 @@ public class RitualEllipsoid extends Ritual
// } // }
@Override @Override
public void gatherComponents(Consumer<RitualComponent> components) public void gatherComponents(Consumer<RitualComponent> components) {
{
addCornerRunes(components, 1, 0, EnumRuneType.DUSK); addCornerRunes(components, 1, 0, EnumRuneType.DUSK);
addRune(components, 4, 0, 0, EnumRuneType.FIRE); addRune(components, 4, 0, 0, EnumRuneType.FIRE);
@ -254,8 +232,7 @@ public class RitualEllipsoid extends Ritual
} }
@Override @Override
public Ritual getNewCopy() public Ritual getNewCopy() {
{
return new RitualEllipsoid(); return new RitualEllipsoid();
} }
} }

108
src/main/java/WayofTime/bloodmagic/routing/RoutingFluidFilter.java
View file

@ -15,54 +15,42 @@ import net.minecraftforge.fluids.FluidUtil;
import net.minecraftforge.fluids.capability.IFluidHandler; import net.minecraftforge.fluids.capability.IFluidHandler;
import net.minecraftforge.fluids.capability.IFluidTankProperties; import net.minecraftforge.fluids.capability.IFluidTankProperties;
public class RoutingFluidFilter implements IFluidFilter public class RoutingFluidFilter implements IFluidFilter {
{
protected List<FluidStack> requestList; protected List<FluidStack> requestList;
protected TileEntity accessedTile; protected TileEntity accessedTile;
protected IFluidHandler fluidHandler; protected IFluidHandler fluidHandler;
@Override @Override
public void initializeFilter(List<ItemStack> filteredList, TileEntity tile, IFluidHandler fluidHandler, boolean isFilterOutput) public void initializeFilter(List<ItemStack> filteredList, TileEntity tile, IFluidHandler fluidHandler, boolean isFilterOutput) {
{
this.accessedTile = tile; this.accessedTile = tile;
this.fluidHandler = fluidHandler; this.fluidHandler = fluidHandler;
if (isFilterOutput) if (isFilterOutput) {
{
//The requestList contains a list of how much can be extracted. //The requestList contains a list of how much can be extracted.
requestList = new ArrayList<>(); requestList = new ArrayList<>();
for (ItemStack filterStack : filteredList) for (ItemStack filterStack : filteredList) {
{
FluidStack fluidFilterStack = getFluidStackFromItemStack(filterStack); FluidStack fluidFilterStack = getFluidStackFromItemStack(filterStack);
if (fluidFilterStack != null) if (fluidFilterStack != null) {
{
requestList.add(fluidFilterStack); requestList.add(fluidFilterStack);
} }
} }
IFluidTankProperties[] properties = fluidHandler.getTankProperties(); IFluidTankProperties[] properties = fluidHandler.getTankProperties();
for (IFluidTankProperties property : properties) for (IFluidTankProperties property : properties) {
{
FluidStack containedStack = property.getContents(); FluidStack containedStack = property.getContents();
if (containedStack != null) if (containedStack != null) {
{ for (FluidStack fluidFilterStack : requestList) {
for (FluidStack fluidFilterStack : requestList) if (doStacksMatch(fluidFilterStack, containedStack)) {
{
if (doStacksMatch(fluidFilterStack, containedStack))
{
fluidFilterStack.amount = Math.max(fluidFilterStack.amount - containedStack.amount, 0); fluidFilterStack.amount = Math.max(fluidFilterStack.amount - containedStack.amount, 0);
} }
} }
} }
} }
} else } else {
{
requestList = new ArrayList<>(); requestList = new ArrayList<>();
for (ItemStack filterStack : filteredList) for (ItemStack filterStack : filteredList) {
{
FluidStack fluidFilterStack = getFluidStackFromItemStack(filterStack); FluidStack fluidFilterStack = getFluidStackFromItemStack(filterStack);
if (fluidFilterStack != null) if (fluidFilterStack != null) {
{
fluidFilterStack.amount *= -1; fluidFilterStack.amount *= -1;
requestList.add(fluidFilterStack); requestList.add(fluidFilterStack);
} }
@ -70,15 +58,11 @@ public class RoutingFluidFilter implements IFluidFilter
IFluidTankProperties[] properties = fluidHandler.getTankProperties(); IFluidTankProperties[] properties = fluidHandler.getTankProperties();
for (IFluidTankProperties property : properties) for (IFluidTankProperties property : properties) {
{
FluidStack containedStack = property.getContents(); FluidStack containedStack = property.getContents();
if (containedStack != null) if (containedStack != null) {
{ for (FluidStack fluidFilterStack : requestList) {
for (FluidStack fluidFilterStack : requestList) if (doStacksMatch(fluidFilterStack, containedStack)) {
{
if (doStacksMatch(fluidFilterStack, containedStack))
{
fluidFilterStack.amount += containedStack.amount; fluidFilterStack.amount += containedStack.amount;
} }
} }
@ -91,20 +75,16 @@ public class RoutingFluidFilter implements IFluidFilter
* Gives the remainder~ * Gives the remainder~
*/ */
@Override @Override
public FluidStack transferStackThroughOutputFilter(FluidStack fluidStack) public FluidStack transferStackThroughOutputFilter(FluidStack fluidStack) {
{
int allowedAmount = 0; int allowedAmount = 0;
for (FluidStack filterStack : requestList) for (FluidStack filterStack : requestList) {
{ if (doStacksMatch(filterStack, fluidStack)) {
if (doStacksMatch(filterStack, fluidStack))
{
allowedAmount = Math.min(filterStack.amount, fluidStack.amount); allowedAmount = Math.min(filterStack.amount, fluidStack.amount);
break; break;
} }
} }
if (allowedAmount <= 0) if (allowedAmount <= 0) {
{
return fluidStack; return fluidStack;
} }
@ -113,14 +93,11 @@ public class RoutingFluidFilter implements IFluidFilter
copyStack.amount = fluidStack.amount - filledAmount; copyStack.amount = fluidStack.amount - filledAmount;
Iterator<FluidStack> itr = requestList.iterator(); Iterator<FluidStack> itr = requestList.iterator();
while (itr.hasNext()) while (itr.hasNext()) {
{
FluidStack filterStack = itr.next(); FluidStack filterStack = itr.next();
if (doStacksMatch(filterStack, copyStack)) if (doStacksMatch(filterStack, copyStack)) {
{
filterStack.amount -= filledAmount; filterStack.amount -= filledAmount;
if (filterStack.amount <= 0) if (filterStack.amount <= 0) {
{
itr.remove(); itr.remove();
} }
} }
@ -134,13 +111,10 @@ public class RoutingFluidFilter implements IFluidFilter
} }
@Override @Override
public int transferThroughInputFilter(IFluidFilter outputFilter, int maxTransfer) public int transferThroughInputFilter(IFluidFilter outputFilter, int maxTransfer) {
{ for (FluidStack filterFluidStack : requestList) {
for (FluidStack filterFluidStack : requestList)
{
int allowedAmount = Math.min(filterFluidStack.amount, maxTransfer); int allowedAmount = Math.min(filterFluidStack.amount, maxTransfer);
if (allowedAmount <= 0) if (allowedAmount <= 0) {
{
continue; continue;
} }
@ -152,8 +126,7 @@ public class RoutingFluidFilter implements IFluidFilter
FluidStack remainderStack = outputFilter.transferStackThroughOutputFilter(drainStack); FluidStack remainderStack = outputFilter.transferStackThroughOutputFilter(drainStack);
int drained = remainderStack == null ? copyStack.amount : (copyStack.amount - remainderStack.amount); int drained = remainderStack == null ? copyStack.amount : (copyStack.amount - remainderStack.amount);
if (drained > 0) if (drained > 0) {
{
drainStack.amount = drained; drainStack.amount = drained;
fluidHandler.drain(drainStack, true); fluidHandler.drain(drainStack, true);
@ -161,14 +134,11 @@ public class RoutingFluidFilter implements IFluidFilter
} }
Iterator<FluidStack> itr = requestList.iterator(); Iterator<FluidStack> itr = requestList.iterator();
while (itr.hasNext()) while (itr.hasNext()) {
{
FluidStack filterStack = itr.next(); FluidStack filterStack = itr.next();
if (doStacksMatch(filterStack, copyStack)) if (doStacksMatch(filterStack, copyStack)) {
{
filterStack.amount -= drained; filterStack.amount -= drained;
if (filterStack.amount <= 0) if (filterStack.amount <= 0) {
{
itr.remove(); itr.remove();
} }
} }
@ -186,12 +156,9 @@ public class RoutingFluidFilter implements IFluidFilter
} }
@Override @Override
public boolean doesStackMatchFilter(FluidStack testStack) public boolean doesStackMatchFilter(FluidStack testStack) {
{ for (FluidStack filterStack : requestList) {
for (FluidStack filterStack : requestList) if (doStacksMatch(filterStack, testStack)) {
{
if (doStacksMatch(filterStack, testStack))
{
return true; return true;
} }
} }
@ -200,17 +167,14 @@ public class RoutingFluidFilter implements IFluidFilter
} }
@Override @Override
public boolean doStacksMatch(FluidStack filterStack, FluidStack testStack) public boolean doStacksMatch(FluidStack filterStack, FluidStack testStack) {
{
return testStack != null && filterStack.getFluid() == testStack.getFluid(); return testStack != null && filterStack.getFluid() == testStack.getFluid();
} }
@Nullable @Nullable
public static FluidStack getFluidStackFromItemStack(ItemStack inputStack) public static FluidStack getFluidStackFromItemStack(ItemStack inputStack) {
{
boolean isEmpty = false; boolean isEmpty = false;
if (inputStack.getCount() == 0) if (inputStack.getCount() == 0) {
{
isEmpty = true; isEmpty = true;
inputStack.setCount(1); inputStack.setCount(1);
} }

3
src/main/java/WayofTime/bloodmagic/soul/ISoulBreathContainer.java
View file

@ -2,8 +2,7 @@ package WayofTime.bloodmagic.soul;
import net.minecraft.item.ItemStack; import net.minecraft.item.ItemStack;
public interface ISoulBreathContainer public interface ISoulBreathContainer {
{
double getBreath(ItemStack stack); double getBreath(ItemStack stack);
void setBreath(ItemStack stack, double amount); void setBreath(ItemStack stack, double amount);

90
src/main/java/WayofTime/bloodmagic/tile/TileAlchemyArray.java
View file

@ -17,8 +17,7 @@ import net.minecraft.util.math.AxisAlignedBB;
import net.minecraftforge.fml.relauncher.Side; import net.minecraftforge.fml.relauncher.Side;
import net.minecraftforge.fml.relauncher.SideOnly; import net.minecraftforge.fml.relauncher.SideOnly;
public class TileAlchemyArray extends TileInventory implements ITickable, IAlchemyArray public class TileAlchemyArray extends TileInventory implements ITickable, IAlchemyArray {
{
public boolean isActive = false; public boolean isActive = false;
public int activeCounter = 0; public int activeCounter = 0;
public EnumFacing rotation = EnumFacing.HORIZONTALS[0]; public EnumFacing rotation = EnumFacing.HORIZONTALS[0];
@ -28,22 +27,18 @@ public class TileAlchemyArray extends TileInventory implements ITickable, IAlche
public AlchemyArrayEffect arrayEffect; public AlchemyArrayEffect arrayEffect;
private boolean doDropIngredients = true; private boolean doDropIngredients = true;
public TileAlchemyArray() public TileAlchemyArray() {
{
super(2, "alchemyArray"); super(2, "alchemyArray");
} }
public void onEntityCollidedWithBlock(IBlockState state, Entity entity) public void onEntityCollidedWithBlock(IBlockState state, Entity entity) {
{ if (arrayEffect != null) {
if (arrayEffect != null)
{
arrayEffect.onEntityCollidedWithBlock(this, getWorld(), pos, state, entity); arrayEffect.onEntityCollidedWithBlock(this, getWorld(), pos, state, entity);
} }
} }
@Override @Override
public void deserialize(NBTTagCompound tagCompound) public void deserialize(NBTTagCompound tagCompound) {
{
super.deserialize(tagCompound); super.deserialize(tagCompound);
this.isActive = tagCompound.getBoolean("isActive"); this.isActive = tagCompound.getBoolean("isActive");
this.activeCounter = tagCompound.getInteger("activeCounter"); this.activeCounter = tagCompound.getInteger("activeCounter");
@ -51,23 +46,20 @@ public class TileAlchemyArray extends TileInventory implements ITickable, IAlche
if (!tagCompound.hasKey("doDropIngredients")) //Check if the array is old if (!tagCompound.hasKey("doDropIngredients")) //Check if the array is old
{ {
this.doDropIngredients = true; this.doDropIngredients = true;
} else } else {
{
this.doDropIngredients = tagCompound.getBoolean("doDropIngredients"); this.doDropIngredients = tagCompound.getBoolean("doDropIngredients");
} }
this.rotation = EnumFacing.HORIZONTALS[tagCompound.getInteger(Constants.NBT.DIRECTION)]; this.rotation = EnumFacing.HORIZONTALS[tagCompound.getInteger(Constants.NBT.DIRECTION)];
NBTTagCompound arrayTag = tagCompound.getCompoundTag("arrayTag"); NBTTagCompound arrayTag = tagCompound.getCompoundTag("arrayTag");
arrayEffect = AlchemyArrayRecipeRegistry.getAlchemyArrayEffect(key); arrayEffect = AlchemyArrayRecipeRegistry.getAlchemyArrayEffect(key);
if (arrayEffect != null) if (arrayEffect != null) {
{
arrayEffect.readFromNBT(arrayTag); arrayEffect.readFromNBT(arrayTag);
} }
} }
@Override @Override
public NBTTagCompound serialize(NBTTagCompound tagCompound) public NBTTagCompound serialize(NBTTagCompound tagCompound) {
{
super.serialize(tagCompound); super.serialize(tagCompound);
tagCompound.setBoolean("isActive", isActive); tagCompound.setBoolean("isActive", isActive);
tagCompound.setInteger("activeCounter", activeCounter); tagCompound.setInteger("activeCounter", activeCounter);
@ -76,8 +68,7 @@ public class TileAlchemyArray extends TileInventory implements ITickable, IAlche
tagCompound.setInteger(Constants.NBT.DIRECTION, rotation.getHorizontalIndex()); tagCompound.setInteger(Constants.NBT.DIRECTION, rotation.getHorizontalIndex());
NBTTagCompound arrayTag = new NBTTagCompound(); NBTTagCompound arrayTag = new NBTTagCompound();
if (arrayEffect != null) if (arrayEffect != null) {
{
arrayEffect.writeToNBT(arrayTag); arrayEffect.writeToNBT(arrayTag);
} }
tagCompound.setTag("arrayTag", arrayTag); tagCompound.setTag("arrayTag", arrayTag);
@ -86,25 +77,20 @@ public class TileAlchemyArray extends TileInventory implements ITickable, IAlche
} }
@Override @Override
public int getInventoryStackLimit() public int getInventoryStackLimit() {
{
return 1; return 1;
} }
//Use this to prevent the Array from dropping items - useful for arrays that need to "consume" ingredients well before the effect. //Use this to prevent the Array from dropping items - useful for arrays that need to "consume" ingredients well before the effect.
public void setItemDrop(boolean dropItems) public void setItemDrop(boolean dropItems) {
{
this.doDropIngredients = dropItems; this.doDropIngredients = dropItems;
} }
@Override @Override
public void update() public void update() {
{ if (isActive && attemptCraft()) {
if (isActive && attemptCraft())
{
activeCounter++; activeCounter++;
} else } else {
{
isActive = false; isActive = false;
doDropIngredients = true; doDropIngredients = true;
activeCounter = 0; activeCounter = 0;
@ -119,61 +105,48 @@ public class TileAlchemyArray extends TileInventory implements ITickable, IAlche
* This occurs when the block is destroyed. * This occurs when the block is destroyed.
*/ */
@Override @Override
public void dropItems() public void dropItems() {
{ if (arrayEffect == null || doDropIngredients) {
if (arrayEffect == null || doDropIngredients)
{
super.dropItems(); super.dropItems();
} }
} }
public boolean attemptCraft() public boolean attemptCraft() {
{
AlchemyArrayEffect effect = AlchemyArrayRecipeRegistry.getAlchemyArrayEffect(this.getStackInSlot(0), this.getStackInSlot(1)); AlchemyArrayEffect effect = AlchemyArrayRecipeRegistry.getAlchemyArrayEffect(this.getStackInSlot(0), this.getStackInSlot(1));
if (effect != null) if (effect != null) {
{ if (arrayEffect == null) {
if (arrayEffect == null)
{
arrayEffect = effect; arrayEffect = effect;
key = effect.getKey(); key = effect.getKey();
} else } else {
{
String effectKey = effect.getKey(); String effectKey = effect.getKey();
if (effectKey.equals(key)) if (effectKey.equals(key)) {
{
//Good! Moving on. //Good! Moving on.
} else } else {
{
//Something has changed, therefore we have to move our stuffs. //Something has changed, therefore we have to move our stuffs.
//TODO: Add an AlchemyArrayEffect.onBreak(); ? //TODO: Add an AlchemyArrayEffect.onBreak(); ?
arrayEffect = effect; arrayEffect = effect;
key = effect.getKey(); key = effect.getKey();
} }
} }
} else } else {
{
RecipeAlchemyArray recipe = BloodMagicAPI.INSTANCE.getRecipeRegistrar().getAlchemyArray(getStackInSlot(0), getStackInSlot(1)); RecipeAlchemyArray recipe = BloodMagicAPI.INSTANCE.getRecipeRegistrar().getAlchemyArray(getStackInSlot(0), getStackInSlot(1));
if (recipe == null) if (recipe == null)
return false; return false;
AlchemyArrayEffect newEffect = new AlchemyArrayEffectCraftingNew(recipe); AlchemyArrayEffect newEffect = new AlchemyArrayEffectCraftingNew(recipe);
if (arrayEffect == null) if (arrayEffect == null) {
{
arrayEffect = newEffect; arrayEffect = newEffect;
key = newEffect.key; key = newEffect.key;
} else if (!newEffect.key.equals(key)) } else if (!newEffect.key.equals(key)) {
{
arrayEffect = newEffect; arrayEffect = newEffect;
key = newEffect.key; key = newEffect.key;
} }
} }
if (arrayEffect != null) if (arrayEffect != null) {
{
isActive = true; isActive = true;
if (arrayEffect.update(this, this.activeCounter)) if (arrayEffect.update(this, this.activeCounter)) {
{
this.decrStackSize(0, 1); this.decrStackSize(0, 1);
this.decrStackSize(1, 1); this.decrStackSize(1, 1);
this.getWorld().setBlockToAir(getPos()); this.getWorld().setBlockToAir(getPos());
@ -186,20 +159,17 @@ public class TileAlchemyArray extends TileInventory implements ITickable, IAlche
} }
@Override @Override
public EnumFacing getRotation() public EnumFacing getRotation() {
{
return rotation; return rotation;
} }
public void setRotation(EnumFacing rotation) public void setRotation(EnumFacing rotation) {
{
this.rotation = rotation; this.rotation = rotation;
} }
@Override @Override
@SideOnly(Side.CLIENT) @SideOnly(Side.CLIENT)
public AxisAlignedBB getRenderBoundingBox() public AxisAlignedBB getRenderBoundingBox() {
{
return Block.FULL_BLOCK_AABB.offset(getPos()); return Block.FULL_BLOCK_AABB.offset(getPos());
} }
} }

314
src/main/java/WayofTime/bloodmagic/tile/TileAlchemyTable.java
View file

@ -29,8 +29,7 @@ import org.apache.commons.lang3.ArrayUtils;
import java.util.ArrayList; import java.util.ArrayList;
import java.util.List; import java.util.List;
public class TileAlchemyTable extends TileInventory implements ISidedInventory, ITickable public class TileAlchemyTable extends TileInventory implements ISidedInventory, ITickable {
{
public static final int orbSlot = 6; public static final int orbSlot = 6;
public static final int toolSlot = 7; public static final int toolSlot = 7;
public static final int outputSlot = 8; public static final int outputSlot = 8;
@ -41,43 +40,36 @@ public class TileAlchemyTable extends TileInventory implements ISidedInventory,
public int ticksRequired = 1; public int ticksRequired = 1;
public BlockPos connectedPos = BlockPos.ORIGIN; public BlockPos connectedPos = BlockPos.ORIGIN;
public boolean[] blockedSlots = new boolean[] { false, false, false, false, false, false }; public boolean[] blockedSlots = new boolean[]{false, false, false, false, false, false};
public TileAlchemyTable() public TileAlchemyTable() {
{
super(9, "alchemyTable"); super(9, "alchemyTable");
} }
public void setInitialTableParameters(EnumFacing direction, boolean isSlave, BlockPos connectedPos) public void setInitialTableParameters(EnumFacing direction, boolean isSlave, BlockPos connectedPos) {
{
this.isSlave = isSlave; this.isSlave = isSlave;
this.connectedPos = connectedPos; this.connectedPos = connectedPos;
if (!isSlave) if (!isSlave) {
{
this.direction = direction; this.direction = direction;
} }
} }
public boolean isInvisible() public boolean isInvisible() {
{
return isSlave(); return isSlave();
} }
public boolean isInputSlotAccessible(int slot) public boolean isInputSlotAccessible(int slot) {
{
return !(slot < 6 && slot >= 0) || !blockedSlots[slot]; return !(slot < 6 && slot >= 0) || !blockedSlots[slot];
} }
public void toggleInputSlotAccessible(int slot) public void toggleInputSlotAccessible(int slot) {
{
if (slot < 6 && slot >= 0) if (slot < 6 && slot >= 0)
blockedSlots[slot] = !blockedSlots[slot]; blockedSlots[slot] = !blockedSlots[slot];
} }
@Override @Override
public void deserialize(NBTTagCompound tag) public void deserialize(NBTTagCompound tag) {
{
super.deserialize(tag); super.deserialize(tag);
isSlave = tag.getBoolean("isSlave"); isSlave = tag.getBoolean("isSlave");
@ -93,8 +85,7 @@ public class TileAlchemyTable extends TileInventory implements ISidedInventory,
} }
@Override @Override
public NBTTagCompound serialize(NBTTagCompound tag) public NBTTagCompound serialize(NBTTagCompound tag) {
{
super.serialize(tag); super.serialize(tag);
tag.setBoolean("isSlave", isSlave); tag.setBoolean("isSlave", isSlave);
@ -116,19 +107,14 @@ public class TileAlchemyTable extends TileInventory implements ISidedInventory,
@SuppressWarnings("unchecked") @SuppressWarnings("unchecked")
@Override @Override
public <T> T getCapability(Capability<T> capability, EnumFacing facing) public <T> T getCapability(Capability<T> capability, EnumFacing facing) {
{ if (facing != null && capability == CapabilityItemHandler.ITEM_HANDLER_CAPABILITY) {
if (facing != null && capability == CapabilityItemHandler.ITEM_HANDLER_CAPABILITY) if (this.isSlave()) {
{
if (this.isSlave())
{
TileEntity tile = getWorld().getTileEntity(connectedPos); TileEntity tile = getWorld().getTileEntity(connectedPos);
if (tile instanceof TileAlchemyTable && !((TileAlchemyTable) tile).isSlave) if (tile instanceof TileAlchemyTable && !((TileAlchemyTable) tile).isSlave) {
{
return (T) tile.getCapability(capability, facing); return (T) tile.getCapability(capability, facing);
} }
} else } else {
{
return super.getCapability(capability, facing); return super.getCapability(capability, facing);
} }
} }
@ -137,89 +123,70 @@ public class TileAlchemyTable extends TileInventory implements ISidedInventory,
} }
@Override @Override
public int[] getSlotsForFace(EnumFacing side) public int[] getSlotsForFace(EnumFacing side) {
{ switch (side) {
switch (side) case DOWN:
{ return new int[]{outputSlot};
case DOWN: case UP:
return new int[] { outputSlot }; return new int[]{orbSlot, toolSlot};
case UP: default:
return new int[] { orbSlot, toolSlot }; return new int[]{0, 1, 2, 3, 4, 5};
default:
return new int[] { 0, 1, 2, 3, 4, 5 };
} }
} }
@Override @Override
public boolean canInsertItem(int index, ItemStack stack, EnumFacing direction) public boolean canInsertItem(int index, ItemStack stack, EnumFacing direction) {
{ switch (direction) {
switch (direction) case DOWN:
{ return index != outputSlot && index != orbSlot && index != toolSlot;
case DOWN: case UP:
return index != outputSlot && index != orbSlot && index != toolSlot; if (index == orbSlot && !stack.isEmpty() && stack.getItem() instanceof IBloodOrb) {
case UP: return true;
if (index == orbSlot && !stack.isEmpty() && stack.getItem() instanceof IBloodOrb) } else if (index == toolSlot) {
{ return false; //TODO:
return true; } else {
} else if (index == toolSlot) return true;
{
return false; //TODO:
} else
{
return true;
}
default:
if (this.isSlave)
{
TileEntity tile = getWorld().getTileEntity(connectedPos);
if (tile instanceof TileAlchemyTable && !((TileAlchemyTable) tile).isSlave)
{
return ((TileAlchemyTable) tile).canInsertItem(index, stack, direction);
} }
} default:
return getAccessibleInputSlots(direction).contains(index); if (this.isSlave) {
TileEntity tile = getWorld().getTileEntity(connectedPos);
if (tile instanceof TileAlchemyTable && !((TileAlchemyTable) tile).isSlave) {
return ((TileAlchemyTable) tile).canInsertItem(index, stack, direction);
}
}
return getAccessibleInputSlots(direction).contains(index);
} }
} }
@Override @Override
public boolean canExtractItem(int index, ItemStack stack, EnumFacing direction) public boolean canExtractItem(int index, ItemStack stack, EnumFacing direction) {
{ switch (direction) {
switch (direction) case DOWN:
{ return index == outputSlot;
case DOWN: case UP:
return index == outputSlot; if (index == orbSlot && !stack.isEmpty() && stack.getItem() instanceof IBloodOrb) {
case UP: return true;
if (index == orbSlot && !stack.isEmpty() && stack.getItem() instanceof IBloodOrb) } else if (index == toolSlot) {
{ return true; //TODO:
return true; } else {
} else if (index == toolSlot) return true;
{
return true; //TODO:
} else
{
return true;
}
default:
if (this.isSlave)
{
TileEntity tile = getWorld().getTileEntity(connectedPos);
if (tile instanceof TileAlchemyTable && !((TileAlchemyTable) tile).isSlave)
{
return ((TileAlchemyTable) tile).canExtractItem(index, stack, direction);
} }
} default:
return getAccessibleInputSlots(direction).contains(index); if (this.isSlave) {
TileEntity tile = getWorld().getTileEntity(connectedPos);
if (tile instanceof TileAlchemyTable && !((TileAlchemyTable) tile).isSlave) {
return ((TileAlchemyTable) tile).canExtractItem(index, stack, direction);
}
}
return getAccessibleInputSlots(direction).contains(index);
} }
} }
public List<Integer> getAccessibleInputSlots(EnumFacing direction) public List<Integer> getAccessibleInputSlots(EnumFacing direction) {
{
List<Integer> list = new ArrayList<>(); List<Integer> list = new ArrayList<>();
for (int i = 0; i < 6; i++) for (int i = 0; i < 6; i++) {
{ if (isInputSlotAccessible(i)) {
if (isInputSlotAccessible(i))
{
list.add(i); list.add(i);
} }
} }
@ -228,19 +195,15 @@ public class TileAlchemyTable extends TileInventory implements ISidedInventory,
} }
@Override @Override
public void update() public void update() {
{ if (isSlave()) {
if (isSlave())
{
return; return;
} }
List<ItemStack> inputList = new ArrayList<>(); List<ItemStack> inputList = new ArrayList<>();
for (int i = 0; i < 6; i++) for (int i = 0; i < 6; i++) {
{ if (!getStackInSlot(i).isEmpty()) {
if (!getStackInSlot(i).isEmpty())
{
inputList.add(getStackInSlot(i)); inputList.add(getStackInSlot(i));
} }
} }
@ -249,31 +212,24 @@ public class TileAlchemyTable extends TileInventory implements ISidedInventory,
// special recipes like dying // special recipes like dying
AlchemyTableRecipe recipe = AlchemyTableRecipeRegistry.getMatchingRecipe(inputList, getWorld(), getPos()); AlchemyTableRecipe recipe = AlchemyTableRecipeRegistry.getMatchingRecipe(inputList, getWorld(), getPos());
if (recipe != null && (burnTime > 0 || (!getWorld().isRemote && tier >= recipe.getTierRequired() && this.getContainedLp() >= recipe.getLpDrained()))) if (recipe != null && (burnTime > 0 || (!getWorld().isRemote && tier >= recipe.getTierRequired() && this.getContainedLp() >= recipe.getLpDrained()))) {
{
if (burnTime == 1) if (burnTime == 1)
notifyUpdate(); notifyUpdate();
if (canCraft(recipe.getRecipeOutput(inputList))) if (canCraft(recipe.getRecipeOutput(inputList))) {
{
ticksRequired = recipe.getTicksRequired(); ticksRequired = recipe.getTicksRequired();
burnTime++; burnTime++;
if (burnTime == ticksRequired) if (burnTime == ticksRequired) {
{ if (!getWorld().isRemote) {
if (!getWorld().isRemote)
{
int requiredLp = recipe.getLpDrained(); int requiredLp = recipe.getLpDrained();
if (requiredLp > 0) if (requiredLp > 0) {
{ if (!getWorld().isRemote) {
if (!getWorld().isRemote)
{
consumeLp(requiredLp); consumeLp(requiredLp);
} }
} }
if (!getWorld().isRemote) if (!getWorld().isRemote) {
{
craftItem(inputList, recipe); craftItem(inputList, recipe);
} }
} }
@ -282,34 +238,25 @@ public class TileAlchemyTable extends TileInventory implements ISidedInventory,
IBlockState state = getWorld().getBlockState(pos); IBlockState state = getWorld().getBlockState(pos);
getWorld().notifyBlockUpdate(getPos(), state, state, 3); getWorld().notifyBlockUpdate(getPos(), state, state, 3);
} else if (burnTime > ticksRequired + 10) } else if (burnTime > ticksRequired + 10) {
{
burnTime = 0; burnTime = 0;
} }
} else } else {
{
burnTime = 0; burnTime = 0;
} }
} else } else { // Simple recipes
{ // Simple recipes
RecipeAlchemyTable recipeAlchemyTable = BloodMagicAPI.INSTANCE.getRecipeRegistrar().getAlchemyTable(inputList); RecipeAlchemyTable recipeAlchemyTable = BloodMagicAPI.INSTANCE.getRecipeRegistrar().getAlchemyTable(inputList);
if (recipeAlchemyTable != null && (burnTime > 0 || (!getWorld().isRemote && tier >= recipeAlchemyTable.getMinimumTier() && getContainedLp() >= recipeAlchemyTable.getSyphon()))) if (recipeAlchemyTable != null && (burnTime > 0 || (!getWorld().isRemote && tier >= recipeAlchemyTable.getMinimumTier() && getContainedLp() >= recipeAlchemyTable.getSyphon()))) {
{
if (burnTime == 1) if (burnTime == 1)
notifyUpdate(); notifyUpdate();
if (canCraft(recipeAlchemyTable.getOutput())) if (canCraft(recipeAlchemyTable.getOutput())) {
{
ticksRequired = recipeAlchemyTable.getTicks(); ticksRequired = recipeAlchemyTable.getTicks();
burnTime++; burnTime++;
if (burnTime >= ticksRequired) if (burnTime >= ticksRequired) {
{ if (!getWorld().isRemote) {
if (!getWorld().isRemote) if (recipeAlchemyTable.getSyphon() > 0) {
{ if (consumeLp(recipeAlchemyTable.getSyphon()) < recipeAlchemyTable.getSyphon()) {
if (recipeAlchemyTable.getSyphon() > 0)
{
if (consumeLp(recipeAlchemyTable.getSyphon()) < recipeAlchemyTable.getSyphon())
{
//There was not enough LP to craft or there was no orb //There was not enough LP to craft or there was no orb
burnTime = 0; burnTime = 0;
notifyUpdate(); notifyUpdate();
@ -330,8 +277,7 @@ public class TileAlchemyTable extends TileInventory implements ISidedInventory,
else else
outputSlotStack.grow(event.getOutput().getCount()); outputSlotStack.grow(event.getOutput().getCount());
for (int i = 0; i < 6; i++) for (int i = 0; i < 6; i++) {
{
ItemStack currentStack = getStackInSlot(i); ItemStack currentStack = getStackInSlot(i);
if (currentStack.getItem().hasContainerItem(currentStack)) if (currentStack.getItem().hasContainerItem(currentStack))
setInventorySlotContents(i, currentStack.getItem().getContainerItem(currentStack)); setInventorySlotContents(i, currentStack.getItem().getContainerItem(currentStack));
@ -346,20 +292,17 @@ public class TileAlchemyTable extends TileInventory implements ISidedInventory,
} }
} }
} }
} else } else {
{
burnTime = 0; burnTime = 0;
} }
} }
} }
public double getProgressForGui() public double getProgressForGui() {
{
return ((double) burnTime) / ticksRequired; return ((double) burnTime) / ticksRequired;
} }
private boolean canCraft(ItemStack output) private boolean canCraft(ItemStack output) {
{
ItemStack currentOutputStack = getStackInSlot(outputSlot); ItemStack currentOutputStack = getStackInSlot(outputSlot);
if (output.isEmpty()) if (output.isEmpty())
return false; return false;
@ -371,13 +314,10 @@ public class TileAlchemyTable extends TileInventory implements ISidedInventory,
return result <= getInventoryStackLimit() && result <= currentOutputStack.getMaxStackSize(); return result <= getInventoryStackLimit() && result <= currentOutputStack.getMaxStackSize();
} }
public int getTierOfOrb() public int getTierOfOrb() {
{
ItemStack orbStack = getStackInSlot(orbSlot); ItemStack orbStack = getStackInSlot(orbSlot);
if (!orbStack.isEmpty()) if (!orbStack.isEmpty()) {
{ if (orbStack.getItem() instanceof IBloodOrb) {
if (orbStack.getItem() instanceof IBloodOrb)
{
BloodOrb orb = ((IBloodOrb) orbStack.getItem()).getOrb(orbStack); BloodOrb orb = ((IBloodOrb) orbStack.getItem()).getOrb(orbStack);
return orb == null ? 0 : orb.getTier(); return orb == null ? 0 : orb.getTier();
} }
@ -386,16 +326,12 @@ public class TileAlchemyTable extends TileInventory implements ISidedInventory,
return 0; return 0;
} }
public int getContainedLp() public int getContainedLp() {
{
ItemStack orbStack = getStackInSlot(orbSlot); ItemStack orbStack = getStackInSlot(orbSlot);
if (!orbStack.isEmpty()) if (!orbStack.isEmpty()) {
{ if (orbStack.getItem() instanceof IBloodOrb) {
if (orbStack.getItem() instanceof IBloodOrb)
{
Binding binding = ((IBindable) orbStack.getItem()).getBinding(orbStack); Binding binding = ((IBindable) orbStack.getItem()).getBinding(orbStack);
if (binding == null) if (binding == null) {
{
return 0; return 0;
} }
@ -408,11 +344,9 @@ public class TileAlchemyTable extends TileInventory implements ISidedInventory,
return 0; return 0;
} }
public void craftItem(List<ItemStack> inputList, AlchemyTableRecipe recipe) public void craftItem(List<ItemStack> inputList, AlchemyTableRecipe recipe) {
{
ItemStack outputStack = recipe.getRecipeOutput(inputList); ItemStack outputStack = recipe.getRecipeOutput(inputList);
if (this.canCraft(outputStack)) if (this.canCraft(outputStack)) {
{
ItemStack currentOutputStack = getStackInSlot(outputSlot); ItemStack currentOutputStack = getStackInSlot(outputSlot);
ItemStack[] inputs = new ItemStack[0]; ItemStack[] inputs = new ItemStack[0];
@ -423,11 +357,9 @@ public class TileAlchemyTable extends TileInventory implements ISidedInventory,
MinecraftForge.EVENT_BUS.post(event); MinecraftForge.EVENT_BUS.post(event);
outputStack = event.getOutput(); outputStack = event.getOutput();
if (currentOutputStack.isEmpty()) if (currentOutputStack.isEmpty()) {
{
setInventorySlotContents(outputSlot, outputStack); setInventorySlotContents(outputSlot, outputStack);
} else if (ItemHandlerHelper.canItemStacksStack(outputStack, currentOutputStack)) } else if (ItemHandlerHelper.canItemStacksStack(outputStack, currentOutputStack)) {
{
currentOutputStack.grow(outputStack.getCount()); currentOutputStack.grow(outputStack.getCount());
} }
@ -435,16 +367,12 @@ public class TileAlchemyTable extends TileInventory implements ISidedInventory,
} }
} }
public int consumeLp(int requested) public int consumeLp(int requested) {
{
ItemStack orbStack = getStackInSlot(orbSlot); ItemStack orbStack = getStackInSlot(orbSlot);
if (!orbStack.isEmpty()) if (!orbStack.isEmpty()) {
{ if (orbStack.getItem() instanceof IBloodOrb) {
if (orbStack.getItem() instanceof IBloodOrb) if (NetworkHelper.syphonFromContainer(orbStack, SoulTicket.item(orbStack, world, pos, requested))) {
{
if (NetworkHelper.syphonFromContainer(orbStack, SoulTicket.item(orbStack, world, pos, requested)))
{
return requested; return requested;
} }
} }
@ -453,64 +381,52 @@ public class TileAlchemyTable extends TileInventory implements ISidedInventory,
return 0; return 0;
} }
public void consumeInventory(AlchemyTableRecipe recipe) public void consumeInventory(AlchemyTableRecipe recipe) {
{
ItemStack[] input = new ItemStack[6]; ItemStack[] input = new ItemStack[6];
for (int i = 0; i < 6; i++) for (int i = 0; i < 6; i++) {
{
input[i] = getStackInSlot(i); input[i] = getStackInSlot(i);
} }
ItemStack[] result = recipe.getRemainingItems(input); ItemStack[] result = recipe.getRemainingItems(input);
for (int i = 0; i < 6; i++) for (int i = 0; i < 6; i++) {
{
setInventorySlotContents(i, result[i]); setInventorySlotContents(i, result[i]);
} }
} }
public EnumFacing getDirection() public EnumFacing getDirection() {
{
return direction; return direction;
} }
public boolean isSlave() public boolean isSlave() {
{
return isSlave; return isSlave;
} }
public int getBurnTime() public int getBurnTime() {
{
return burnTime; return burnTime;
} }
public int getTicksRequired() public int getTicksRequired() {
{
return ticksRequired; return ticksRequired;
} }
public BlockPos getConnectedPos() public BlockPos getConnectedPos() {
{
return connectedPos; return connectedPos;
} }
public boolean[] getBlockedSlots() public boolean[] getBlockedSlots() {
{
return blockedSlots; return blockedSlots;
} }
public static int getOrbSlot() public static int getOrbSlot() {
{
return orbSlot; return orbSlot;
} }
public static int getToolSlot() public static int getToolSlot() {
{
return toolSlot; return toolSlot;
} }
public static int getOutputSlot() public static int getOutputSlot() {
{
return outputSlot; return outputSlot;
} }
} }

94
src/main/java/WayofTime/bloodmagic/tile/TileDemonCrystal.java
View file

@ -12,8 +12,7 @@ import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.util.EnumFacing; import net.minecraft.util.EnumFacing;
import net.minecraft.util.math.MathHelper; import net.minecraft.util.math.MathHelper;
public class TileDemonCrystal extends TileTicking public class TileDemonCrystal extends TileTicking {
{
public static final double sameWillConversionRate = 50; public static final double sameWillConversionRate = 50;
public static final double defaultWillConversionRate = 100; public static final double defaultWillConversionRate = 100;
public static final double timeDelayForWrongWill = 0.6; public static final double timeDelayForWrongWill = 0.6;
@ -25,45 +24,35 @@ public class TileDemonCrystal extends TileTicking
public int crystalCount = 1; public int crystalCount = 1;
public EnumFacing placement = EnumFacing.UP; //Side that this crystal is placed on. public EnumFacing placement = EnumFacing.UP; //Side that this crystal is placed on.
public TileDemonCrystal() public TileDemonCrystal() {
{
this.crystalCount = 1; this.crystalCount = 1;
} }
@Override @Override
public void onUpdate() public void onUpdate() {
{ if (getWorld().isRemote) {
if (getWorld().isRemote)
{
return; return;
} }
internalCounter++; internalCounter++;
if (internalCounter % 20 == 0 && crystalCount < 7) if (internalCounter % 20 == 0 && crystalCount < 7) {
{
EnumDemonWillType type = getType(); EnumDemonWillType type = getType();
double value = WorldDemonWillHandler.getCurrentWill(getWorld(), pos, type); double value = WorldDemonWillHandler.getCurrentWill(getWorld(), pos, type);
if (type != EnumDemonWillType.DEFAULT) if (type != EnumDemonWillType.DEFAULT) {
{ if (value >= 0.5) {
if (value >= 0.5)
{
double nextProgress = getCrystalGrowthPerSecond(value); double nextProgress = getCrystalGrowthPerSecond(value);
progressToNextCrystal += WorldDemonWillHandler.drainWill(getWorld(), getPos(), type, nextProgress * sameWillConversionRate, true) / sameWillConversionRate; progressToNextCrystal += WorldDemonWillHandler.drainWill(getWorld(), getPos(), type, nextProgress * sameWillConversionRate, true) / sameWillConversionRate;
} else } else {
{
value = WorldDemonWillHandler.getCurrentWill(getWorld(), pos, EnumDemonWillType.DEFAULT); value = WorldDemonWillHandler.getCurrentWill(getWorld(), pos, EnumDemonWillType.DEFAULT);
if (value > 0.5) if (value > 0.5) {
{
double nextProgress = getCrystalGrowthPerSecond(value) * timeDelayForWrongWill; double nextProgress = getCrystalGrowthPerSecond(value) * timeDelayForWrongWill;
progressToNextCrystal += WorldDemonWillHandler.drainWill(getWorld(), getPos(), EnumDemonWillType.DEFAULT, nextProgress * defaultWillConversionRate, true) / defaultWillConversionRate; progressToNextCrystal += WorldDemonWillHandler.drainWill(getWorld(), getPos(), EnumDemonWillType.DEFAULT, nextProgress * defaultWillConversionRate, true) / defaultWillConversionRate;
} }
} }
} else } else {
{ if (value > 0.5) {
if (value > 0.5)
{
double nextProgress = getCrystalGrowthPerSecond(value); double nextProgress = getCrystalGrowthPerSecond(value);
progressToNextCrystal += WorldDemonWillHandler.drainWill(getWorld(), getPos(), type, nextProgress * sameWillConversionRate, true) / sameWillConversionRate; progressToNextCrystal += WorldDemonWillHandler.drainWill(getWorld(), getPos(), type, nextProgress * sameWillConversionRate, true) / sameWillConversionRate;
@ -84,17 +73,14 @@ public class TileDemonCrystal extends TileTicking
* Encourages the crystal to grow by a large percentage by telling it to * Encourages the crystal to grow by a large percentage by telling it to
* drain will from the aura. * drain will from the aura.
* *
* @param willDrain * @param willDrain The amount of drain that is needed for the crystal to grow
* The amount of drain that is needed for the crystal to grow * successfully for the desired amount. Can be more than the base
* successfully for the desired amount. Can be more than the base * amount.
* amount.
* @param progressPercentage * @param progressPercentage
* @return percentage actually grown. * @return percentage actually grown.
*/ */
public double growCrystalWithWillAmount(double willDrain, double progressPercentage) public double growCrystalWithWillAmount(double willDrain, double progressPercentage) {
{ if (crystalCount >= 7) {
if (crystalCount >= 7)
{
return 0; return 0;
} }
@ -104,8 +90,7 @@ public class TileDemonCrystal extends TileTicking
double value = WorldDemonWillHandler.getCurrentWill(getWorld(), pos, type); double value = WorldDemonWillHandler.getCurrentWill(getWorld(), pos, type);
double percentDrain = willDrain <= 0 ? 1 : Math.min(1, value / willDrain); double percentDrain = willDrain <= 0 ? 1 : Math.min(1, value / willDrain);
if (percentDrain <= 0) if (percentDrain <= 0) {
{
return 0; return 0;
} }
@ -118,15 +103,12 @@ public class TileDemonCrystal extends TileTicking
return percentDrain * progressPercentage; return percentDrain * progressPercentage;
} }
public EnumDemonWillType getType() public EnumDemonWillType getType() {
{
return EnumDemonWillType.values()[this.getBlockMetadata()]; return EnumDemonWillType.values()[this.getBlockMetadata()];
} }
public void checkAndGrowCrystal() public void checkAndGrowCrystal() {
{ if (progressToNextCrystal >= 1 && internalCounter % 100 == 0) {
if (progressToNextCrystal >= 1 && internalCounter % 100 == 0)
{
progressToNextCrystal--; progressToNextCrystal--;
crystalCount++; crystalCount++;
markDirty(); markDirty();
@ -134,20 +116,16 @@ public class TileDemonCrystal extends TileTicking
} }
} }
public double getMaxWillForCrystal() public double getMaxWillForCrystal() {
{
return 50; return 50;
} }
public boolean dropSingleCrystal() public boolean dropSingleCrystal() {
{ if (!getWorld().isRemote && crystalCount > 1) {
if (!getWorld().isRemote && crystalCount > 1)
{
IBlockState state = getWorld().getBlockState(pos); IBlockState state = getWorld().getBlockState(pos);
EnumDemonWillType type = state.getValue(BlockDemonCrystal.TYPE); EnumDemonWillType type = state.getValue(BlockDemonCrystal.TYPE);
ItemStack stack = BlockDemonCrystal.getItemStackDropped(type, 1); ItemStack stack = BlockDemonCrystal.getItemStackDropped(type, 1);
if (!stack.isEmpty()) if (!stack.isEmpty()) {
{
crystalCount--; crystalCount--;
InventoryHelper.spawnItemStack(getWorld(), pos.getX(), pos.getY(), pos.getZ(), stack); InventoryHelper.spawnItemStack(getWorld(), pos.getX(), pos.getY(), pos.getZ(), stack);
notifyUpdate(); notifyUpdate();
@ -158,19 +136,16 @@ public class TileDemonCrystal extends TileTicking
return false; return false;
} }
public double getCrystalGrowthPerSecond(double will) public double getCrystalGrowthPerSecond(double will) {
{
return 1.0 / 200 * Math.sqrt(will / 200); return 1.0 / 200 * Math.sqrt(will / 200);
} }
public int getCrystalCountForRender() public int getCrystalCountForRender() {
{
return MathHelper.clamp(crystalCount - 1, 0, 6); return MathHelper.clamp(crystalCount - 1, 0, 6);
} }
@Override @Override
public void deserialize(NBTTagCompound tag) public void deserialize(NBTTagCompound tag) {
{
holder.readFromNBT(tag, "Will"); holder.readFromNBT(tag, "Will");
crystalCount = tag.getInteger("crystalCount"); crystalCount = tag.getInteger("crystalCount");
placement = EnumFacing.byIndex(tag.getInteger("placement")); placement = EnumFacing.byIndex(tag.getInteger("placement"));
@ -178,8 +153,7 @@ public class TileDemonCrystal extends TileTicking
} }
@Override @Override
public NBTTagCompound serialize(NBTTagCompound tag) public NBTTagCompound serialize(NBTTagCompound tag) {
{
holder.writeToNBT(tag, "Will"); holder.writeToNBT(tag, "Will");
tag.setInteger("crystalCount", crystalCount); tag.setInteger("crystalCount", crystalCount);
tag.setInteger("placement", placement.getIndex()); tag.setInteger("placement", placement.getIndex());
@ -187,23 +161,19 @@ public class TileDemonCrystal extends TileTicking
return tag; return tag;
} }
public int getCrystalCount() public int getCrystalCount() {
{
return crystalCount; return crystalCount;
} }
public void setCrystalCount(int crystalCount) public void setCrystalCount(int crystalCount) {
{
this.crystalCount = crystalCount; this.crystalCount = crystalCount;
} }
public EnumFacing getPlacement() public EnumFacing getPlacement() {
{
return placement; return placement;
} }
public void setPlacement(EnumFacing placement) public void setPlacement(EnumFacing placement) {
{
this.placement = placement; this.placement = placement;
} }

72
src/main/java/WayofTime/bloodmagic/tile/TileDemonCrystallizer.java
View file

@ -11,8 +11,7 @@ import WayofTime.bloodmagic.soul.EnumDemonWillType;
import WayofTime.bloodmagic.soul.IDemonWillConduit; import WayofTime.bloodmagic.soul.IDemonWillConduit;
import WayofTime.bloodmagic.tile.base.TileTicking; import WayofTime.bloodmagic.tile.base.TileTicking;
public class TileDemonCrystallizer extends TileTicking implements IDemonWillConduit public class TileDemonCrystallizer extends TileTicking implements IDemonWillConduit {
{
public static final int maxWill = 100; public static final int maxWill = 100;
public static final double drainRate = 1; public static final double drainRate = 1;
public static final double willToFormCrystal = 99; public static final double willToFormCrystal = 99;
@ -21,16 +20,13 @@ public class TileDemonCrystallizer extends TileTicking implements IDemonWillCond
public DemonWillHolder holder = new DemonWillHolder(); public DemonWillHolder holder = new DemonWillHolder();
public double internalCounter = 0; public double internalCounter = 0;
public TileDemonCrystallizer() public TileDemonCrystallizer() {
{
} }
@Override @Override
public void onUpdate() public void onUpdate() {
{ if (getWorld().isRemote) {
if (getWorld().isRemote)
{
return; return;
} }
@ -39,15 +35,11 @@ public class TileDemonCrystallizer extends TileTicking implements IDemonWillCond
{ {
EnumDemonWillType highestType = WorldDemonWillHandler.getHighestDemonWillType(getWorld(), pos); EnumDemonWillType highestType = WorldDemonWillHandler.getHighestDemonWillType(getWorld(), pos);
double amount = WorldDemonWillHandler.getCurrentWill(getWorld(), pos, highestType); double amount = WorldDemonWillHandler.getCurrentWill(getWorld(), pos, highestType);
if (amount >= willToFormCrystal) if (amount >= willToFormCrystal) {
{
internalCounter += getCrystalFormationRate(amount); internalCounter += getCrystalFormationRate(amount);
if (internalCounter >= totalFormationTime) if (internalCounter >= totalFormationTime) {
{ if (WorldDemonWillHandler.drainWill(getWorld(), getPos(), highestType, willToFormCrystal, false) >= willToFormCrystal) {
if (WorldDemonWillHandler.drainWill(getWorld(), getPos(), highestType, willToFormCrystal, false) >= willToFormCrystal) if (formCrystal(highestType, offsetPos)) {
{
if (formCrystal(highestType, offsetPos))
{
WorldDemonWillHandler.drainWill(getWorld(), getPos(), highestType, willToFormCrystal, true); WorldDemonWillHandler.drainWill(getWorld(), getPos(), highestType, willToFormCrystal, true);
internalCounter = 0; internalCounter = 0;
} }
@ -57,12 +49,10 @@ public class TileDemonCrystallizer extends TileTicking implements IDemonWillCond
} }
} }
public boolean formCrystal(EnumDemonWillType type, BlockPos position) public boolean formCrystal(EnumDemonWillType type, BlockPos position) {
{
getWorld().setBlockState(position, RegistrarBloodMagicBlocks.DEMON_CRYSTAL.getStateFromMeta(type.ordinal())); getWorld().setBlockState(position, RegistrarBloodMagicBlocks.DEMON_CRYSTAL.getStateFromMeta(type.ordinal()));
TileEntity tile = getWorld().getTileEntity(position); TileEntity tile = getWorld().getTileEntity(position);
if (tile instanceof TileDemonCrystal) if (tile instanceof TileDemonCrystal) {
{
((TileDemonCrystal) tile).setPlacement(EnumFacing.UP); ((TileDemonCrystal) tile).setPlacement(EnumFacing.UP);
return true; return true;
} }
@ -70,21 +60,18 @@ public class TileDemonCrystallizer extends TileTicking implements IDemonWillCond
return false; return false;
} }
public double getCrystalFormationRate(double currentWill) public double getCrystalFormationRate(double currentWill) {
{
return 1; return 1;
} }
@Override @Override
public void deserialize(NBTTagCompound tag) public void deserialize(NBTTagCompound tag) {
{
holder.readFromNBT(tag, "Will"); holder.readFromNBT(tag, "Will");
internalCounter = tag.getDouble("internalCounter"); internalCounter = tag.getDouble("internalCounter");
} }
@Override @Override
public NBTTagCompound serialize(NBTTagCompound tag) public NBTTagCompound serialize(NBTTagCompound tag) {
{
holder.writeToNBT(tag, "Will"); holder.writeToNBT(tag, "Will");
tag.setDouble("internalCounter", internalCounter); tag.setDouble("internalCounter", internalCounter);
return tag; return tag;
@ -93,26 +80,21 @@ public class TileDemonCrystallizer extends TileTicking implements IDemonWillCond
// IDemonWillConduit // IDemonWillConduit
@Override @Override
public int getWeight() public int getWeight() {
{
return 10; return 10;
} }
@Override @Override
public double fillDemonWill(EnumDemonWillType type, double amount, boolean doFill) public double fillDemonWill(EnumDemonWillType type, double amount, boolean doFill) {
{ if (amount <= 0) {
if (amount <= 0)
{
return 0; return 0;
} }
if (!canFill(type)) if (!canFill(type)) {
{
return 0; return 0;
} }
if (!doFill) if (!doFill) {
{
return Math.min(maxWill - holder.getWill(type), amount); return Math.min(maxWill - holder.getWill(type), amount);
} }
@ -120,17 +102,14 @@ public class TileDemonCrystallizer extends TileTicking implements IDemonWillCond
} }
@Override @Override
public double drainDemonWill(EnumDemonWillType type, double amount, boolean doDrain) public double drainDemonWill(EnumDemonWillType type, double amount, boolean doDrain) {
{
double drained = amount; double drained = amount;
double current = holder.getWill(type); double current = holder.getWill(type);
if (current < drained) if (current < drained) {
{
drained = current; drained = current;
} }
if (doDrain) if (doDrain) {
{
return holder.drainWill(type, amount); return holder.drainWill(type, amount);
} }
@ -138,20 +117,17 @@ public class TileDemonCrystallizer extends TileTicking implements IDemonWillCond
} }
@Override @Override
public boolean canFill(EnumDemonWillType type) public boolean canFill(EnumDemonWillType type) {
{
return true; return true;
} }
@Override @Override
public boolean canDrain(EnumDemonWillType type) public boolean canDrain(EnumDemonWillType type) {
{
return true; return true;
} }
@Override @Override
public double getCurrentWill(EnumDemonWillType type) public double getCurrentWill(EnumDemonWillType type) {
{
return holder.getWill(type); return holder.getWill(type);
} }
} }

12
src/main/java/WayofTime/bloodmagic/tile/TileMimic.java
View file

@ -42,7 +42,7 @@ public class TileMimic extends TileInventory implements ITickable {
public NBTTagCompound tileTag = new NBTTagCompound(); public NBTTagCompound tileTag = new NBTTagCompound();
public TileEntity mimicedTile = null; public TileEntity mimicedTile = null;
IBlockState stateOfReplacedBlock = Blocks.AIR.getDefaultState(); IBlockState stateOfReplacedBlock = Blocks.AIR.getDefaultState();
public int playerCheckRadius = 5; public int playerCheckRadius = 5;
public int potionSpawnRadius = 5; public int potionSpawnRadius = 5;
public int potionSpawnInterval = 40; public int potionSpawnInterval = 40;
@ -137,7 +137,7 @@ public class TileMimic extends TileInventory implements ITickable {
Utils.insertItemToTile(this, player, 0); Utils.insertItemToTile(this, player, 0);
ItemStack stack = getStackInSlot(0); ItemStack stack = getStackInSlot(0);
if(stateOfReplacedBlock == Blocks.AIR.getDefaultState()) { if (stateOfReplacedBlock == Blocks.AIR.getDefaultState()) {
if (!stack.isEmpty() && stack.getItem() instanceof ItemBlock) { if (!stack.isEmpty() && stack.getItem() instanceof ItemBlock) {
Block block = ((ItemBlock) stack.getItem()).getBlock(); Block block = ((ItemBlock) stack.getItem()).getBlock();
stateOfReplacedBlock = block.getDefaultState(); stateOfReplacedBlock = block.getDefaultState();
@ -273,7 +273,7 @@ public class TileMimic extends TileInventory implements ITickable {
tag.setInteger("playerCheckRadius", playerCheckRadius); tag.setInteger("playerCheckRadius", playerCheckRadius);
tag.setInteger("potionSpawnRadius", potionSpawnRadius); tag.setInteger("potionSpawnRadius", potionSpawnRadius);
tag.setInteger("potionSpawnInterval", potionSpawnInterval); tag.setInteger("potionSpawnInterval", potionSpawnInterval);
tag.setString("stateOfReplacedBlock",stateOfReplacedBlock.toString()); tag.setString("stateOfReplacedBlock", stateOfReplacedBlock.toString());
return tag; return tag;
} }
@ -296,11 +296,11 @@ public class TileMimic extends TileInventory implements ITickable {
public IBlockState getReplacedState() { public IBlockState getReplacedState() {
return stateOfReplacedBlock; return stateOfReplacedBlock;
} }
public void setReplacedState(IBlockState state) { public void setReplacedState(IBlockState state) {
stateOfReplacedBlock = state; stateOfReplacedBlock = state;
} }
@Override @Override
public boolean isItemValidForSlot(int slot, ItemStack itemstack) { public boolean isItemValidForSlot(int slot, ItemStack itemstack) {
return slot == 0 && dropItemsOnBreak; return slot == 0 && dropItemsOnBreak;
@ -312,7 +312,7 @@ public class TileMimic extends TileInventory implements ITickable {
replaceMimicWithBlockActual(world, pos, mimic.getStackInSlot(0), mimic.tileTag, mimic.stateOfReplacedBlock); replaceMimicWithBlockActual(world, pos, mimic.getStackInSlot(0), mimic.tileTag, mimic.stateOfReplacedBlock);
} }
public static boolean replaceMimicWithBlockActual(World world, BlockPos pos, ItemStack stack, NBTTagCompound tileTag, IBlockState replacementState) { public static boolean replaceMimicWithBlockActual(World world, BlockPos pos, ItemStack stack, NBTTagCompound tileTag, IBlockState replacementState) {
if (!stack.isEmpty() && stack.getItem() instanceof ItemBlock) { if (!stack.isEmpty() && stack.getItem() instanceof ItemBlock) {
Block block = ((ItemBlock) stack.getItem()).getBlock(); Block block = ((ItemBlock) stack.getItem()).getBlock();

2
src/main/java/WayofTime/bloodmagic/tile/TilePhantomBlock.java
View file

@ -29,7 +29,7 @@ public class TilePhantomBlock extends TileTicking {
@Override @Override
public void onUpdate() { public void onUpdate() {
if(!world.isRemote) { if (!world.isRemote) {
EntityPlayer player = world.getClosestPlayer(getPos().getX(), getPos().getY(), getPos().getZ(), 10.0D, ItemSigilPhantomBridge.IS_PHANTOM_ACTIVE); EntityPlayer player = world.getClosestPlayer(getPos().getX(), getPos().getY(), getPos().getZ(), 10.0D, ItemSigilPhantomBridge.IS_PHANTOM_ACTIVE);
if (player != null && !player.isSneaking()) if (player != null && !player.isSneaking())
return; return;

255
src/main/java/WayofTime/bloodmagic/tile/routing/TileMasterRoutingNode.java
View file

@ -16,8 +16,7 @@ import net.minecraft.world.World;
import java.util.*; import java.util.*;
import java.util.Map.Entry; import java.util.Map.Entry;
public class TileMasterRoutingNode extends TileInventory implements IMasterRoutingNode, ITickable public class TileMasterRoutingNode extends TileInventory implements IMasterRoutingNode, ITickable {
{
public static final int tickRate = 20; public static final int tickRate = 20;
private int currentInput; private int currentInput;
// A list of connections // A list of connections
@ -26,16 +25,13 @@ public class TileMasterRoutingNode extends TileInventory implements IMasterRouti
private List<BlockPos> outputNodeList = new LinkedList<>(); private List<BlockPos> outputNodeList = new LinkedList<>();
private List<BlockPos> inputNodeList = new LinkedList<>(); private List<BlockPos> inputNodeList = new LinkedList<>();
public TileMasterRoutingNode() public TileMasterRoutingNode() {
{
super(0, "masterRoutingNode"); super(0, "masterRoutingNode");
} }
@Override @Override
public void update() public void update() {
{ if (!getWorld().isRemote) {
if (!getWorld().isRemote)
{
// currentInput = getWorld().isBlockIndirectlyGettingPowered(pos); // currentInput = getWorld().isBlockIndirectlyGettingPowered(pos);
currentInput = getWorld().getStrongPower(pos); currentInput = getWorld().getStrongPower(pos);
@ -50,31 +46,23 @@ public class TileMasterRoutingNode extends TileInventory implements IMasterRouti
Map<Integer, List<IItemFilter>> outputMap = new TreeMap<>(); Map<Integer, List<IItemFilter>> outputMap = new TreeMap<>();
Map<Integer, List<IFluidFilter>> outputFluidMap = new TreeMap<>(); Map<Integer, List<IFluidFilter>> outputFluidMap = new TreeMap<>();
for (BlockPos outputPos : outputNodeList) for (BlockPos outputPos : outputNodeList) {
{
TileEntity outputTile = getWorld().getTileEntity(outputPos); TileEntity outputTile = getWorld().getTileEntity(outputPos);
if (this.isConnected(new LinkedList<>(), outputPos)) if (this.isConnected(new LinkedList<>(), outputPos)) {
{ if (outputTile instanceof IOutputItemRoutingNode) {
if (outputTile instanceof IOutputItemRoutingNode)
{
IOutputItemRoutingNode outputNode = (IOutputItemRoutingNode) outputTile; IOutputItemRoutingNode outputNode = (IOutputItemRoutingNode) outputTile;
for (EnumFacing facing : EnumFacing.VALUES) for (EnumFacing facing : EnumFacing.VALUES) {
{ if (!outputNode.isInventoryConnectedToSide(facing) || !outputNode.isOutput(facing)) {
if (!outputNode.isInventoryConnectedToSide(facing) || !outputNode.isOutput(facing))
{
continue; continue;
} }
IItemFilter filter = outputNode.getOutputFilterForSide(facing); IItemFilter filter = outputNode.getOutputFilterForSide(facing);
if (filter != null) if (filter != null) {
{
int priority = outputNode.getPriority(facing); int priority = outputNode.getPriority(facing);
if (outputMap.containsKey(priority)) if (outputMap.containsKey(priority)) {
{
outputMap.get(priority).add(filter); outputMap.get(priority).add(filter);
} else } else {
{
List<IItemFilter> filterList = new LinkedList<>(); List<IItemFilter> filterList = new LinkedList<>();
filterList.add(filter); filterList.add(filter);
outputMap.put(priority, filterList); outputMap.put(priority, filterList);
@ -83,26 +71,20 @@ public class TileMasterRoutingNode extends TileInventory implements IMasterRouti
} }
} }
if (outputTile instanceof IOutputFluidRoutingNode) if (outputTile instanceof IOutputFluidRoutingNode) {
{
IOutputFluidRoutingNode outputNode = (IOutputFluidRoutingNode) outputTile; IOutputFluidRoutingNode outputNode = (IOutputFluidRoutingNode) outputTile;
for (EnumFacing facing : EnumFacing.VALUES) for (EnumFacing facing : EnumFacing.VALUES) {
{ if (!outputNode.isTankConnectedToSide(facing) || !outputNode.isFluidOutput(facing)) {
if (!outputNode.isTankConnectedToSide(facing) || !outputNode.isFluidOutput(facing))
{
continue; continue;
} }
IFluidFilter filter = outputNode.getOutputFluidFilterForSide(facing); IFluidFilter filter = outputNode.getOutputFluidFilterForSide(facing);
if (filter != null) if (filter != null) {
{
int priority = outputNode.getPriority(facing); int priority = outputNode.getPriority(facing);
if (outputFluidMap.containsKey(priority)) if (outputFluidMap.containsKey(priority)) {
{
outputFluidMap.get(priority).add(filter); outputFluidMap.get(priority).add(filter);
} else } else {
{
List<IFluidFilter> filterList = new LinkedList<>(); List<IFluidFilter> filterList = new LinkedList<>();
filterList.add(filter); filterList.add(filter);
outputFluidMap.put(priority, filterList); outputFluidMap.put(priority, filterList);
@ -116,31 +98,23 @@ public class TileMasterRoutingNode extends TileInventory implements IMasterRouti
Map<Integer, List<IItemFilter>> inputMap = new TreeMap<>(); Map<Integer, List<IItemFilter>> inputMap = new TreeMap<>();
Map<Integer, List<IFluidFilter>> inputFluidMap = new TreeMap<>(); Map<Integer, List<IFluidFilter>> inputFluidMap = new TreeMap<>();
for (BlockPos inputPos : inputNodeList) for (BlockPos inputPos : inputNodeList) {
{
TileEntity inputTile = getWorld().getTileEntity(inputPos); TileEntity inputTile = getWorld().getTileEntity(inputPos);
if (this.isConnected(new LinkedList<>(), inputPos)) if (this.isConnected(new LinkedList<>(), inputPos)) {
{ if (inputTile instanceof IInputItemRoutingNode) {
if (inputTile instanceof IInputItemRoutingNode)
{
IInputItemRoutingNode inputNode = (IInputItemRoutingNode) inputTile; IInputItemRoutingNode inputNode = (IInputItemRoutingNode) inputTile;
for (EnumFacing facing : EnumFacing.VALUES) for (EnumFacing facing : EnumFacing.VALUES) {
{ if (!inputNode.isInventoryConnectedToSide(facing) || !inputNode.isInput(facing)) {
if (!inputNode.isInventoryConnectedToSide(facing) || !inputNode.isInput(facing))
{
continue; continue;
} }
IItemFilter filter = inputNode.getInputFilterForSide(facing); IItemFilter filter = inputNode.getInputFilterForSide(facing);
if (filter != null) if (filter != null) {
{
int priority = inputNode.getPriority(facing); int priority = inputNode.getPriority(facing);
if (inputMap.containsKey(priority)) if (inputMap.containsKey(priority)) {
{
inputMap.get(priority).add(filter); inputMap.get(priority).add(filter);
} else } else {
{
List<IItemFilter> filterList = new LinkedList<>(); List<IItemFilter> filterList = new LinkedList<>();
filterList.add(filter); filterList.add(filter);
inputMap.put(priority, filterList); inputMap.put(priority, filterList);
@ -149,26 +123,20 @@ public class TileMasterRoutingNode extends TileInventory implements IMasterRouti
} }
} }
if (inputTile instanceof IInputFluidRoutingNode) if (inputTile instanceof IInputFluidRoutingNode) {
{
IInputFluidRoutingNode inputNode = (IInputFluidRoutingNode) inputTile; IInputFluidRoutingNode inputNode = (IInputFluidRoutingNode) inputTile;
for (EnumFacing facing : EnumFacing.VALUES) for (EnumFacing facing : EnumFacing.VALUES) {
{ if (!inputNode.isTankConnectedToSide(facing) || !inputNode.isFluidInput(facing)) {
if (!inputNode.isTankConnectedToSide(facing) || !inputNode.isFluidInput(facing))
{
continue; continue;
} }
IFluidFilter filter = inputNode.getInputFluidFilterForSide(facing); IFluidFilter filter = inputNode.getInputFluidFilterForSide(facing);
if (filter != null) if (filter != null) {
{
int priority = inputNode.getPriority(facing); int priority = inputNode.getPriority(facing);
if (inputFluidMap.containsKey(priority)) if (inputFluidMap.containsKey(priority)) {
{
inputFluidMap.get(priority).add(filter); inputFluidMap.get(priority).add(filter);
} else } else {
{
List<IFluidFilter> filterList = new LinkedList<>(); List<IFluidFilter> filterList = new LinkedList<>();
filterList.add(filter); filterList.add(filter);
inputFluidMap.put(priority, filterList); inputFluidMap.put(priority, filterList);
@ -182,19 +150,14 @@ public class TileMasterRoutingNode extends TileInventory implements IMasterRouti
int maxTransfer = this.getMaxTransferForDemonWill(WorldDemonWillHandler.getCurrentWill(getWorld(), pos, EnumDemonWillType.DEFAULT)); int maxTransfer = this.getMaxTransferForDemonWill(WorldDemonWillHandler.getCurrentWill(getWorld(), pos, EnumDemonWillType.DEFAULT));
int maxFluidTransfer = 1000; int maxFluidTransfer = 1000;
for (Entry<Integer, List<IItemFilter>> outputEntry : outputMap.entrySet()) for (Entry<Integer, List<IItemFilter>> outputEntry : outputMap.entrySet()) {
{
List<IItemFilter> outputList = outputEntry.getValue(); List<IItemFilter> outputList = outputEntry.getValue();
for (IItemFilter outputFilter : outputList) for (IItemFilter outputFilter : outputList) {
{ for (Entry<Integer, List<IItemFilter>> inputEntry : inputMap.entrySet()) {
for (Entry<Integer, List<IItemFilter>> inputEntry : inputMap.entrySet())
{
List<IItemFilter> inputList = inputEntry.getValue(); List<IItemFilter> inputList = inputEntry.getValue();
for (IItemFilter inputFilter : inputList) for (IItemFilter inputFilter : inputList) {
{
maxTransfer -= inputFilter.transferThroughInputFilter(outputFilter, maxTransfer); maxTransfer -= inputFilter.transferThroughInputFilter(outputFilter, maxTransfer);
if (maxTransfer <= 0) if (maxTransfer <= 0) {
{
return; return;
} }
} }
@ -202,19 +165,14 @@ public class TileMasterRoutingNode extends TileInventory implements IMasterRouti
} }
} }
for (Entry<Integer, List<IFluidFilter>> outputEntry : outputFluidMap.entrySet()) for (Entry<Integer, List<IFluidFilter>> outputEntry : outputFluidMap.entrySet()) {
{
List<IFluidFilter> outputList = outputEntry.getValue(); List<IFluidFilter> outputList = outputEntry.getValue();
for (IFluidFilter outputFilter : outputList) for (IFluidFilter outputFilter : outputList) {
{ for (Entry<Integer, List<IFluidFilter>> inputEntry : inputFluidMap.entrySet()) {
for (Entry<Integer, List<IFluidFilter>> inputEntry : inputFluidMap.entrySet())
{
List<IFluidFilter> inputList = inputEntry.getValue(); List<IFluidFilter> inputList = inputEntry.getValue();
for (IFluidFilter inputFilter : inputList) for (IFluidFilter inputFilter : inputList) {
{
maxFluidTransfer -= inputFilter.transferThroughInputFilter(outputFilter, maxFluidTransfer); maxFluidTransfer -= inputFilter.transferThroughInputFilter(outputFilter, maxFluidTransfer);
if (maxFluidTransfer <= 0) if (maxFluidTransfer <= 0) {
{
return; return;
} }
} }
@ -223,18 +181,15 @@ public class TileMasterRoutingNode extends TileInventory implements IMasterRouti
} }
} }
public int getMaxTransferForDemonWill(double will) public int getMaxTransferForDemonWill(double will) {
{
return 64; return 64;
} }
@Override @Override
public NBTTagCompound serialize(NBTTagCompound tag) public NBTTagCompound serialize(NBTTagCompound tag) {
{
super.serialize(tag); super.serialize(tag);
NBTTagList tags = new NBTTagList(); NBTTagList tags = new NBTTagList();
for (BlockPos pos : generalNodeList) for (BlockPos pos : generalNodeList) {
{
NBTTagCompound posTag = new NBTTagCompound(); NBTTagCompound posTag = new NBTTagCompound();
posTag.setInteger(Constants.NBT.X_COORD, pos.getX()); posTag.setInteger(Constants.NBT.X_COORD, pos.getX());
posTag.setInteger(Constants.NBT.Y_COORD, pos.getY()); posTag.setInteger(Constants.NBT.Y_COORD, pos.getY());
@ -244,8 +199,7 @@ public class TileMasterRoutingNode extends TileInventory implements IMasterRouti
tag.setTag(Constants.NBT.ROUTING_MASTER_GENERAL, tags); tag.setTag(Constants.NBT.ROUTING_MASTER_GENERAL, tags);
tags = new NBTTagList(); tags = new NBTTagList();
for (BlockPos pos : inputNodeList) for (BlockPos pos : inputNodeList) {
{
NBTTagCompound posTag = new NBTTagCompound(); NBTTagCompound posTag = new NBTTagCompound();
posTag.setInteger(Constants.NBT.X_COORD, pos.getX()); posTag.setInteger(Constants.NBT.X_COORD, pos.getX());
posTag.setInteger(Constants.NBT.Y_COORD, pos.getY()); posTag.setInteger(Constants.NBT.Y_COORD, pos.getY());
@ -255,8 +209,7 @@ public class TileMasterRoutingNode extends TileInventory implements IMasterRouti
tag.setTag(Constants.NBT.ROUTING_MASTER_INPUT, tags); tag.setTag(Constants.NBT.ROUTING_MASTER_INPUT, tags);
tags = new NBTTagList(); tags = new NBTTagList();
for (BlockPos pos : outputNodeList) for (BlockPos pos : outputNodeList) {
{
NBTTagCompound posTag = new NBTTagCompound(); NBTTagCompound posTag = new NBTTagCompound();
posTag.setInteger(Constants.NBT.X_COORD, pos.getX()); posTag.setInteger(Constants.NBT.X_COORD, pos.getX());
posTag.setInteger(Constants.NBT.Y_COORD, pos.getY()); posTag.setInteger(Constants.NBT.Y_COORD, pos.getY());
@ -268,29 +221,25 @@ public class TileMasterRoutingNode extends TileInventory implements IMasterRouti
} }
@Override @Override
public void deserialize(NBTTagCompound tag) public void deserialize(NBTTagCompound tag) {
{
super.deserialize(tag); super.deserialize(tag);
NBTTagList tags = tag.getTagList(Constants.NBT.ROUTING_MASTER_GENERAL, 10); NBTTagList tags = tag.getTagList(Constants.NBT.ROUTING_MASTER_GENERAL, 10);
for (int i = 0; i < tags.tagCount(); i++) for (int i = 0; i < tags.tagCount(); i++) {
{
NBTTagCompound blockTag = tags.getCompoundTagAt(i); NBTTagCompound blockTag = tags.getCompoundTagAt(i);
BlockPos newPos = new BlockPos(blockTag.getInteger(Constants.NBT.X_COORD), blockTag.getInteger(Constants.NBT.Y_COORD), blockTag.getInteger(Constants.NBT.Z_COORD)); BlockPos newPos = new BlockPos(blockTag.getInteger(Constants.NBT.X_COORD), blockTag.getInteger(Constants.NBT.Y_COORD), blockTag.getInteger(Constants.NBT.Z_COORD));
generalNodeList.add(newPos); generalNodeList.add(newPos);
} }
tags = tag.getTagList(Constants.NBT.ROUTING_MASTER_INPUT, 10); tags = tag.getTagList(Constants.NBT.ROUTING_MASTER_INPUT, 10);
for (int i = 0; i < tags.tagCount(); i++) for (int i = 0; i < tags.tagCount(); i++) {
{
NBTTagCompound blockTag = tags.getCompoundTagAt(i); NBTTagCompound blockTag = tags.getCompoundTagAt(i);
BlockPos newPos = new BlockPos(blockTag.getInteger(Constants.NBT.X_COORD), blockTag.getInteger(Constants.NBT.Y_COORD), blockTag.getInteger(Constants.NBT.Z_COORD)); BlockPos newPos = new BlockPos(blockTag.getInteger(Constants.NBT.X_COORD), blockTag.getInteger(Constants.NBT.Y_COORD), blockTag.getInteger(Constants.NBT.Z_COORD));
inputNodeList.add(newPos); inputNodeList.add(newPos);
} }
tags = tag.getTagList(Constants.NBT.ROUTING_MASTER_OUTPUT, 10); tags = tag.getTagList(Constants.NBT.ROUTING_MASTER_OUTPUT, 10);
for (int i = 0; i < tags.tagCount(); i++) for (int i = 0; i < tags.tagCount(); i++) {
{
NBTTagCompound blockTag = tags.getCompoundTagAt(i); NBTTagCompound blockTag = tags.getCompoundTagAt(i);
BlockPos newPos = new BlockPos(blockTag.getInteger(Constants.NBT.X_COORD), blockTag.getInteger(Constants.NBT.Y_COORD), blockTag.getInteger(Constants.NBT.Z_COORD)); BlockPos newPos = new BlockPos(blockTag.getInteger(Constants.NBT.X_COORD), blockTag.getInteger(Constants.NBT.Y_COORD), blockTag.getInteger(Constants.NBT.Z_COORD));
outputNodeList.add(newPos); outputNodeList.add(newPos);
@ -298,16 +247,14 @@ public class TileMasterRoutingNode extends TileInventory implements IMasterRouti
} }
@Override @Override
public boolean isConnected(List<BlockPos> path, BlockPos nodePos) public boolean isConnected(List<BlockPos> path, BlockPos nodePos) {
{
//TODO: Figure out how to make it so the path is obtained //TODO: Figure out how to make it so the path is obtained
// if (!connectionMap.containsKey(nodePos)) // if (!connectionMap.containsKey(nodePos))
// { // {
// return false; // return false;
// } // }
TileEntity tile = getWorld().getTileEntity(nodePos); TileEntity tile = getWorld().getTileEntity(nodePos);
if (!(tile instanceof IRoutingNode)) if (!(tile instanceof IRoutingNode)) {
{
// connectionMap.remove(nodePos); // connectionMap.remove(nodePos);
return false; return false;
} }
@ -316,22 +263,17 @@ public class TileMasterRoutingNode extends TileInventory implements IMasterRouti
List<BlockPos> connectionList = node.getConnected(); List<BlockPos> connectionList = node.getConnected();
// List<BlockPos> testPath = path.subList(0, path.size()); // List<BlockPos> testPath = path.subList(0, path.size());
path.add(nodePos); path.add(nodePos);
for (BlockPos testPos : connectionList) for (BlockPos testPos : connectionList) {
{ if (path.contains(testPos)) {
if (path.contains(testPos))
{
continue; continue;
} }
if (testPos.equals(this.getPos()) && node.isConnectionEnabled(testPos)) if (testPos.equals(this.getPos()) && node.isConnectionEnabled(testPos)) {
{
// path.clear(); // path.clear();
// path.addAll(testPath); // path.addAll(testPath);
return true; return true;
} else if (NodeHelper.isNodeConnectionEnabled(getWorld(), node, testPos)) } else if (NodeHelper.isNodeConnectionEnabled(getWorld(), node, testPos)) {
{ if (isConnected(path, testPos)) {
if (isConnected(path, testPos))
{
// path.clear(); // path.clear();
// path.addAll(testPath); // path.addAll(testPath);
return true; return true;
@ -343,56 +285,44 @@ public class TileMasterRoutingNode extends TileInventory implements IMasterRouti
} }
@Override @Override
public boolean isConnectionEnabled(BlockPos testPos) public boolean isConnectionEnabled(BlockPos testPos) {
{
return currentInput <= 0; return currentInput <= 0;
} }
@Override @Override
public void addNodeToList(IRoutingNode node) public void addNodeToList(IRoutingNode node) {
{
BlockPos newPos = node.getBlockPos(); BlockPos newPos = node.getBlockPos();
if (!generalNodeList.contains(newPos)) if (!generalNodeList.contains(newPos)) {
{
generalNodeList.add(newPos); generalNodeList.add(newPos);
} }
if (node instanceof IInputItemRoutingNode && !inputNodeList.contains(newPos)) if (node instanceof IInputItemRoutingNode && !inputNodeList.contains(newPos)) {
{
inputNodeList.add(newPos); inputNodeList.add(newPos);
} }
if (node instanceof IOutputItemRoutingNode && !outputNodeList.contains(newPos)) if (node instanceof IOutputItemRoutingNode && !outputNodeList.contains(newPos)) {
{
outputNodeList.add(newPos); outputNodeList.add(newPos);
} }
} }
@Override @Override
public void addConnections(BlockPos pos, List<BlockPos> connectionList) public void addConnections(BlockPos pos, List<BlockPos> connectionList) {
{ for (BlockPos testPos : connectionList) {
for (BlockPos testPos : connectionList)
{
addConnection(pos, testPos); addConnection(pos, testPos);
} }
} }
@Override @Override
public void addConnection(BlockPos pos1, BlockPos pos2) public void addConnection(BlockPos pos1, BlockPos pos2) {
{ if (connectionMap.containsKey(pos1) && !connectionMap.get(pos1).contains(pos2)) {
if (connectionMap.containsKey(pos1) && !connectionMap.get(pos1).contains(pos2))
{
connectionMap.get(pos1).add(pos2); connectionMap.get(pos1).add(pos2);
} else } else {
{
List<BlockPos> list = new LinkedList<>(); List<BlockPos> list = new LinkedList<>();
list.add(pos2); list.add(pos2);
connectionMap.put(pos1, list); connectionMap.put(pos1, list);
} }
if (connectionMap.containsKey(pos2) && !connectionMap.get(pos2).contains(pos1)) if (connectionMap.containsKey(pos2) && !connectionMap.get(pos2).contains(pos1)) {
{
connectionMap.get(pos2).add(pos1); connectionMap.get(pos2).add(pos1);
} else } else {
{
List<BlockPos> list = new LinkedList<>(); List<BlockPos> list = new LinkedList<>();
list.add(pos1); list.add(pos1);
connectionMap.put(pos2, list); connectionMap.put(pos2, list);
@ -400,84 +330,69 @@ public class TileMasterRoutingNode extends TileInventory implements IMasterRouti
} }
@Override @Override
public void removeConnection(BlockPos pos1, BlockPos pos2) public void removeConnection(BlockPos pos1, BlockPos pos2) {
{ if (connectionMap.containsKey(pos1)) {
if (connectionMap.containsKey(pos1))
{
List<BlockPos> posList = connectionMap.get(pos1); List<BlockPos> posList = connectionMap.get(pos1);
posList.remove(pos2); posList.remove(pos2);
if (posList.isEmpty()) if (posList.isEmpty()) {
{
connectionMap.remove(pos1); connectionMap.remove(pos1);
} }
} }
if (connectionMap.containsKey(pos2)) if (connectionMap.containsKey(pos2)) {
{
List<BlockPos> posList = connectionMap.get(pos2); List<BlockPos> posList = connectionMap.get(pos2);
posList.remove(pos1); posList.remove(pos1);
if (posList.isEmpty()) if (posList.isEmpty()) {
{
connectionMap.remove(pos2); connectionMap.remove(pos2);
} }
} }
} }
@Override @Override
public void connectMasterToRemainingNode(World world, List<BlockPos> alreadyChecked, IMasterRoutingNode master) public void connectMasterToRemainingNode(World world, List<BlockPos> alreadyChecked, IMasterRoutingNode master) {
{
return; return;
} }
@Override @Override
public BlockPos getBlockPos() public BlockPos getBlockPos() {
{
return this.getPos(); return this.getPos();
} }
@Override @Override
public List<BlockPos> getConnected() public List<BlockPos> getConnected() {
{
return new LinkedList<>(); return new LinkedList<>();
} }
@Override @Override
public BlockPos getMasterPos() public BlockPos getMasterPos() {
{
return this.getPos(); return this.getPos();
} }
@Override @Override
public boolean isMaster(IMasterRoutingNode master) public boolean isMaster(IMasterRoutingNode master) {
{
return false; return false;
} }
@Override @Override
public void addConnection(BlockPos pos1) public void addConnection(BlockPos pos1) {
{
// Empty // Empty
} }
@Override @Override
public void removeConnection(BlockPos pos1) public void removeConnection(BlockPos pos1) {
{
generalNodeList.remove(pos1); generalNodeList.remove(pos1);
inputNodeList.remove(pos1); inputNodeList.remove(pos1);
outputNodeList.remove(pos1); outputNodeList.remove(pos1);
} }
@Override @Override
public void removeAllConnections() public void removeAllConnections() {
{
List<BlockPos> list = generalNodeList.subList(0, generalNodeList.size()); List<BlockPos> list = generalNodeList.subList(0, generalNodeList.size());
Iterator<BlockPos> itr = list.iterator(); Iterator<BlockPos> itr = list.iterator();
while (itr.hasNext()) while (itr.hasNext()) {
{
BlockPos testPos = itr.next(); BlockPos testPos = itr.next();
TileEntity tile = getWorld().getTileEntity(testPos); TileEntity tile = getWorld().getTileEntity(testPos);
if (tile instanceof IRoutingNode) if (tile instanceof IRoutingNode) {
{
((IRoutingNode) tile).removeConnection(pos); ((IRoutingNode) tile).removeConnection(pos);
getWorld().notifyBlockUpdate(getPos(), getWorld().getBlockState(testPos), getWorld().getBlockState(testPos), 3); getWorld().notifyBlockUpdate(getPos(), getWorld().getBlockState(testPos), getWorld().getBlockState(testPos), 3);
} }

18
src/main/java/WayofTime/bloodmagic/util/Constants.java
View file

@ -7,10 +7,8 @@ import net.minecraftforge.fml.common.registry.ForgeRegistries;
import java.util.Locale; import java.util.Locale;
public class Constants public class Constants {
{ public static class NBT {
public static class NBT
{
public static final String OWNER_UUID = "ownerUUID"; public static final String OWNER_UUID = "ownerUUID";
public static final String OWNER_NAME = "ownerNAME"; public static final String OWNER_NAME = "ownerNAME";
public static final String USES = "uses"; public static final String USES = "uses";
@ -133,13 +131,11 @@ public class Constants
public static final String BREATH = "breath"; public static final String BREATH = "breath";
} }
public static class Mod public static class Mod {
{
public static final String DOMAIN = BloodMagic.MODID.toLowerCase(Locale.ENGLISH) + ":"; public static final String DOMAIN = BloodMagic.MODID.toLowerCase(Locale.ENGLISH) + ":";
} }
public static final class Gui public static final class Gui {
{
public static final int TELEPOSER_GUI = 0; public static final int TELEPOSER_GUI = 0;
public static final int SOUL_FORGE_GUI = 1; public static final int SOUL_FORGE_GUI = 1;
public static final int ROUTING_NODE_GUI = 2; public static final int ROUTING_NODE_GUI = 2;
@ -148,8 +144,7 @@ public class Constants
public static final int SIGIL_HOLDING_GUI = 5; public static final int SIGIL_HOLDING_GUI = 5;
} }
public static class Compat public static class Compat {
{
public static final String JEI_CATEGORY_ALTAR = BloodMagic.MODID + ":altar"; public static final String JEI_CATEGORY_ALTAR = BloodMagic.MODID + ":altar";
public static final String JEI_CATEGORY_BINDING = BloodMagic.MODID + ":binding"; public static final String JEI_CATEGORY_BINDING = BloodMagic.MODID + ":binding";
public static final String JEI_CATEGORY_ALCHEMYARRAY = BloodMagic.MODID + ":alchemyArray"; public static final String JEI_CATEGORY_ALCHEMYARRAY = BloodMagic.MODID + ":alchemyArray";
@ -166,8 +161,7 @@ public class Constants
public static final Item THAUMCRAFT_GOGGLES = ForgeRegistries.ITEMS.getValue(new ResourceLocation("Thaumcraft", "goggles")); public static final Item THAUMCRAFT_GOGGLES = ForgeRegistries.ITEMS.getValue(new ResourceLocation("Thaumcraft", "goggles"));
} }
public static class Misc public static class Misc {
{
public static final int POTION_ARRAY_SIZE = 256; public static final int POTION_ARRAY_SIZE = 256;
public static final float ALTERED_STEP_HEIGHT = 1.00314159f; public static final float ALTERED_STEP_HEIGHT = 1.00314159f;
public static final int NIGHT_VISION_CONSTANT_BEGIN = 30020; public static final int NIGHT_VISION_CONSTANT_BEGIN = 30020;

2
src/main/java/WayofTime/bloodmagic/util/ISigilFluidItem.java
View file

@ -5,8 +5,10 @@ import net.minecraftforge.fluids.FluidStack;
public interface ISigilFluidItem { public interface ISigilFluidItem {
FluidStack getFluid(ItemStack sigil); FluidStack getFluid(ItemStack sigil);
int getCapacity(ItemStack sigil); int getCapacity(ItemStack sigil);
int fill(ItemStack sigil, FluidStack resource, boolean doFill); int fill(ItemStack sigil, FluidStack resource, boolean doFill);
FluidStack drain(ItemStack sigil, int maxDrain, boolean doDrain); FluidStack drain(ItemStack sigil, int maxDrain, boolean doDrain);
} }

5
src/main/java/WayofTime/bloodmagic/util/PluginUtil.java
View file

@ -45,7 +45,7 @@ public class PluginUtil {
// Bring core plugin up to top // Bring core plugin up to top
discoveredAnnotations.sort((o1, o2) -> { discoveredAnnotations.sort((o1, o2) -> {
if (o1.getLeft().getClass() == BloodMagicCorePlugin.class) if (o1.getLeft().getClass() == BloodMagicCorePlugin.class)
return -1; return -1;
return o1.getClass().getCanonicalName().compareToIgnoreCase(o2.getClass().getCanonicalName()); return o1.getClass().getCanonicalName().compareToIgnoreCase(o2.getClass().getCanonicalName());
}); });
@ -120,8 +120,7 @@ public class PluginUtil {
public enum RegistrationStep { public enum RegistrationStep {
PLUGIN_REGISTER(p -> p.getLeft().register(BloodMagicAPI.INSTANCE)), PLUGIN_REGISTER(p -> p.getLeft().register(BloodMagicAPI.INSTANCE)),
RECIPE_REGISTER(p -> p.getLeft().registerRecipes(BloodMagicAPI.INSTANCE.getRecipeRegistrar())) RECIPE_REGISTER(p -> p.getLeft().registerRecipes(BloodMagicAPI.INSTANCE.getRecipeRegistrar()));
;
private final Consumer<Pair<IBloodMagicPlugin, BloodMagicPlugin>> consumer; private final Consumer<Pair<IBloodMagicPlugin, BloodMagicPlugin>> consumer;

8
src/main/java/WayofTime/bloodmagic/util/handler/event/GenericHandler.java
View file

@ -360,7 +360,7 @@ public class GenericHandler {
BindableHelper.applyBinding(held, player); // Bind item to the player BindableHelper.applyBinding(held, player); // Bind item to the player
} }
// If the binding exists, we'll check if the player's name has changed since they last used it and update that if so. // If the binding exists, we'll check if the player's name has changed since they last used it and update that if so.
} else if (binding.getOwnerId().equals(player.getGameProfile().getId()) && !binding.getOwnerName().equals(player.getGameProfile().getName())) { } else if (binding.getOwnerId().equals(player.getGameProfile().getId()) && !binding.getOwnerName().equals(player.getGameProfile().getName())) {
binding.setOwnerName(player.getGameProfile().getName()); binding.setOwnerName(player.getGameProfile().getName());
BindableHelper.applyBinding(held, binding); BindableHelper.applyBinding(held, binding);
@ -419,9 +419,9 @@ public class GenericHandler {
} }
@SubscribeEvent @SubscribeEvent
public static void onRitualDeath(LivingDropsEvent event){ public static void onRitualDeath(LivingDropsEvent event) {
if(!ConfigHandler.values.wellOfSufferingDrops){ if (!ConfigHandler.values.wellOfSufferingDrops) {
if(event.getSource().equals(RitualManager.RITUAL_DAMAGE)) { if (event.getSource().equals(RitualManager.RITUAL_DAMAGE)) {
event.getDrops().clear(); event.getDrops().clear();
} }
} }

197
src/main/java/WayofTime/bloodmagic/util/handler/event/LivingArmourHandler.java
View file

@ -45,31 +45,24 @@ import net.minecraftforge.fml.common.eventhandler.EventPriority;
import net.minecraftforge.fml.common.eventhandler.SubscribeEvent; import net.minecraftforge.fml.common.eventhandler.SubscribeEvent;
@Mod.EventBusSubscriber(modid = BloodMagic.MODID) @Mod.EventBusSubscriber(modid = BloodMagic.MODID)
public class LivingArmourHandler public class LivingArmourHandler {
{
@SubscribeEvent @SubscribeEvent
public static void onEntityHealed(LivingHealEvent event) public static void onEntityHealed(LivingHealEvent event) {
{ if (event.getEntityLiving() instanceof EntityPlayer) {
if (event.getEntityLiving() instanceof EntityPlayer)
{
EntityPlayer player = (EntityPlayer) event.getEntity(); EntityPlayer player = (EntityPlayer) event.getEntity();
if (LivingArmour.hasFullSet(player)) if (LivingArmour.hasFullSet(player)) {
{
ItemStack chestStack = player.getItemStackFromSlot(EntityEquipmentSlot.CHEST); ItemStack chestStack = player.getItemStackFromSlot(EntityEquipmentSlot.CHEST);
LivingArmour armour = ItemLivingArmour.getLivingArmour(chestStack); LivingArmour armour = ItemLivingArmour.getLivingArmour(chestStack);
if (armour != null) if (armour != null) {
{
double modifier = 1; double modifier = 1;
LivingArmourUpgrade upgrade = ItemLivingArmour.getUpgrade(BloodMagic.MODID + ".upgrade.slowHeal", chestStack); LivingArmourUpgrade upgrade = ItemLivingArmour.getUpgrade(BloodMagic.MODID + ".upgrade.slowHeal", chestStack);
if (upgrade instanceof LivingArmourUpgradeSlowHeal) if (upgrade instanceof LivingArmourUpgradeSlowHeal) {
{
modifier *= ((LivingArmourUpgradeSlowHeal) upgrade).getHealingModifier(); modifier *= ((LivingArmourUpgradeSlowHeal) upgrade).getHealingModifier();
} }
if (modifier != 1) if (modifier != 1) {
{
event.setAmount((float) (event.getAmount() * modifier)); event.setAmount((float) (event.getAmount() * modifier));
} }
} }
@ -78,23 +71,18 @@ public class LivingArmourHandler
} }
@SubscribeEvent @SubscribeEvent
public static void onMiningSpeedCheck(PlayerEvent.BreakSpeed event) public static void onMiningSpeedCheck(PlayerEvent.BreakSpeed event) {
{
EntityPlayer player = event.getEntityPlayer(); EntityPlayer player = event.getEntityPlayer();
if (LivingArmour.hasFullSet(player)) if (LivingArmour.hasFullSet(player)) {
{
ItemStack chestStack = player.getItemStackFromSlot(EntityEquipmentSlot.CHEST); ItemStack chestStack = player.getItemStackFromSlot(EntityEquipmentSlot.CHEST);
LivingArmour armour = ItemLivingArmour.getLivingArmour(chestStack); LivingArmour armour = ItemLivingArmour.getLivingArmour(chestStack);
if (armour != null) if (armour != null) {
{
double modifier = 1; double modifier = 1;
for (LivingArmourUpgrade upgrade : armour.upgradeMap.values()) for (LivingArmourUpgrade upgrade : armour.upgradeMap.values()) {
{
modifier *= upgrade.getMiningSpeedModifier(player); modifier *= upgrade.getMiningSpeedModifier(player);
} }
if (modifier != 1) if (modifier != 1) {
{
event.setNewSpeed((float) (event.getOriginalSpeed() * modifier)); event.setNewSpeed((float) (event.getOriginalSpeed() * modifier));
} }
} }
@ -103,31 +91,24 @@ public class LivingArmourHandler
// Applies: Storm Trooper // Applies: Storm Trooper
@SubscribeEvent @SubscribeEvent
public static void onEntityJoinedWorld(EntityJoinWorldEvent event) public static void onEntityJoinedWorld(EntityJoinWorldEvent event) {
{
Entity owner = null; Entity owner = null;
if (event.getEntity() instanceof EntityArrow) if (event.getEntity() instanceof EntityArrow) {
{
owner = ((EntityArrow) event.getEntity()).shootingEntity; owner = ((EntityArrow) event.getEntity()).shootingEntity;
} else if (event.getEntity() instanceof EntityThrowable) } else if (event.getEntity() instanceof EntityThrowable) {
{
owner = ((EntityThrowable) event.getEntity()).getThrower(); owner = ((EntityThrowable) event.getEntity()).getThrower();
} }
if (owner instanceof EntityPlayer) if (owner instanceof EntityPlayer) {
{
Entity projectile = event.getEntity(); Entity projectile = event.getEntity();
EntityPlayer player = (EntityPlayer) owner; EntityPlayer player = (EntityPlayer) owner;
if (LivingArmour.hasFullSet(player)) if (LivingArmour.hasFullSet(player)) {
{
ItemStack chestStack = player.getItemStackFromSlot(EntityEquipmentSlot.CHEST); ItemStack chestStack = player.getItemStackFromSlot(EntityEquipmentSlot.CHEST);
LivingArmour armour = ItemLivingArmour.getLivingArmour(chestStack); LivingArmour armour = ItemLivingArmour.getLivingArmour(chestStack);
if (armour != null) if (armour != null) {
{
LivingArmourUpgrade upgrade = ItemLivingArmour.getUpgrade(BloodMagic.MODID + ".upgrade.stormTrooper", chestStack); LivingArmourUpgrade upgrade = ItemLivingArmour.getUpgrade(BloodMagic.MODID + ".upgrade.stormTrooper", chestStack);
if (upgrade instanceof LivingArmourUpgradeStormTrooper) if (upgrade instanceof LivingArmourUpgradeStormTrooper) {
{
float velocityModifier = (float) (((LivingArmourUpgradeStormTrooper) upgrade).getArrowJiggle(player) * Math.sqrt(projectile.motionX * projectile.motionX + projectile.motionY * projectile.motionY + projectile.motionZ * projectile.motionZ)); float velocityModifier = (float) (((LivingArmourUpgradeStormTrooper) upgrade).getArrowJiggle(player) * Math.sqrt(projectile.motionX * projectile.motionX + projectile.motionY * projectile.motionY + projectile.motionZ * projectile.motionZ));
projectile.motionX += 2 * (event.getWorld().rand.nextDouble() - 0.5) * velocityModifier; projectile.motionX += 2 * (event.getWorld().rand.nextDouble() - 0.5) * velocityModifier;
@ -140,37 +121,28 @@ public class LivingArmourHandler
} }
@SubscribeEvent @SubscribeEvent
public static void onPlayerClick(PlayerInteractEvent event) public static void onPlayerClick(PlayerInteractEvent event) {
{ if (event.isCancelable()) {
if (event.isCancelable())
{
EntityPlayer player = event.getEntityPlayer(); EntityPlayer player = event.getEntityPlayer();
if (LivingArmour.hasFullSet(player)) if (LivingArmour.hasFullSet(player)) {
{
ItemStack chestStack = player.getItemStackFromSlot(EntityEquipmentSlot.CHEST); ItemStack chestStack = player.getItemStackFromSlot(EntityEquipmentSlot.CHEST);
LivingArmour armour = ItemLivingArmour.getLivingArmour(chestStack); LivingArmour armour = ItemLivingArmour.getLivingArmour(chestStack);
if (armour != null) if (armour != null) {
{ if (event.getHand() == EnumHand.OFF_HAND) {
if (event.getHand() == EnumHand.OFF_HAND)
{
LivingArmourUpgrade upgrade = ItemLivingArmour.getUpgrade(BloodMagic.MODID + ".upgrade.crippledArm", chestStack); LivingArmourUpgrade upgrade = ItemLivingArmour.getUpgrade(BloodMagic.MODID + ".upgrade.crippledArm", chestStack);
if (upgrade instanceof LivingArmourUpgradeCrippledArm) if (upgrade instanceof LivingArmourUpgradeCrippledArm) {
{
event.setCanceled(true); event.setCanceled(true);
} }
} }
if (event.getItemStack().getItemUseAction() == EnumAction.DRINK) if (event.getItemStack().getItemUseAction() == EnumAction.DRINK) {
{
ItemStack drinkStack = event.getItemStack(); ItemStack drinkStack = event.getItemStack();
if (!(drinkStack.getItem() instanceof ItemSplashPotion)) if (!(drinkStack.getItem() instanceof ItemSplashPotion)) {
{
LivingArmourUpgrade upgrade = ItemLivingArmour.getUpgrade(BloodMagic.MODID + ".upgrade.quenched", chestStack); LivingArmourUpgrade upgrade = ItemLivingArmour.getUpgrade(BloodMagic.MODID + ".upgrade.quenched", chestStack);
if (upgrade instanceof LivingArmourUpgradeQuenched) if (upgrade instanceof LivingArmourUpgradeQuenched) {
{
event.setCanceled(true); event.setCanceled(true);
} }
} }
@ -182,24 +154,19 @@ public class LivingArmourHandler
// Applies: Grim Reaper // Applies: Grim Reaper
@SubscribeEvent(priority = EventPriority.HIGHEST) @SubscribeEvent(priority = EventPriority.HIGHEST)
public static void onEntityDeath(LivingDeathEvent event) public static void onEntityDeath(LivingDeathEvent event) {
{ if (event.getEntityLiving() instanceof EntityPlayer) {
if (event.getEntityLiving() instanceof EntityPlayer)
{
EntityPlayer player = (EntityPlayer) event.getEntityLiving(); EntityPlayer player = (EntityPlayer) event.getEntityLiving();
if (LivingArmour.hasFullSet(player)) if (LivingArmour.hasFullSet(player)) {
{
ItemStack chestStack = player.getItemStackFromSlot(EntityEquipmentSlot.CHEST); ItemStack chestStack = player.getItemStackFromSlot(EntityEquipmentSlot.CHEST);
LivingArmour armour = ItemLivingArmour.getLivingArmour(chestStack); LivingArmour armour = ItemLivingArmour.getLivingArmour(chestStack);
if (armour != null) if (armour != null) {
{
StatTrackerGrimReaperSprint.incrementCounter(armour); StatTrackerGrimReaperSprint.incrementCounter(armour);
LivingArmourUpgrade upgrade = ItemLivingArmour.getUpgrade(BloodMagic.MODID + ".upgrade.grimReaper", chestStack); LivingArmourUpgrade upgrade = ItemLivingArmour.getUpgrade(BloodMagic.MODID + ".upgrade.grimReaper", chestStack);
if (upgrade instanceof LivingArmourUpgradeGrimReaperSprint && ((LivingArmourUpgradeGrimReaperSprint) upgrade).canSavePlayer(player)) if (upgrade instanceof LivingArmourUpgradeGrimReaperSprint && ((LivingArmourUpgradeGrimReaperSprint) upgrade).canSavePlayer(player)) {
{
((LivingArmourUpgradeGrimReaperSprint) upgrade).applyEffectOnRebirth(player); ((LivingArmourUpgradeGrimReaperSprint) upgrade).applyEffectOnRebirth(player);
event.setCanceled(true); event.setCanceled(true);
event.setResult(Event.Result.DENY); event.setResult(Event.Result.DENY);
@ -213,26 +180,20 @@ public class LivingArmourHandler
// Applies: Jump // Applies: Jump
@SubscribeEvent @SubscribeEvent
public static void onJumpEvent(LivingEvent.LivingJumpEvent event) public static void onJumpEvent(LivingEvent.LivingJumpEvent event) {
{ if (event.getEntityLiving() instanceof EntityPlayer) {
if (event.getEntityLiving() instanceof EntityPlayer)
{
EntityPlayer player = (EntityPlayer) event.getEntityLiving(); EntityPlayer player = (EntityPlayer) event.getEntityLiving();
if (LivingArmour.hasFullSet(player)) if (LivingArmour.hasFullSet(player)) {
{
ItemStack chestStack = player.getItemStackFromSlot(EntityEquipmentSlot.CHEST); ItemStack chestStack = player.getItemStackFromSlot(EntityEquipmentSlot.CHEST);
LivingArmour armour = ItemLivingArmour.getLivingArmour(chestStack); LivingArmour armour = ItemLivingArmour.getLivingArmour(chestStack);
if (armour != null) if (armour != null) {
{
StatTrackerJump.incrementCounter(armour); StatTrackerJump.incrementCounter(armour);
if (!player.isSneaking()) if (!player.isSneaking()) {
{
LivingArmourUpgrade upgrade = ItemLivingArmour.getUpgradeFromNBT(BloodMagic.MODID + ".upgrade.jump", chestStack); LivingArmourUpgrade upgrade = ItemLivingArmour.getUpgradeFromNBT(BloodMagic.MODID + ".upgrade.jump", chestStack);
if (upgrade instanceof LivingArmourUpgradeJump) if (upgrade instanceof LivingArmourUpgradeJump) {
{
player.motionY += ((LivingArmourUpgradeJump) upgrade).getJumpModifier(); player.motionY += ((LivingArmourUpgradeJump) upgrade).getJumpModifier();
} }
} }
@ -243,34 +204,25 @@ public class LivingArmourHandler
// Applies: Step Assist, Speed Boost // Applies: Step Assist, Speed Boost
@SubscribeEvent(priority = EventPriority.HIGHEST) @SubscribeEvent(priority = EventPriority.HIGHEST)
public static void onEntityUpdate(LivingEvent.LivingUpdateEvent event) public static void onEntityUpdate(LivingEvent.LivingUpdateEvent event) {
{ if (event.getEntityLiving() instanceof EntityPlayer) {
if (event.getEntityLiving() instanceof EntityPlayer)
{
EntityPlayer player = (EntityPlayer) event.getEntityLiving(); EntityPlayer player = (EntityPlayer) event.getEntityLiving();
boolean hasAssist = false; boolean hasAssist = false;
if (event.getEntityLiving().isPotionActive(RegistrarBloodMagic.BOOST)) if (event.getEntityLiving().isPotionActive(RegistrarBloodMagic.BOOST)) {
{
hasAssist = true; hasAssist = true;
player.stepHeight = Constants.Misc.ALTERED_STEP_HEIGHT; player.stepHeight = Constants.Misc.ALTERED_STEP_HEIGHT;
} else } else {
{ if (LivingArmour.hasFullSet(player)) {
if (LivingArmour.hasFullSet(player))
{
ItemStack chestStack = player.getItemStackFromSlot(EntityEquipmentSlot.CHEST); ItemStack chestStack = player.getItemStackFromSlot(EntityEquipmentSlot.CHEST);
LivingArmour armour = ItemLivingArmour.getLivingArmourFromStack(chestStack); LivingArmour armour = ItemLivingArmour.getLivingArmourFromStack(chestStack);
if (armour != null) if (armour != null) {
{
LivingArmourUpgrade upgrade = ItemLivingArmour.getUpgrade(BloodMagic.MODID + ".upgrade.stepAssist", chestStack); LivingArmourUpgrade upgrade = ItemLivingArmour.getUpgrade(BloodMagic.MODID + ".upgrade.stepAssist", chestStack);
if (upgrade instanceof LivingArmourUpgradeStepAssist) if (upgrade instanceof LivingArmourUpgradeStepAssist) {
{ if (!player.isSneaking()) {
if (!player.isSneaking())
{
player.stepHeight = ((LivingArmourUpgradeStepAssist) upgrade).getStepAssist(); player.stepHeight = ((LivingArmourUpgradeStepAssist) upgrade).getStepAssist();
hasAssist = true; hasAssist = true;
} else } else {
{
player.stepHeight = 0.6F; player.stepHeight = 0.6F;
} }
} }
@ -283,31 +235,26 @@ public class LivingArmourHandler
float percentIncrease = 0; float percentIncrease = 0;
if (LivingArmour.hasFullSet(player)) if (LivingArmour.hasFullSet(player)) {
{
ItemStack chestStack = player.getItemStackFromSlot(EntityEquipmentSlot.CHEST); ItemStack chestStack = player.getItemStackFromSlot(EntityEquipmentSlot.CHEST);
LivingArmour armour = ItemLivingArmour.getLivingArmourFromStack(chestStack); LivingArmour armour = ItemLivingArmour.getLivingArmourFromStack(chestStack);
if (armour != null) if (armour != null) {
{
LivingArmourUpgrade upgrade = ItemLivingArmour.getUpgradeFromNBT(BloodMagic.MODID + ".upgrade.movement", chestStack); LivingArmourUpgrade upgrade = ItemLivingArmour.getUpgradeFromNBT(BloodMagic.MODID + ".upgrade.movement", chestStack);
if (upgrade instanceof LivingArmourUpgradeSpeed) if (upgrade instanceof LivingArmourUpgradeSpeed) {
{
percentIncrease += ((LivingArmourUpgradeSpeed) upgrade).getSpeedModifier(); percentIncrease += ((LivingArmourUpgradeSpeed) upgrade).getSpeedModifier();
} }
} }
} }
if (event.getEntityLiving().isPotionActive(RegistrarBloodMagic.BOOST)) if (event.getEntityLiving().isPotionActive(RegistrarBloodMagic.BOOST)) {
{
int i = event.getEntityLiving().getActivePotionEffect(RegistrarBloodMagic.BOOST).getAmplifier(); int i = event.getEntityLiving().getActivePotionEffect(RegistrarBloodMagic.BOOST).getAmplifier();
{ {
percentIncrease += (i + 1) * 0.5f; percentIncrease += (i + 1) * 0.5f;
} }
} }
if (percentIncrease > 0 && (player.onGround || player.capabilities.isFlying) && (Math.abs(player.moveForward) > 0 || Math.abs(player.moveStrafing) > 0)) if (percentIncrease > 0 && (player.onGround || player.capabilities.isFlying) && (Math.abs(player.moveForward) > 0 || Math.abs(player.moveStrafing) > 0)) {
{
player.travel(player.moveStrafing * percentIncrease, 0, player.moveForward * percentIncrease); player.travel(player.moveStrafing * percentIncrease, 0, player.moveForward * percentIncrease);
} }
} }
@ -316,8 +263,7 @@ public class LivingArmourHandler
// Applies: Arrow Shot // Applies: Arrow Shot
// Tracks: Arrow Shot // Tracks: Arrow Shot
@SubscribeEvent @SubscribeEvent
public static void onArrowFire(ArrowLooseEvent event) public static void onArrowFire(ArrowLooseEvent event) {
{
World world = event.getEntityPlayer().getEntityWorld(); World world = event.getEntityPlayer().getEntityWorld();
ItemStack stack = event.getBow(); ItemStack stack = event.getBow();
EntityPlayer player = event.getEntityPlayer(); EntityPlayer player = event.getEntityPlayer();
@ -326,17 +272,14 @@ public class LivingArmourHandler
if (world.isRemote) if (world.isRemote)
return; return;
if (LivingArmour.hasFullSet(player)) if (LivingArmour.hasFullSet(player)) {
{
ItemStack chestStack = player.getItemStackFromSlot(EntityEquipmentSlot.CHEST); ItemStack chestStack = player.getItemStackFromSlot(EntityEquipmentSlot.CHEST);
LivingArmour armour = ItemLivingArmour.getLivingArmour(chestStack); LivingArmour armour = ItemLivingArmour.getLivingArmour(chestStack);
if (armour != null) if (armour != null) {
{
StatTrackerArrowShot.incrementCounter(armour); StatTrackerArrowShot.incrementCounter(armour);
LivingArmourUpgrade upgrade = ItemLivingArmour.getUpgrade(BloodMagic.MODID + ".upgrade.arrowShot", chestStack); LivingArmourUpgrade upgrade = ItemLivingArmour.getUpgrade(BloodMagic.MODID + ".upgrade.arrowShot", chestStack);
if (upgrade instanceof LivingArmourUpgradeArrowShot) if (upgrade instanceof LivingArmourUpgradeArrowShot) {
{
int charge = event.getCharge(); int charge = event.getCharge();
float velocity = (float) charge / 20.0F; float velocity = (float) charge / 20.0F;
velocity = (velocity * velocity + velocity * 2.0F) / 3.0F; velocity = (velocity * velocity + velocity * 2.0F) / 3.0F;
@ -350,8 +293,7 @@ public class LivingArmourHandler
sentientShot = true; sentientShot = true;
} }
int extraArrows = ((LivingArmourUpgradeArrowShot) upgrade).getExtraArrows(); int extraArrows = ((LivingArmourUpgradeArrowShot) upgrade).getExtraArrows();
for (int n = 0; n < extraArrows; n++) for (int n = 0; n < extraArrows; n++) {
{
ItemStack arrowStack = new ItemStack(Items.ARROW); ItemStack arrowStack = new ItemStack(Items.ARROW);
ItemArrow itemarrow = (ItemArrow) ((stack.getItem() instanceof ItemArrow ? arrowStack.getItem() : Items.ARROW)); ItemArrow itemarrow = (ItemArrow) ((stack.getItem() instanceof ItemArrow ? arrowStack.getItem() : Items.ARROW));
EntityArrow entityarrow; EntityArrow entityarrow;
@ -392,21 +334,19 @@ public class LivingArmourHandler
} }
} }
} }
} }
// Applies: Softfall // Applies: Softfall
@SubscribeEvent @SubscribeEvent
public static void onPlayerFall(LivingFallEvent event) { public static void onPlayerFall(LivingFallEvent event) {
if (event.getEntityLiving() instanceof EntityPlayer) if (event.getEntityLiving() instanceof EntityPlayer) {
{
EntityPlayer player = (EntityPlayer) event.getEntityLiving(); EntityPlayer player = (EntityPlayer) event.getEntityLiving();
if (LivingArmour.hasFullSet(player)) if (LivingArmour.hasFullSet(player)) {
{
ItemStack chestStack = player.getItemStackFromSlot(EntityEquipmentSlot.CHEST); ItemStack chestStack = player.getItemStackFromSlot(EntityEquipmentSlot.CHEST);
LivingArmour armour = ItemLivingArmour.getLivingArmour(chestStack); LivingArmour armour = ItemLivingArmour.getLivingArmour(chestStack);
if (armour != null) if (armour != null) {
{
StatTrackerFallProtect.incrementCounter(armour, event.getDamageMultiplier() * (event.getDistance() - 3)); StatTrackerFallProtect.incrementCounter(armour, event.getDamageMultiplier() * (event.getDistance() - 3));
LivingArmourUpgrade upgrade = ItemLivingArmour.getUpgrade(BloodMagic.MODID + ".upgrade.fallProtect", chestStack); LivingArmourUpgrade upgrade = ItemLivingArmour.getUpgrade(BloodMagic.MODID + ".upgrade.fallProtect", chestStack);
if (upgrade instanceof LivingArmourUpgradeFallProtect) { if (upgrade instanceof LivingArmourUpgradeFallProtect) {
@ -417,17 +357,14 @@ public class LivingArmourHandler
} }
} }
} }
// Applies: Arrow Shot // Applies: Arrow Shot
@SubscribeEvent @SubscribeEvent
public static void onProjectileImpact(ProjectileImpactEvent.Arrow event) public static void onProjectileImpact(ProjectileImpactEvent.Arrow event) {
{ if (event.getArrow().removeTag("arrow_shot")) {
if (event.getArrow().removeTag("arrow_shot"))
{
Entity entity = event.getRayTraceResult().entityHit; Entity entity = event.getRayTraceResult().entityHit;
if (entity != null) if (entity != null) {
{
entity.hurtResistantTime = 0; entity.hurtResistantTime = 0;
} }
} }

3
src/main/java/WayofTime/bloodmagic/util/helper/IncenseHelper.java
View file

@ -21,7 +21,7 @@ public class IncenseHelper {
data.setDouble(Constants.NBT.CURRENT_INCENSE, amount); data.setDouble(Constants.NBT.CURRENT_INCENSE, amount);
} }
public static void setMaxIncense(EntityPlayer player, double amount){ public static void setMaxIncense(EntityPlayer player, double amount) {
NBTTagCompound data = player.getEntityData(); NBTTagCompound data = player.getEntityData();
data.setDouble(Constants.NBT.MAX_INCENSE, amount); data.setDouble(Constants.NBT.MAX_INCENSE, amount);
} }
@ -38,6 +38,7 @@ public class IncenseHelper {
stack = NBTHelper.checkNBT(stack); stack = NBTHelper.checkNBT(stack);
stack.getTagCompound().setBoolean(Constants.NBT.HAS_MAX_INCENSE, isMax); stack.getTagCompound().setBoolean(Constants.NBT.HAS_MAX_INCENSE, isMax);
} }
public static boolean getHasMaxIncense(ItemStack stack) { public static boolean getHasMaxIncense(ItemStack stack) {
stack = NBTHelper.checkNBT(stack); stack = NBTHelper.checkNBT(stack);
return stack.getTagCompound().getBoolean(Constants.NBT.HAS_MAX_INCENSE); return stack.getTagCompound().getBoolean(Constants.NBT.HAS_MAX_INCENSE);

9
src/main/java/WayofTime/bloodmagic/util/helper/NetworkHelper.java
View file

@ -115,12 +115,11 @@ public class NetworkHelper {
/** /**
* Syphons a player from within a container. * Syphons a player from within a container.
* *
* @param stack - ItemStack in the Container. * @param stack - ItemStack in the Container.
* @param ticket - SoulTicket to syphon * @param ticket - SoulTicket to syphon
* @return - If the syphon was successful. * @return - If the syphon was successful.
*/ */
public static boolean syphonFromContainer(ItemStack stack, SoulTicket ticket) public static boolean syphonFromContainer(ItemStack stack, SoulTicket ticket) {
{
if (!(stack.getItem() instanceof IBindable)) if (!(stack.getItem() instanceof IBindable))
return false; return false;
@ -131,7 +130,7 @@ public class NetworkHelper {
SoulNetwork network = getSoulNetwork(binding); SoulNetwork network = getSoulNetwork(binding);
SoulNetworkEvent.Syphon.Item event = new SoulNetworkEvent.Syphon.Item(network, ticket, stack); SoulNetworkEvent.Syphon.Item event = new SoulNetworkEvent.Syphon.Item(network, ticket, stack);
return !MinecraftForge.EVENT_BUS.post(event) && network.syphon(event.getTicket(),true) >= ticket.getAmount(); return !MinecraftForge.EVENT_BUS.post(event) && network.syphon(event.getTicket(), true) >= ticket.getAmount();
} }
/** /**

2
src/main/java/WayofTime/bloodmagic/util/helper/PlayerSacrificeHelper.java
View file

@ -35,7 +35,7 @@ public class PlayerSacrificeHelper {
amount = amount + Math.min(increment, incenseAddition - amount); amount = amount + Math.min(increment, incenseAddition - amount);
setPlayerIncense(player, amount); setPlayerIncense(player, amount);
if(amount == incenseAddition) { if (amount == incenseAddition) {
IncenseHelper.setMaxIncense(player, incenseAddition); IncenseHelper.setMaxIncense(player, incenseAddition);
} }
// System.out.println("Amount of incense: " + amount + ", Increment: " + // System.out.println("Amount of incense: " + amount + ", Increment: " +