@SuppressWarnings("unchecked")
protected Entity areaOfEffect() {
List<EntityLivingBase> list =
worldObj.getEntitiesWithinAABB(
EntityLivingBase.class,
AxisAlignedBB.getBoundingBox(
attacker.boundingBox.minX,
attacker.boundingBox.minY,
attacker.boundingBox.minZ,
attacker.boundingBox.maxX,
attacker.boundingBox.maxY,
attacker.boundingBox.maxZ)
.expand(8D, 1D, 8D));
for (int i = 0; i < list.size(); i++) {
Entity entity = list.get(i);
if (entity != null)
if (entity instanceof EntityLivingBase
&& !(entity instanceof EntityTarantulaMiniboss)
&& !(entity instanceof EntityTarantula)
&& !(entity instanceof EntityTarantulaBaby)) {
float Knockback = 2;
entity.attackEntityFrom(DamageSource.causeMobDamage(attacker), 8.0F);
entity.addVelocity(
-MathHelper.sin(attacker.rotationYaw * 3.141593F / 180.0F) * Knockback * 0.5F,
0.4D,
MathHelper.cos(attacker.rotationYaw * 3.141593F / 180.0F) * Knockback * 0.5F);
attacker.playSound("erebus:blamsound", 1.5F, 1.0F);
((EntityLivingBase) entity)
.addPotionEffect(new PotionEffect(Potion.moveSlowdown.id, 8 * 20, 0));
((EntityLivingBase) entity)
.addPotionEffect(new PotionEffect(Potion.blindness.id, 5 * 20, 0));
}
}
return null;
}
/** Drops the entity's currently held item into the world */
public static void dropHeldItem(EntityLivingBase entity) {
if (!entity.worldObj.isRemote && entity.getHeldItem() != null) {
EntityItem drop =
new EntityItem(
entity.worldObj,
entity.posX,
entity.posY - 0.30000001192092896D + (double) entity.getEyeHeight(),
entity.posZ,
entity.getHeldItem().copy());
float f = 0.3F;
float f1 = entity.worldObj.rand.nextFloat() * (float) Math.PI * 2.0F;
drop.motionX =
(double)
(-MathHelper.sin(entity.rotationYaw / 180.0F * (float) Math.PI)
* MathHelper.cos(entity.rotationPitch / 180.0F * (float) Math.PI)
* f);
drop.motionZ =
(double)
(MathHelper.cos(entity.rotationYaw / 180.0F * (float) Math.PI)
* MathHelper.cos(entity.rotationPitch / 180.0F * (float) Math.PI)
* f);
drop.motionY =
(double) (-MathHelper.sin(entity.rotationPitch / 180.0F * (float) Math.PI) * f + 0.1F);
f = 0.02F * entity.worldObj.rand.nextFloat();
drop.motionX += Math.cos((double) f1) * (double) f;
drop.motionY +=
(double) ((entity.worldObj.rand.nextFloat() - entity.worldObj.rand.nextFloat()) * 0.1F);
drop.motionZ += Math.sin((double) f1) * (double) f;
drop.delayBeforeCanPickup = 40;
entity.worldObj.spawnEntityInWorld(drop);
entity.setCurrentItemOrArmor(0, (ItemStack) null);
}
}
@Override
public IMessage onMessage(PacketKurosawaAttack message, MessageContext ctx) {
EntityPlayer player = ctx.getServerHandler().playerEntity;
Kurosawa item = (Kurosawa) player.getHeldItem().getItem();
if (!item.getCooldown()) {
World world = player.worldObj;
EntityLivingBase target = (EntityLivingBase) world.getEntityByID(message.targetID);
Vec3 targetPos = target.getPositionVector();
Vec3 attackerPos = player.getPositionVector();
Vec3 distance = targetPos.subtractReverse(attackerPos).normalize();
distance = new Vec3(distance.xCoord * 3, distance.yCoord * 3, distance.zCoord * 3);
player.setPositionAndRotation(
target.posX - distance.xCoord,
target.posY - distance.yCoord,
target.posZ - distance.zCoord,
player.rotationYaw + 180,
player.rotationPitch);
player.setRotationYawHead(player.rotationYawHead + 180);
player.cameraPitch += 180;
player.setPositionAndUpdate(
target.posX - distance.xCoord,
target.posY - distance.yCoord,
target.posZ - distance.zCoord);
target.attackEntityFrom(DamageSource.causePlayerDamage(player), 44);
item.setCooldown();
}
return null;
}
@SuppressWarnings("unchecked")
private void pop() {
List<EntityLivingBase> ents =
worldObj.getEntitiesWithinAABB(
EntityLivingBase.class,
AxisAlignedBB.getBoundingBox(
xCoord + 1.0,
yCoord + 1.0,
zCoord + 1.0,
xCoord + xLength - 1,
yCoord + 3.0,
zCoord + zLength - 1));
for (EntityLivingBase ent : ents) {
if (ent instanceof EntityPlayer) {
EntityPlayerMP player = (EntityPlayerMP) ent;
if (!player.capabilities.isCreativeMode) {
player.playerNetServerHandler.sendPacket(
new S12PacketEntityVelocity(
player.getEntityId(), 0.0, MathHelper.randomDoubleInRange(0.5, 2), 0.0));
}
} else {
if (!ent.isDead) {
ent.addVelocity(0.0, MathHelper.randomDoubleInRange(0.5, 2), 0);
}
}
}
}
/** Applies permanent buffs / debuffs to vanilla mobs */
private void initBuffs(EntityLivingBase entity) {
if (!ZSSEntityInfo.get(entity).getActiveBuffsMap().isEmpty()) {
return;
}
// double damage from cold effects, highly resistant to fire damage
if (entity.isImmuneToFire()) {
ZSSEntityInfo.get(entity).applyBuff(Buff.RESIST_FIRE, Integer.MAX_VALUE, 75);
ZSSEntityInfo.get(entity).applyBuff(Buff.WEAKNESS_COLD, Integer.MAX_VALUE, 100);
}
if (entity.getCreatureAttribute() == EnumCreatureAttribute.UNDEAD) {
if (!entity.isImmuneToFire()) {
ZSSEntityInfo.get(entity).applyBuff(Buff.WEAKNESS_FIRE, Integer.MAX_VALUE, 50);
}
ZSSEntityInfo.get(entity).applyBuff(Buff.WEAKNESS_HOLY, Integer.MAX_VALUE, 300);
ZSSEntityInfo.get(entity).applyBuff(Buff.RESIST_COLD, Integer.MAX_VALUE, 50);
ZSSEntityInfo.get(entity).applyBuff(Buff.RESIST_STUN, Integer.MAX_VALUE, 50);
}
if (entity instanceof EntityGolem) {
ZSSEntityInfo.get(entity).applyBuff(Buff.RESIST_COLD, Integer.MAX_VALUE, 100);
ZSSEntityInfo.get(entity).applyBuff(Buff.RESIST_STUN, Integer.MAX_VALUE, 100);
}
if (entity instanceof EntityWitch) {
ZSSEntityInfo.get(entity).applyBuff(Buff.RESIST_MAGIC, Integer.MAX_VALUE, 75);
}
if (entity instanceof EntityWither) {
ZSSEntityInfo.get(entity).removeBuff(Buff.WEAKNESS_COLD);
}
}
@Override
protected void spawnProjectiles() {
if (!TragicConfig.getBoolean("jabbaProjectiles")) return;
EntityLivingBase entity = this.getAttackTarget();
double d0 = entity.posX - this.posX;
double d1 =
entity.getEntityBoundingBox().minY
+ entity.height / 2.0F
- (this.posY + this.height / 2.0F);
double d2 = entity.posZ - this.posZ;
float f1 = MathHelper.sqrt_float(this.getDistanceToEntity(entity)) * 0.5F;
for (byte i = 0; i < 5; ++i) {
EntityPoisonBarb poisonbarb =
new EntityPoisonBarb(
this.worldObj,
this,
d0 + this.rand.nextGaussian() * f1,
d1,
d2 + this.rand.nextGaussian() * f1);
poisonbarb.posX = this.posX + d0 * 0.115D;
poisonbarb.posY = this.posY + 0.435D;
poisonbarb.posZ = this.posZ + d0 * 0.115D;
this.worldObj.spawnEntityInWorld(poisonbarb);
this.setAngerTicks(this.getAngerTicks() - 50);
}
}
public void attackEntityWithRangedAttack(EntityLivingBase par1EntityLiving, float par2) {
if (!this.getAggressive()) {
EntityPotion var2 = new EntityPotion(this.worldObj, this, 32732);
var2.rotationPitch -= -20.0F;
double var3 = par1EntityLiving.posX + par1EntityLiving.motionX - this.posX;
double var5 =
par1EntityLiving.posY
+ (double) par1EntityLiving.getEyeHeight()
- 1.100000023841858D
- this.posY;
double var7 = par1EntityLiving.posZ + par1EntityLiving.motionZ - this.posZ;
float var9 = MathHelper.sqrt_double(var3 * var3 + var7 * var7);
if (var9 >= 8.0F && !par1EntityLiving.isPotionActive(Potion.moveSlowdown)) {
var2.setPotionDamage(32698);
} else if (par1EntityLiving.getHealth() >= 8.0F
&& !par1EntityLiving.isPotionActive(Potion.poison)) {
var2.setPotionDamage(32660);
} else if (var9 <= 3.0F
&& !par1EntityLiving.isPotionActive(Potion.weakness)
&& this.rand.nextFloat() < 0.25F) {
var2.setPotionDamage(32696);
}
var2.setThrowableHeading(var3, var5 + (double) (var9 * 0.2F), var7, 0.75F, 8.0F);
this.worldObj.spawnEntityInWorld(var2);
}
}
@Override
protected boolean isValidTarget(Entity ent) {
if (ent instanceof TargetEntity) return ((TargetEntity) ent).shouldTarget(this, placerUUID);
if (!(ent instanceof EntityLivingBase)) return false;
EntityLivingBase elb = (EntityLivingBase) ent;
if (elb.isDead || elb.getHealth() <= 0) return false;
if (ent.onGround || ent.isInWater() || ent.isInsideOfMaterial(Material.lava)) return false;
if (elb instanceof EntityFlying && ReikaEntityHelper.isHostile(elb)) {
return ReikaMathLibrary.py3d(
ent.posX - xCoord - 0.5, ent.posY - yCoord - 0.5, ent.posZ - zCoord - 0.5)
> 2;
}
if (ent instanceof EntityBlaze || ent instanceof EntityWither || ent instanceof EntityDragon) {
return ReikaMathLibrary.py3d(
ent.posX - xCoord - 0.5, ent.posY - yCoord - 0.5, ent.posZ - zCoord - 0.5)
> 2;
}
if (ent instanceof FlyingMob) {
FlyingMob fm = (FlyingMob) ent;
return fm.isCurrentlyFlying()
&& fm.isHostile()
&& ReikaMathLibrary.py3d(
ent.posX - xCoord - 0.5, ent.posY - yCoord - 0.5, ent.posZ - zCoord - 0.5)
> 2;
}
if (InterfaceCache.BCROBOT.instanceOf(ent)) {
return true;
}
return false;
}
private void updateNearbyEntities() {
ArrayList<EntityLivingBase> toRemove = new ArrayList<EntityLivingBase>();
List<EntityLivingBase> nearbyEntities =
this.worldObj.getEntitiesWithinAABB(
EntityLivingBase.class,
AxisAlignedBB.getBoundingBox(
this.xCoord - 10,
this.yCoord,
this.zCoord - 10,
this.xCoord + 10,
this.yCoord + 4,
this.zCoord + 10));
for (EntityLivingBase entity : nearbyEntities) {
if (entity.isEntityInvulnerable()
|| entity instanceof IBossDisplayData
|| entity instanceof EntityDarkling
|| entity instanceof EntityPlayer
|| entity instanceof EntityAirSled
|| entity instanceof EntityWinterGuardianArm
|| entity instanceof EntityThrownSickle
|| entity instanceof EntityFlicker
|| entity instanceof EntityShadowHelper) continue;
if (!cachedEntities.contains(entity)) cachedEntities.add(entity);
}
ticksSinceLastEntityScan = 0;
}
@SubscribeEvent(priority = EventPriority.LOWEST)
public void disallowDespawn(AllowDespawn ad) {
EntityLivingBase e = ad.entityLiving;
PotionEffect pe = e.getActivePotionEffect(RotaryCraft.freeze);
if (pe == null) return;
ad.setResult(Result.DENY);
}
public EntityMeteorChunk(
World world,
EntityLivingBase shootingEntity,
EntityLivingBase target,
float speed,
float randMod) {
super(world);
this.renderDistanceWeight = 10.0D;
this.shootingEntity = shootingEntity;
if (shootingEntity instanceof EntityPlayer) {
this.canBePickedUp = 1;
}
this.posY = shootingEntity.posY + shootingEntity.getEyeHeight() - 0.10000000149011612D;
double d0 = target.posX - shootingEntity.posX;
double d1 = target.getEntityBoundingBox().minY + target.height / 3.0F - this.posY;
double d2 = target.posZ - shootingEntity.posZ;
double d3 = MathHelper.sqrt_double(d0 * d0 + d2 * d2);
if (d3 >= 1.0E-7D) {
float f2 = (float) (Math.atan2(d2, d0) * 180.0D / Math.PI) - 90.0F;
float f3 = (float) -(Math.atan2(d1, d3) * 180.0D / Math.PI);
double d4 = d0 / d3;
double d5 = d2 / d3;
this.setLocationAndAngles(
shootingEntity.posX + d4, this.posY, shootingEntity.posZ + d5, f2, f3);
float f4 = (float) d3 * 0.2F;
this.setThrowableHeading(d0, d1 + f4, d2, speed, randMod);
}
}
private void doBolt(EntityBallLightning other) {
Vec3 vec = ReikaVectorHelper.getVec2Pt(posX, posY, posZ, other.posX, other.posY, other.posZ);
// EntityGluon g = new EntityGluon(this, other);
// worldObj.spawnEntityInWorld(g);
targetColor = other.color;
ReikaPacketHelper.sendDataPacket(
ChromatiCraft.packetChannel,
ChromaPackets.GLUON.ordinal(),
new DimensionTarget(worldObj),
this.getEntityId(),
other.getEntityId());
double len = vec.lengthVector();
for (double i = 0; i < len; i += 0.0625) {
double dx = posX - i * vec.xCoord / len;
double dy = posY - i * vec.yCoord / len;
double dz = posZ - i * vec.zCoord / len;
if (worldObj.isRemote) this.gluonParticles(other, dx, dy, dz, (float) (i / len));
if (ChromaOptions.HOSTILEFOREST.getState()) {
AxisAlignedBB box =
AxisAlignedBB.getBoundingBox(dx, dy, dz, dx, dy, dz).expand(0.5, 0.5, 0.5);
List<EntityLivingBase> elb = worldObj.getEntitiesWithinAABB(EntityLivingBase.class, box);
for (EntityLivingBase e : elb) {
e.attackEntityFrom(DamageSource.generic, isPylonSpawn ? 4 : 1);
}
}
}
}
@Override
public boolean attackEntityAsMob(Entity par1Entity) {
if (this.worldObj.isRemote) return false;
boolean result = super.attackEntityAsMob(par1Entity);
EnumDifficulty dif = this.worldObj.getDifficulty();
int x = 2;
if (dif == EnumDifficulty.NORMAL) {
x = 3;
} else if (dif == EnumDifficulty.HARD) {
x = 4;
}
if (result) {
if (this.isSpinning()) this.setSpinTicks(0);
if (this.getFlutterTicks() > 0) this.setFlutterTicks(0);
if (par1Entity instanceof EntityLivingBase) {
if (rand.nextInt(16 / x) == 0)
((EntityLivingBase) par1Entity)
.addPotionEffect(
new PotionEffect(
Potion.moveSlowdown.id, 100 + rand.nextInt(140), 1 + rand.nextInt(2)));
if (rand.nextInt(32 / x) == 0)
((EntityLivingBase) par1Entity)
.addPotionEffect(
new PotionEffect(
Potion.digSlowdown.id, 100 + rand.nextInt(140), 1 + rand.nextInt(2)));
}
}
return result;
}
/** Returns whether the EntityAIBase should begin execution. */
@SuppressWarnings("unchecked")
@Override
public boolean shouldExecute() {
EntityLivingBase entitylivingbase = this.attacker.getAttackTarget();
if (entitylivingbase == null) {
return false;
} else if (!entitylivingbase.isEntityAlive()) {
return false;
} else if (this.classTarget != null
&& !this.classTarget.isAssignableFrom(entitylivingbase.getClass())) {
return false;
} else if (this.worldObj.isDaytime()) {
return false;
} else {
if (--this.field_75445_i <= 0) {
this.entityPathEntity =
this.attacker.getNavigator().getPathToEntityLiving(entitylivingbase);
this.field_75445_i = 4 + this.attacker.getRNG().nextInt(7);
return this.entityPathEntity != null;
} else {
return true;
}
}
}
/** Damages the item in the ItemStack */
public void damageItem(int par1, EntityLivingBase par2EntityLivingBase) {
if (!(par2EntityLivingBase instanceof EntityPlayer)
|| !((EntityPlayer) par2EntityLivingBase).capabilities.isCreativeMode) {
if (this.isItemStackDamageable()) {
if (this.attemptDamageItem(par1, par2EntityLivingBase.getRNG())) {
par2EntityLivingBase.renderBrokenItemStack(this);
--this.stackSize;
if (par2EntityLivingBase instanceof EntityPlayer) {
EntityPlayer entityplayer = (EntityPlayer) par2EntityLivingBase;
entityplayer.addStat(
StatList.objectBreakStats[Item.getIdFromItem(this.field_151002_e)], 1);
if (this.stackSize == 0 && this.getItem() instanceof ItemBow) {
entityplayer.destroyCurrentEquippedItem();
}
}
if (this.stackSize < 0) {
this.stackSize = 0;
}
this.itemDamage = 0;
}
}
}
}
/** Performs a ranged attack according to the AI's rangedAttackID. */
private void doRangedAttack() {
// 43% chance to "miss"
int chanceToMiss = entityHost.isPotionActive(Potion.moveSpeed) ? 10 : 43;
if (worldObj.rand.nextInt(100) < chanceToMiss) {
AMCore.instance.proxy.particleManager.BoltFromPointToPoint(
worldObj,
entityHost.posX,
entityHost.posY + entityHost.getEyeHeight(),
entityHost.posZ,
attackTarget.posX + worldObj.rand.nextFloat() - 0.5f,
attackTarget.posY + attackTarget.getEyeHeight() + worldObj.rand.nextFloat() - 0.5f,
attackTarget.posZ + worldObj.rand.nextFloat() - 0.5f,
2,
-1);
} else {
AMCore.instance.proxy.particleManager.BoltFromEntityToEntity(
worldObj, entityHost, entityHost, attackTarget, this.damage, 2, -1);
float manaDrained =
this.manaDrainedPerCasterLevel * ExtendedProperties.For(attackTarget).getMagicLevel();
ExtendedProperties.For(attackTarget)
.setCurrentMana(ExtendedProperties.For(attackTarget).getCurrentMana() - (manaDrained));
ExtendedProperties.For(attackTarget).forceSync();
attackTarget.attackEntityFrom(
DamageSource.causeIndirectMagicDamage(entityHost, entityHost), this.damage);
if (manaDrained > 100) {
entityHost.heal(1);
if (entityHost.worldObj.difficultySetting == EnumDifficulty.HARD) {
attackTarget.addPotionEffect(new PotionEffect(Potion.moveSlowdown.id, 40, 1, true));
entityHost.addPotionEffect(new PotionEffect(Potion.moveSpeed.id, 40, 3, true));
}
}
}
}
public boolean tryFireMinigun(EntityLivingBase target) {
boolean lastShotOfAmmo = false;
if (ammo != null && (pressurizable == null || pressurizable.getPressure(stack) > 0)) {
setMinigunTriggerTimeOut(Math.max(10, getMinigunSoundCounter()));
if (getMinigunSpeed() == MAX_GUN_SPEED && (!requiresTarget || gunAimedAtTarget)) {
if (!requiresTarget) target = raytraceTarget();
lastShotOfAmmo = ammo.attemptDamageItem(1, rand);
if (pressurizable != null) pressurizable.addAir(stack, -airUsage);
if (target != null) {
ItemStack potion = ItemGunAmmo.getPotion(ammo);
if (potion != null) {
if (rand.nextInt(20) == 0) {
List<PotionEffect> effects = Items.potionitem.getEffects(potion);
if (effects != null) {
for (PotionEffect effect : effects) {
target.addPotionEffect(new PotionEffect(effect));
}
}
}
} else {
target.attackEntityFrom(DamageSource.causePlayerDamage(player), 4);
}
}
}
}
return lastShotOfAmmo;
}
protected void onImpact(MovingObjectPosition par1MovingObjectPosition) {
if (par1MovingObjectPosition.entityHit != null) {
int i0 = StuffWorthThrowingConfig.rockMinDamage;
int i1 = StuffWorthThrowingConfig.rockMaxDamage - i0 + 1;
int i2 = this.rand.nextInt(i1) + i0 + StuffWorthThrowingConfig.brokenBrickStronger;
int i3 = StuffWorthThrowingConfig.dizzyMultiplier;
int i4 = StuffWorthThrowingConfig.debuffMultiplier;
if (!this.worldObj.isRemote && StuffWorthThrowingConfig.itemStatusEffects) {
EntityLivingBase entityLiving = (EntityLivingBase) par1MovingObjectPosition.entityHit;
entityLiving.setFire(i2 * i4 / 20);
if (StuffWorthThrowingConfig.dizzyBricks) {
entityLiving.addPotionEffect(new PotionEffect(Potion.confusion.getId(), i2 * i3, 0));
}
}
par1MovingObjectPosition.entityHit.attackEntityFrom(
DamageSource.causeThrownDamage(this, this.getThrower()), (byte) i2);
}
for (int i = 0; i < 8; ++i) {
this.worldObj.spawnParticle("smoke", this.posX, this.posY, this.posZ, 0.0D, 0.0D, 0.0D);
}
if (!this.worldObj.isRemote) {
this.setDead();
}
}
@Override
public boolean itemInteractionForEntity(
ItemStack itemStack, EntityPlayer player, EntityLivingBase entity) {
if (entity.worldObj.isRemote) {
return false;
} else {
ItemStack container;
switch (itemStack.getItemDamage()) {
case 0:
break;
case 1:
container = LifeSystem.findFilledLifeContainer(player.inventory.mainInventory);
if (container != null && entity.getHealth() < entity.getMaxHealth()) {
if (((ILifeContainer) container.getItem()).takeLife(container, 1) > 0) {
entity.heal(1f);
player.addStat(ModAchievements.useLP, 1);
return true;
}
}
break;
case 2:
break;
}
}
return false;
}
@Override
protected void onImpact(MovingObjectPosition mop) {
if (!this.worldObj.isRemote && getThrower() != null) {
if (mop.entityHit != null) {
Entity ent = mop.entityHit;
if (ent instanceof EntityLivingBase) {
((EntityLivingBase) ent)
.attackEntityFrom(DamageSource.causeIndirectMagicDamage(getThrower(), ent), this.dmg);
if (this.corrosive) {
try {
((EntityLivingBase) ent).addPotionEffect(new PotionEffect(Potion.wither.id, 160, 1));
} catch (Exception e) {
e.printStackTrace();
}
} else {
try {
((EntityLivingBase) ent)
.addPotionEffect(new PotionEffect(Potion.weakness.id, 160, 1));
} catch (Exception e) {
e.printStackTrace();
}
}
}
}
this.worldObj.playSoundAtEntity(
this, "random.fizz", 0.5F, 2.6F + (this.rand.nextFloat() - this.rand.nextFloat()) * 0.8F);
this.ticksExisted = 100;
this.worldObj.setEntityState(this, (byte) 16);
}
setDead();
}
private void tryAbility(EntityLivingBase mob, EntityLivingBase target) {
if (target == null || !mob.canEntityBeSeen(target)) {
return;
}
if (mob.getDistanceToEntity(target) > MIN_DISTANCE) {
double diffX = target.posX - mob.posX;
double diffY =
target.boundingBox.minY
+ (double) (target.height / 2.0F)
- (mob.posY + (double) (mob.height / 2.0F));
double diffZ = target.posZ - mob.posZ;
mob.renderYawOffset =
mob.rotationYaw = -((float) Math.atan2(diffX, diffZ)) * 180.0F / (float) Math.PI;
mob.worldObj.playAuxSFXAtEntity(
(EntityPlayer) null, 1008, (int) mob.posX, (int) mob.posY, (int) mob.posZ, 0);
EntityLargeFireball entFB = new EntityLargeFireball(mob.worldObj, mob, diffX, diffY, diffZ);
double spawnOffset = 2.0D;
Vec3 mobLook = mob.getLook(1.0F);
entFB.posX = mob.posX + mobLook.xCoord * spawnOffset;
entFB.posY = mob.posY + (double) (mob.height / 2.0F) + 0.5D;
entFB.posZ = mob.posZ + mobLook.zCoord * spawnOffset;
mob.worldObj.spawnEntityInWorld(entFB);
}
}
public EntityMamormeterShot(
World world,
EntityLivingBase thrower,
EntityLivingBase target,
float var4,
float var5,
boolean b) {
super(world);
this.shootingEntity = thrower;
if (thrower instanceof EntityPlayer) {
this.canBePickedUp = 1;
}
this.posY = thrower.posY + thrower.getEyeHeight() - 0.10000000149011612D;
double var6 = target.posX - thrower.posX;
double var8 = target.posY + target.getEyeHeight() - 0.699999988079071D - this.posY;
double var10 = target.posZ - thrower.posZ;
double var12 = MathHelper.sqrt_double(var6 * var6 + var10 * var10);
if (var12 >= 1.0E-7D) {
float var14 = (float) (Math.atan2(var10, var6) * 180.0D / Math.PI) - 90.0F;
float var15 = (float) (-(Math.atan2(var8, var12) * 180.0D / Math.PI));
double var16 = var6 / var12;
double var18 = var10 / var12;
this.setLocationAndAngles(
thrower.posX + var16, this.posY, thrower.posZ + var18, var14, var15);
this.yOffset = 0.0F;
float var20 = (float) var12 * 0.2F;
this.setArrowHeading(var6, var8 + var20, var10, var4, var5);
}
this.explosive = b;
}
@SuppressWarnings("unchecked")
private void potion() {
List<EntityLivingBase> ents =
worldObj.getEntitiesWithinAABB(
EntityLivingBase.class,
AxisAlignedBB.getBoundingBox(
xCoord + 1.0,
yCoord + 1.0,
zCoord + 1.0,
xCoord + xLength - 1,
yCoord + 3.0,
zCoord + zLength - 1));
if (ents != null && ents.size() > 0) {
Potion potion = null;
// Try and find a potion, 15 times max
for (int i = 0; i < 15; i++) {
potion = Potion.potionTypes[worldObj.rand.nextInt(Potion.potionTypes.length)];
if (potion != null) break;
}
if (potion == null) return;
EntityLivingBase ent = ents.get(worldObj.rand.nextInt(ents.size()));
ent.addPotionEffect(
new PotionEffect(potion.id, MathHelper.randomIntInRange(3, 10), 1, false));
}
}
public static boolean removeModifier(
EntityLivingBase entity, IAttribute attribute, AttributeModifier modifier) {
if (entity.getEntityAttribute(attribute).getModifier(modifier.getID()) != null) {
entity.getEntityAttribute(attribute).removeModifier(modifier);
return true;
} else return false;
}
public static MovingObjectPosition getMovingObjectPositionFromPlayer(
World world, EntityLivingBase living, boolean bool) {
float f = 1.0F;
float f1 = living.prevRotationPitch + (living.rotationPitch - living.prevRotationPitch) * f;
float f2 = living.prevRotationYaw + (living.rotationYaw - living.prevRotationYaw) * f;
double d0 = living.prevPosX + (living.posX - living.prevPosX) * (double) f;
double d1 =
living.prevPosY
+ (living.posY - living.prevPosY) * (double) f
+ (double)
(world.isRemote
? living.getEyeHeight()
- (living instanceof EntityPlayer
? ((EntityPlayer) living).getDefaultEyeHeight()
: 0)
: living
.getEyeHeight()); // isRemote check to revert changes to ray trace position
// due to adding the eye height clientside and player
// yOffset differences
double d2 = living.prevPosZ + (living.posZ - living.prevPosZ) * (double) f;
Vec3 vec3 = Vec3.createVectorHelper(d0, d1, d2);
float f3 = MathHelper.cos(-f2 * 0.017453292F - (float) Math.PI);
float f4 = MathHelper.sin(-f2 * 0.017453292F - (float) Math.PI);
float f5 = -MathHelper.cos(-f1 * 0.017453292F);
float f6 = MathHelper.sin(-f1 * 0.017453292F);
float f7 = f4 * f5;
float f8 = f3 * f5;
double d3 = 5.0D;
if (living instanceof EntityPlayerMP)
d3 = ((EntityPlayerMP) living).theItemInWorldManager.getBlockReachDistance();
Vec3 vec31 = vec3.addVector((double) f7 * d3, (double) f6 * d3, (double) f8 * d3);
return world.func_147447_a(vec3, vec31, bool, !bool, false);
}
public void func_111187_a(
EntityLivingBase p_111187_1_, BaseAttributeMap p_111187_2_, int p_111187_3_) {
super.func_111187_a(p_111187_1_, p_111187_2_, p_111187_3_);
if (p_111187_1_.func_110143_aJ() > p_111187_1_.func_110138_aP()) {
p_111187_1_.func_70606_j(p_111187_1_.func_110138_aP());
}
}
public static float[] getRotationsNeeded(Entity entity) {
if (entity == null) return null;
double diffX = entity.posX - Minecraft.getMinecraft().thePlayer.posX;
double diffY;
if (entity instanceof EntityLivingBase) {
EntityLivingBase entityLivingBase = (EntityLivingBase) entity;
diffY =
entityLivingBase.posY
+ entityLivingBase.getEyeHeight() * 0.9
- (Minecraft.getMinecraft().thePlayer.posY
+ Minecraft.getMinecraft().thePlayer.getEyeHeight());
} else
diffY =
(entity.boundingBox.minY + entity.boundingBox.maxY) / 2.0D
- (Minecraft.getMinecraft().thePlayer.posY
+ Minecraft.getMinecraft().thePlayer.getEyeHeight());
double diffZ = entity.posZ - Minecraft.getMinecraft().thePlayer.posZ;
double dist = MathHelper.sqrt_double(diffX * diffX + diffZ * diffZ);
float yaw = (float) (Math.atan2(diffZ, diffX) * 180.0D / Math.PI) - 90.0F;
float pitch = (float) -(Math.atan2(diffY, dist) * 180.0D / Math.PI);
return new float[] {
Minecraft.getMinecraft().thePlayer.rotationYaw
+ MathHelper.wrapAngleTo180_float(yaw - Minecraft.getMinecraft().thePlayer.rotationYaw),
Minecraft.getMinecraft().thePlayer.rotationPitch
+ MathHelper.wrapAngleTo180_float(
pitch - Minecraft.getMinecraft().thePlayer.rotationPitch)
};
}
@Override
protected void onImpact(MovingObjectPosition par1MovingObjectPosition) {
if (!this.worldObj.isRemote
&& potionStack.getItem() != null
&& potionStack.getItem() instanceof ItemPotion) {
@SuppressWarnings("unchecked")
List<PotionEffect> effectList = ((ItemPotion) potionStack.getItem()).getEffects(potionStack);
if (effectList != null && !effectList.isEmpty()) {
AxisAlignedBB axisalignedbb = this.boundingBox.expand(4.0D, 2.0D, 4.0D);
@SuppressWarnings("unchecked")
List<EntityLivingBase> entityList =
this.worldObj.getEntitiesWithinAABB(EntityLivingBase.class, axisalignedbb);
if (entityList != null && !entityList.isEmpty()) {
Iterator<EntityLivingBase> iterator = entityList.iterator();
while (iterator.hasNext()) {
EntityLivingBase entityliving = iterator.next();
double squareDistance = this.getDistanceSqToEntity(entityliving);
if (squareDistance < 16.0D) {
double distanceFactor = 1.0D - Math.sqrt(squareDistance) / 4.0D;
if (entityliving == par1MovingObjectPosition.entityHit) {
distanceFactor = 1.0D;
}
Iterator<PotionEffect> iterator1 = effectList.iterator();
while (iterator1.hasNext()) {
PotionEffect potioneffect = iterator1.next();
int potionID = potioneffect.getPotionID();
if (Potion.potionTypes[potionID].isInstant()) {
Potion.potionTypes[potionID].affectEntity(
this.getThrower(), entityliving, potioneffect.getAmplifier(), distanceFactor);
} else {
int potionDuration = (int) (distanceFactor * potioneffect.getDuration() + 0.5D);
if (potionDuration > 20) {
entityliving.addPotionEffect(
new PotionEffect(potionID, potionDuration, potioneffect.getAmplifier()));
}
}
}
}
}
}
}
this.worldObj.playAuxSFX(
2002,
(int) Math.round(this.posX),
(int) Math.round(this.posY),
(int) Math.round(this.posZ),
potionStack.getItemDamage());
this.setDead();
}
}
@Override
public void doSpellCasterEffect(EntityPlayer caster) {
final int radius = 10;
caster.worldObj.playSoundAtEntity(caster, "mob.enderdragon.wings", 1.0F, 1.0F);
for (final Object obj :
caster.worldObj.getEntitiesWithinAABBExcludingEntity(
caster,
AxisAlignedBB.getBoundingBox(
caster.posX - radius,
caster.posY - 3,
caster.posZ - radius,
caster.posX + radius,
caster.posY + 3,
caster.posZ + radius))) {
if (obj instanceof EntityLivingBase) {
final EntityLivingBase entity = (EntityLivingBase) obj;
entity.attackEntityFrom(DamageSource.causeIndirectMagicDamage(caster, entity), 0.0F);
double deltaX = entity.posX - caster.posX;
double deltaZ;
for (deltaZ = entity.posZ - caster.posZ;
deltaX * deltaX + deltaZ * deltaZ < 1.0E-4D;
deltaZ = (Math.random() - Math.random()) * 0.01D) {
deltaX = (Math.random() - Math.random()) * 0.01D;
}
for (int i = 0; i < 10; i++) {
entity.knockBack(caster, 10.0F, deltaX * -1, deltaZ * -1);
}
}
}
}
/**
* Current implementations of this method in child classes do not use the entry argument beside
* ev. They just raise the damage on the stack.
*/
public boolean hitEntity(
ItemStack par1ItemStack,
EntityLivingBase par2EntityLivingBase,
EntityLivingBase par3EntityLivingBase) {
if (tool == 4 || tool == 5) {
NBTTagCompound tag = par1ItemStack.getTagCompound();
this.currentCharge = tag.getInteger("CurrentCharge");
if (this.currentCharge >= 24) {
this.currentCharge -= 24;
tag.setInteger("CurrentCharge", this.currentCharge);
int extra = this.doModuleHitAdditions(par2EntityLivingBase, par3EntityLivingBase);
par2EntityLivingBase.attackEntityFrom(
DamageSource.magic, 20 + extra); // /2 because its steel not the best material
return false;
}
return false;
} else {
NBTTagCompound tag = par1ItemStack.getTagCompound();
this.currentCharge = tag.getInteger("CurrentCharge");
if (this.currentCharge >= 48) {
this.currentCharge -= 48;
tag.setInteger("CurrentCharge", this.currentCharge);
int extra = this.doModuleHitAdditions(par2EntityLivingBase, par3EntityLivingBase);
par2EntityLivingBase.attackEntityFrom(
DamageSource.magic, 12 + extra / 2); // /2 because its steel not the best material
return false;
}
return false;
}
}