/** * This class was created by . It's distributed as * part of the Botania Mod. Get the Source Code in github: * https://github.com/Vazkii/Botania * * Botania is Open Source and distributed under the * Botania License: http://botaniamod.net/license.php * * File Created @ [Jan 26, 2014, 5:09:12 PM (GMT)] */ package vazkii.botania.common.entity; import java.awt.Color; import java.util.ArrayList; import java.util.HashSet; import java.util.List; import java.util.Objects; import java.util.Random; import java.util.Set; import java.util.UUID; import javax.annotation.Nonnull; import net.minecraft.block.Block; import net.minecraft.block.BlockBush; import net.minecraft.block.BlockLeaves; import net.minecraft.block.state.IBlockState; import net.minecraft.entity.Entity; import net.minecraft.entity.EntityType; import net.minecraft.entity.player.EntityPlayer; import net.minecraft.entity.projectile.EntityThrowable; import net.minecraft.init.Blocks; import net.minecraft.init.Particles; import net.minecraft.item.ItemStack; import net.minecraft.nbt.NBTTagCompound; import net.minecraft.network.datasync.DataParameter; import net.minecraft.network.datasync.DataSerializers; import net.minecraft.network.datasync.EntityDataManager; import net.minecraft.tileentity.TileEntity; import net.minecraft.util.EnumHand; import net.minecraft.util.math.AxisAlignedBB; import net.minecraft.util.math.BlockPos; import net.minecraft.util.math.MathHelper; import net.minecraft.util.math.RayTraceResult; import net.minecraft.util.math.Vec3d; import net.minecraft.world.World; import net.minecraftforge.api.distmarker.Dist; import net.minecraftforge.api.distmarker.OnlyIn; import net.minecraftforge.registries.ObjectHolder; import vazkii.botania.api.BotaniaAPI; import vazkii.botania.api.internal.IManaBurst; import vazkii.botania.api.internal.VanillaPacketDispatcher; import vazkii.botania.api.mana.IClientManaHandler; import vazkii.botania.api.mana.ILensEffect; import vazkii.botania.api.mana.IManaCollector; import vazkii.botania.api.mana.IManaCollisionGhost; import vazkii.botania.api.mana.IManaReceiver; import vazkii.botania.api.mana.IManaSpreader; import vazkii.botania.api.mana.IManaTrigger; import vazkii.botania.api.mana.IPingable; import vazkii.botania.api.mana.IThrottledPacket; import vazkii.botania.common.Botania; import vazkii.botania.common.core.handler.ConfigHandler; import vazkii.botania.common.core.helper.Vector3; import vazkii.botania.common.item.equipment.bauble.ItemTinyPlanet; import vazkii.botania.common.lib.LibMisc; public class EntityManaBurst extends EntityThrowable implements IManaBurst { @ObjectHolder(LibMisc.MOD_ID + ":mana_burst") public static EntityType TYPE; private static final String TAG_TICKS_EXISTED = "ticksExisted"; private static final String TAG_COLOR = "color"; private static final String TAG_MANA = "mana"; private static final String TAG_STARTING_MANA = "startingMana"; private static final String TAG_MIN_MANA_LOSS = "minManaLoss"; private static final String TAG_TICK_MANA_LOSS = "manaLossTick"; private static final String TAG_SPREADER_X = "spreaderX"; private static final String TAG_SPREADER_Y = "spreaderY"; private static final String TAG_SPREADER_Z = "spreaderZ"; private static final String TAG_GRAVITY = "gravity"; private static final String TAG_LENS_STACK = "lensStack"; private static final String TAG_LAST_MOTION_X = "lastMotionX"; private static final String TAG_LAST_MOTION_Y = "lastMotionY"; private static final String TAG_LAST_MOTION_Z = "lastMotionZ"; private static final String TAG_HAS_SHOOTER = "hasShooter"; private static final String TAG_SHOOTER_UUID_MOST = "shooterUUIDMost"; private static final String TAG_SHOOTER_UUID_LEAST = "shooterUUIDLeast"; private static final DataParameter COLOR = EntityDataManager.createKey(EntityManaBurst.class, DataSerializers.VARINT); private static final DataParameter MANA = EntityDataManager.createKey(EntityManaBurst.class, DataSerializers.VARINT); private static final DataParameter START_MANA = EntityDataManager.createKey(EntityManaBurst.class, DataSerializers.VARINT); private static final DataParameter MIN_MANA_LOSS = EntityDataManager.createKey(EntityManaBurst.class, DataSerializers.VARINT); private static final DataParameter MANA_LOSS_PER_TICK = EntityDataManager.createKey(EntityManaBurst.class, DataSerializers.FLOAT); private static final DataParameter GRAVITY = EntityDataManager.createKey(EntityManaBurst.class, DataSerializers.FLOAT); private static final DataParameter SOURCE_COORDS = EntityDataManager.createKey(EntityManaBurst.class, DataSerializers.BLOCK_POS); private static final DataParameter SOURCE_LENS = EntityDataManager.createKey(EntityManaBurst.class, DataSerializers.ITEM_STACK); float accumulatedManaLoss = 0; boolean fake = false; final Set alreadyCollidedAt = new HashSet<>(); boolean fullManaLastTick = true; UUID shooterIdentity = null; int _ticksExisted = 0; boolean scanBeam = false; public final List propsList = new ArrayList<>(); public EntityManaBurst(World world) { super(TYPE, world); setSize(0F, 0F); } @Override protected void registerData() { super.registerData(); dataManager.register(COLOR, 0); dataManager.register(MANA, 0); dataManager.register(START_MANA, 0); dataManager.register(MIN_MANA_LOSS, 0); dataManager.register(MANA_LOSS_PER_TICK, 0F); dataManager.register(GRAVITY, 0F); dataManager.register(SOURCE_COORDS, BlockPos.ORIGIN); dataManager.register(SOURCE_LENS, ItemStack.EMPTY); } public EntityManaBurst(IManaSpreader spreader, boolean fake) { this(((TileEntity)spreader).getWorld()); TileEntity tile = (TileEntity) spreader; this.fake = fake; setBurstSourceCoords(tile.getPos()); setLocationAndAngles(tile.getPos().getX() + 0.5, tile.getPos().getY() + 0.5, tile.getPos().getZ() + 0.5, 0, 0); rotationYaw = -(spreader.getRotationX() + 90F); rotationPitch = spreader.getRotationY(); float f = 0.4F; double mx = MathHelper.sin(rotationYaw / 180.0F * (float) Math.PI) * MathHelper.cos(rotationPitch / 180.0F * (float) Math.PI) * f / 2D; double mz = -(MathHelper.cos(rotationYaw / 180.0F * (float) Math.PI) * MathHelper.cos(rotationPitch / 180.0F * (float) Math.PI) * f) / 2D; double my = MathHelper.sin(rotationPitch / 180.0F * (float) Math.PI) * f / 2D; setMotion(mx, my, mz); } public EntityManaBurst(EntityPlayer player, EnumHand hand) { this(player.world); setBurstSourceCoords(new BlockPos(0, -1, 0)); setLocationAndAngles(player.posX, player.posY + player.getEyeHeight(), player.posZ, player.rotationYaw + 180, -player.rotationPitch); posX -= (hand == EnumHand.OFF_HAND ? -1 : 1) * MathHelper.cos((rotationYaw + 180) / 180.0F * (float) Math.PI) * 0.16F; posY -= 0.10000000149011612D; posZ -= (hand == EnumHand.OFF_HAND ? -1 : 1) * MathHelper.sin((rotationYaw + 180) / 180.0F * (float) Math.PI) * 0.16F; setPosition(posX, posY, posZ); float f = 0.4F; double mx = MathHelper.sin(rotationYaw / 180.0F * (float) Math.PI) * MathHelper.cos(rotationPitch / 180.0F * (float) Math.PI) * f / 2D; double mz = -(MathHelper.cos(rotationYaw / 180.0F * (float) Math.PI) * MathHelper.cos(rotationPitch / 180.0F * (float) Math.PI) * f) / 2D; double my = MathHelper.sin(rotationPitch / 180.0F * (float) Math.PI) * f / 2D; setMotion(mx, my, mz); } private void superUpdate() { this.lastTickPosX = this.posX; this.lastTickPosY = this.posY; this.lastTickPosZ = this.posZ; // Botania - inline supersuperclass.tick() { if (!this.world.isRemote) { this.setFlag(6, this.isGlowing()); } this.baseTick(); } if (this.throwableShake > 0) { --this.throwableShake; } if (this.inGround) { this.inGround = false; this.motionX *= (double)(this.rand.nextFloat() * 0.2F); this.motionY *= (double)(this.rand.nextFloat() * 0.2F); this.motionZ *= (double)(this.rand.nextFloat() * 0.2F); } Vec3d vec3d = new Vec3d(this.posX, this.posY, this.posZ); Vec3d vec3d1 = new Vec3d(this.posX + this.motionX, this.posY + this.motionY, this.posZ + this.motionZ); RayTraceResult raytraceresult = this.world.rayTraceBlocks(vec3d, vec3d1); vec3d = new Vec3d(this.posX, this.posY, this.posZ); vec3d1 = new Vec3d(this.posX + this.motionX, this.posY + this.motionY, this.posZ + this.motionZ); if (raytraceresult != null) { vec3d1 = new Vec3d(raytraceresult.hitVec.x, raytraceresult.hitVec.y, raytraceresult.hitVec.z); } if (!scanBeam && !world.isRemote) { // Botania - collide only on server and non-scanbeam Entity entity = null; List list = this.world.getEntitiesWithinAABBExcludingEntity(this, this.getBoundingBox().expand(this.motionX, this.motionY, this.motionZ).grow(1.0D)); double d0 = 0.0D; boolean flag = false; for (int i = 0; i < list.size(); ++i) { Entity entity1 = list.get(i); if (entity1.canBeCollidedWith()) { if (entity1 == this.ignoreEntity) { flag = true; } else if (this.thrower != null && this.ticksExisted < 2 && this.ignoreEntity == null) { this.ignoreEntity = entity1; flag = true; } else { flag = false; AxisAlignedBB axisalignedbb = entity1.getBoundingBox().grow((double) 0.3F); RayTraceResult raytraceresult1 = axisalignedbb.calculateIntercept(vec3d, vec3d1); if (raytraceresult1 != null) { double d1 = vec3d.squareDistanceTo(raytraceresult1.hitVec); if (d1 < d0 || d0 == 0.0D) { entity = entity1; d0 = d1; } } } } } if (this.ignoreEntity != null) { /* if (flag) { this.ignoreTime = 2; } else if (this.ignoreTime-- <= 0) { this.ignoreEntity = null; } */ } if (entity != null) { raytraceresult = new RayTraceResult(entity); } } if (raytraceresult != null) { if (raytraceresult.type == RayTraceResult.Type.BLOCK && this.world.getBlockState(raytraceresult.getBlockPos()).getBlock() == Blocks.NETHER_PORTAL) { this.setPortal(raytraceresult.getBlockPos()); } else if (!net.minecraftforge.event.ForgeEventFactory.onProjectileImpact(this, raytraceresult)){ this.onImpact(raytraceresult); } } this.posX += this.motionX; this.posY += this.motionY; this.posZ += this.motionZ; float f = MathHelper.sqrt(this.motionX * this.motionX + this.motionZ * this.motionZ); this.rotationYaw = (float)(MathHelper.atan2(this.motionX, this.motionZ) * (double)(180F / (float)Math.PI)); for(this.rotationPitch = (float)(MathHelper.atan2(this.motionY, (double)f) * (double)(180F / (float)Math.PI)); this.rotationPitch - this.prevRotationPitch < -180.0F; this.prevRotationPitch -= 360.0F) { ; } while(this.rotationPitch - this.prevRotationPitch >= 180.0F) { this.prevRotationPitch += 360.0F; } while(this.rotationYaw - this.prevRotationYaw < -180.0F) { this.prevRotationYaw -= 360.0F; } while(this.rotationYaw - this.prevRotationYaw >= 180.0F) { this.prevRotationYaw += 360.0F; } this.rotationPitch = this.prevRotationPitch + (this.rotationPitch - this.prevRotationPitch) * 0.2F; this.rotationYaw = this.prevRotationYaw + (this.rotationYaw - this.prevRotationYaw) * 0.2F; float f1 = 0.99F; float f2 = this.getGravityVelocity(); if (this.isInWater()) { for(int j = 0; j < 4; ++j) { float f3 = 0.25F; this.world.addParticle(Particles.BUBBLE, this.posX - this.motionX * 0.25D, this.posY - this.motionY * 0.25D, this.posZ - this.motionZ * 0.25D, this.motionX, this.motionY, this.motionZ); } f1 = 0.8F; } /* Botania - no drag this.motionX *= (double)f1; this.motionY *= (double)f1; this.motionZ *= (double)f1; */ if (!this.hasNoGravity()) { this.motionY -= (double)f2; } this.setPosition(this.posX, this.posY, this.posZ); } @Override public void tick() { setTicksExisted(getTicksExisted() + 1); superUpdate(); if(!fake && isAlive() && !scanBeam) ping(); ILensEffect lens = getLensInstance(); if(lens != null) lens.updateBurst(this, getSourceLens()); int mana = getMana(); if(getTicksExisted() >= getMinManaLoss()) { accumulatedManaLoss += getManaLossPerTick(); int loss = (int) accumulatedManaLoss; setMana(mana - loss); accumulatedManaLoss -= loss; if(getMana() <= 0) remove(); } particles(); setMotion(motionX, motionY, motionZ); fullManaLastTick = getMana() == getStartingMana(); if(scanBeam) { PositionProperties props = new PositionProperties(this); if(propsList.isEmpty()) propsList.add(props); else { PositionProperties lastProps = propsList.get(propsList.size() - 1); if(!props.coordsEqual(lastProps)) propsList.add(props); } } } @Override @OnlyIn(Dist.CLIENT) public void setPositionAndRotationDirect(double x, double y, double z, float yaw, float pitch, int posRotationIncrements, boolean teleport) { setPosition(x, y, z); setRotation(yaw, pitch); } @Override public boolean handleWaterMovement() { return false; } @Override public boolean isInLava() { //Avoids expensive getBlockState check in Entity#onEntityUpdate (see super impl) return false; } private TileEntity collidedTile = null; private boolean noParticles = false; public TileEntity getCollidedTile(boolean noParticles) { this.noParticles = noParticles; int iterations = 0; while(isAlive() && iterations < ConfigHandler.spreaderTraceTime) { tick(); iterations++; } if(fake) incrementFakeParticleTick(); return collidedTile; } @Override public void writeAdditional(NBTTagCompound par1nbtTagCompound) { super.writeAdditional(par1nbtTagCompound); par1nbtTagCompound.putInt(TAG_TICKS_EXISTED, getTicksExisted()); par1nbtTagCompound.putInt(TAG_COLOR, getColor()); par1nbtTagCompound.putInt(TAG_MANA, getMana()); par1nbtTagCompound.putInt(TAG_STARTING_MANA, getStartingMana()); par1nbtTagCompound.putInt(TAG_MIN_MANA_LOSS, getMinManaLoss()); par1nbtTagCompound.putFloat(TAG_TICK_MANA_LOSS, getManaLossPerTick()); par1nbtTagCompound.putFloat(TAG_GRAVITY, getGravity()); ItemStack stack = getSourceLens(); NBTTagCompound lensCmp = new NBTTagCompound(); if(!stack.isEmpty()) lensCmp = stack.write(lensCmp); par1nbtTagCompound.put(TAG_LENS_STACK, lensCmp); BlockPos coords = getBurstSourceBlockPos(); par1nbtTagCompound.putInt(TAG_SPREADER_X, coords.getX()); par1nbtTagCompound.putInt(TAG_SPREADER_Y, coords.getY()); par1nbtTagCompound.putInt(TAG_SPREADER_Z, coords.getZ()); par1nbtTagCompound.putDouble(TAG_LAST_MOTION_X, motionX); par1nbtTagCompound.putDouble(TAG_LAST_MOTION_Y, motionY); par1nbtTagCompound.putDouble(TAG_LAST_MOTION_Z, motionZ); UUID identity = getShooterUUID(); boolean hasShooter = identity != null; par1nbtTagCompound.putBoolean(TAG_HAS_SHOOTER, hasShooter); if(hasShooter) { par1nbtTagCompound.putLong(TAG_SHOOTER_UUID_MOST, identity.getMostSignificantBits()); par1nbtTagCompound.putLong(TAG_SHOOTER_UUID_LEAST, identity.getLeastSignificantBits()); } } @Override public void readAdditional(NBTTagCompound cmp) { super.readAdditional(cmp); setTicksExisted(cmp.getInt(TAG_TICKS_EXISTED)); setColor(cmp.getInt(TAG_COLOR)); setMana(cmp.getInt(TAG_MANA)); setStartingMana(cmp.getInt(TAG_STARTING_MANA)); setMinManaLoss(cmp.getInt(TAG_MIN_MANA_LOSS)); setManaLossPerTick(cmp.getFloat(TAG_TICK_MANA_LOSS)); setGravity(cmp.getFloat(TAG_GRAVITY)); NBTTagCompound lensCmp = cmp.getCompound(TAG_LENS_STACK); ItemStack stack = ItemStack.read(lensCmp); if(!stack.isEmpty()) setSourceLens(stack); else setSourceLens(ItemStack.EMPTY); int x = cmp.getInt(TAG_SPREADER_X); int y = cmp.getInt(TAG_SPREADER_Y); int z = cmp.getInt(TAG_SPREADER_Z); setBurstSourceCoords(new BlockPos(x, y, z)); double lastMotionX = cmp.getDouble(TAG_LAST_MOTION_X); double lastMotionY = cmp.getDouble(TAG_LAST_MOTION_Y); double lastMotionZ = cmp.getDouble(TAG_LAST_MOTION_Z); setMotion(lastMotionX, lastMotionY, lastMotionZ); boolean hasShooter = cmp.getBoolean(TAG_HAS_SHOOTER); if(hasShooter) { long most = cmp.getLong(TAG_SHOOTER_UUID_MOST); long least = cmp.getLong(TAG_SHOOTER_UUID_LEAST); UUID identity = getShooterUUID(); if(identity == null || most != identity.getMostSignificantBits() || least != identity.getLeastSignificantBits()) shooterIdentity = new UUID(most, least); } } public void particles() { if(!isAlive() || !world.isRemote) return; ILensEffect lens = getLensInstance(); if(lens != null && !lens.doParticles(this, getSourceLens())) return; Color color = new Color(getColor()); float r = color.getRed() / 255F; float g = color.getGreen() / 255F; float b = color.getBlue() / 255F; float osize = getParticleSize(); float size = osize; if(fake) { if(getMana() == getStartingMana()) size = 2F; else if(fullManaLastTick) size = 4F; if(!noParticles && shouldDoFakeParticles()) Botania.proxy.sparkleFX(posX, posY, posZ, r, g, b, 0.4F * size, 1, true); } else { boolean monocle = Botania.proxy.isClientPlayerWearingMonocle(); if(monocle) Botania.proxy.setWispFXDepthTest(false); if(ConfigHandler.subtlePowerSystem) Botania.proxy.wispFX(posX, posY, posZ, r, g, b, 0.1F * size, (float) (Math.random() - 0.5F) * 0.02F, (float) (Math.random() - 0.5F) * 0.02F, (float) (Math.random() - 0.5F) * 0.01F); else { float or = r; float og = g; float ob = b; double luminance = 0.2126 * r + 0.7152 * g + 0.0722 * b; // Standard relative luminance calculation double savedPosX = posX; double savedPosY = posY; double savedPosZ = posZ; Vector3 currentPos = Vector3.fromEntity(this); Vector3 oldPos = new Vector3(prevPosX, prevPosY, prevPosZ); Vector3 diffVec = oldPos.subtract(currentPos); Vector3 diffVecNorm = diffVec.normalize(); double distance = 0.095; do { if (luminance < 0.1) { r = or + (float) Math.random() * 0.125F; g = og + (float) Math.random() * 0.125F; b = ob + (float) Math.random() * 0.125F; } size = osize + ((float) Math.random() - 0.5F) * 0.065F + (float) Math.sin(new Random(entityUniqueID.getMostSignificantBits()).nextInt(9001)) * 0.4F; Botania.proxy.wispFX(posX, posY, posZ, r, g, b, 0.2F * size, (float) -motionX * 0.01F, (float) -motionY * 0.01F, (float) -motionZ * 0.01F); posX += diffVecNorm.x * distance; posY += diffVecNorm.y * distance; posZ += diffVecNorm.z * distance; currentPos = Vector3.fromEntity(this); diffVec = oldPos.subtract(currentPos); if(getEntityData().contains(ItemTinyPlanet.TAG_ORBIT)) break; } while(Math.abs(diffVec.mag()) > distance); Botania.proxy.wispFX(posX, posY, posZ, or, og, ob, 0.1F * size, (float) (Math.random() - 0.5F) * 0.06F, (float) (Math.random() - 0.5F) * 0.06F, (float) (Math.random() - 0.5F) * 0.06F); posX = savedPosX; posY = savedPosY; posZ = savedPosZ; } if(monocle) Botania.proxy.setWispFXDepthTest(true); } } public float getParticleSize() { return (float) getMana() / (float) getStartingMana(); } @Override protected void onImpact(@Nonnull RayTraceResult rtr) { boolean collided = false; boolean dead = false; if(rtr.entity == null) { TileEntity tile = world.getTileEntity(rtr.getBlockPos()); IBlockState state = world.getBlockState(rtr.getBlockPos()); Block block = state.getBlock(); if(block instanceof IManaCollisionGhost && ((IManaCollisionGhost) block).isGhost(state, world, rtr.getBlockPos()) && !(block instanceof IManaTrigger) || block instanceof BlockBush || block instanceof BlockLeaves) return; if(BotaniaAPI.internalHandler.isBuildcraftPipe(tile)) return; BlockPos coords = getBurstSourceBlockPos(); if(tile != null && !tile.getPos().equals(coords)) collidedTile = tile; if(tile == null || !tile.getPos().equals(coords)) { if(!fake && !noParticles && (!world.isRemote || tile instanceof IClientManaHandler) && tile != null && tile instanceof IManaReceiver && ((IManaReceiver) tile).canRecieveManaFromBursts()) onRecieverImpact((IManaReceiver) tile, tile.getPos()); if(block instanceof IManaTrigger) ((IManaTrigger) block).onBurstCollision(this, world, rtr.getBlockPos()); boolean ghost = block instanceof IManaCollisionGhost; dead = !ghost; if(ghost) return; } collided = true; } ILensEffect lens = getLensInstance(); if(lens != null) dead = lens.collideBurst(this, rtr, collidedTile != null && collidedTile instanceof IManaReceiver && ((IManaReceiver) collidedTile).canRecieveManaFromBursts(), dead, getSourceLens()); if(collided && !hasAlreadyCollidedAt(rtr.getBlockPos())) alreadyCollidedAt.add(rtr.getBlockPos()); if(dead && isAlive()) { if(!fake) { Color color = new Color(getColor()); float r = color.getRed() / 255F; float g = color.getGreen() / 255F; float b = color.getBlue() / 255F; int mana = getMana(); int maxMana = getStartingMana(); float size = (float) mana / (float) maxMana; if(!ConfigHandler.subtlePowerSystem) for(int i = 0; i < 4; i++) Botania.proxy.wispFX(posX, posY, posZ, r, g, b, 0.15F * size, (float) (Math.random() - 0.5F) * 0.04F, (float) (Math.random() - 0.5F) * 0.04F, (float) (Math.random() - 0.5F) * 0.04F); Botania.proxy.sparkleFX((float) posX, (float) posY, (float) posZ, r, g, b, 4, 2); } remove(); } } private void onRecieverImpact(IManaReceiver tile, BlockPos pos) { ILensEffect lens = getLensInstance(); int mana = getMana(); if(lens != null) { ItemStack stack = getSourceLens(); mana = lens.getManaToTransfer(this, this, stack, tile); } if(tile instanceof IManaCollector) mana *= ((IManaCollector) tile).getManaYieldMultiplier(this); tile.recieveMana(mana); if(tile instanceof IThrottledPacket) ((IThrottledPacket) tile).markDispatchable(); else VanillaPacketDispatcher.dispatchTEToNearbyPlayers(world, pos); } @Override public void remove() { super.remove(); if(!fake) { TileEntity tile = getShooter(); if(tile instanceof IManaSpreader) ((IManaSpreader) tile).setCanShoot(true); } else setDeathTicksForFakeParticle(); } private TileEntity getShooter() { return world.getTileEntity(getBurstSourceBlockPos()); } @Override protected float getGravityVelocity() { return getGravity(); } @Override public boolean isFake() { return fake; } @Override public void setFake(boolean fake) { this.fake = fake; } public void setScanBeam() { scanBeam = true; } @Override public int getColor() { return dataManager.get(COLOR); } @Override public void setColor(int color) { dataManager.set(COLOR, color); } @Override public int getMana() { return dataManager.get(MANA); } @Override public void setMana(int mana) { dataManager.set(MANA, mana); } @Override public int getStartingMana() { return dataManager.get(START_MANA); } @Override public void setStartingMana(int mana) { dataManager.set(START_MANA, mana); } @Override public int getMinManaLoss() { return dataManager.get(MIN_MANA_LOSS); } @Override public void setMinManaLoss(int minManaLoss) { dataManager.set(MIN_MANA_LOSS, minManaLoss); } @Override public float getManaLossPerTick() { return dataManager.get(MANA_LOSS_PER_TICK); } @Override public void setManaLossPerTick(float mana) { dataManager.set(MANA_LOSS_PER_TICK, mana); } @Override public float getGravity() { return dataManager.get(GRAVITY); } @Override public void setGravity(float gravity) { dataManager.set(GRAVITY, gravity); } @Override public BlockPos getBurstSourceBlockPos() { return dataManager.get(SOURCE_COORDS); } @Override public void setBurstSourceCoords(BlockPos pos) { dataManager.set(SOURCE_COORDS, pos); } @Override public ItemStack getSourceLens() { return dataManager.get(SOURCE_LENS); } @Override public void setSourceLens(ItemStack lens) { dataManager.set(SOURCE_LENS, lens); } @Override public int getTicksExisted() { return _ticksExisted; } public void setTicksExisted(int ticks) { _ticksExisted = ticks; } private ILensEffect getLensInstance() { ItemStack lens = getSourceLens(); if(!lens.isEmpty() && lens.getItem() instanceof ILensEffect) return (ILensEffect) lens.getItem(); return null; } @Override public void setMotion(double x, double y, double z) { motionX = x; motionY = y; motionZ = z; } @Override public boolean hasAlreadyCollidedAt(BlockPos pos) { return alreadyCollidedAt.contains(pos); } @Override public void setCollidedAt(BlockPos pos) { if(!hasAlreadyCollidedAt(pos)) alreadyCollidedAt.add(pos.toImmutable()); } @Override public void setShooterUUID(UUID uuid) { shooterIdentity = uuid; } @Override public UUID getShooterUUID() { return shooterIdentity; } @Override public void ping() { TileEntity tile = getShooter(); if(tile != null && tile instanceof IPingable) ((IPingable) tile).pingback(this, getShooterUUID()); } protected boolean shouldDoFakeParticles() { if (ConfigHandler.staticWandBeam) return true; TileEntity tile = getShooter(); return tile instanceof IManaSpreader && (getMana() != getStartingMana() && fullManaLastTick || Math.abs(((IManaSpreader) tile).getBurstParticleTick() - getTicksExisted()) < 4); } private void incrementFakeParticleTick() { TileEntity tile = getShooter(); if(tile instanceof IManaSpreader) { IManaSpreader spreader = (IManaSpreader) tile; spreader.setBurstParticleTick(spreader.getBurstParticleTick()+2); if(spreader.getLastBurstDeathTick() != -1 && spreader.getBurstParticleTick() > spreader.getLastBurstDeathTick()) spreader.setBurstParticleTick(0); } } private void setDeathTicksForFakeParticle() { BlockPos coords = getBurstSourceBlockPos(); TileEntity tile = world.getTileEntity(coords); if(tile != null && tile instanceof IManaSpreader) ((IManaSpreader) tile).setLastBurstDeathTick(getTicksExisted()); } public static class PositionProperties { public final BlockPos coords; public final IBlockState state; public boolean invalid = false; public PositionProperties(Entity entity) { int x = MathHelper.floor(entity.posX); int y = MathHelper.floor(entity.posY); int z = MathHelper.floor(entity.posZ); coords = new BlockPos(x, y, z); state = entity.world.getBlockState(coords); } public boolean coordsEqual(PositionProperties props) { return coords.equals(props.coords); } public boolean contentsEqual(World world) { if(!world.isBlockLoaded(coords)) { invalid = true; return false; } return world.getBlockState(coords) == state; } @Override public int hashCode() { return Objects.hash(coords, state); } @Override public boolean equals(Object o) { return o instanceof PositionProperties && ((PositionProperties) o).state == state && ((PositionProperties) o).coords.equals(coords); } } }