public void setRotationAngles(float f, float f1, float f2, float f3, float f4, float f5) {
super.setRotationAngles(f, f1, f2, f3, f4, f5, null);
head.rotateAngleX = f4 / 57.29578F;
head.rotateAngleY = f4 / 57.29578F;
flame.rotateAngleX = f4 / 57.29578F;
flame.rotateAngleY = f4 / 57.29578F;
mouth.rotateAngleX = f4 / 57.29578F;
mouth.rotateAngleY = f4 / 57.29578F;
glare1.rotateAngleX = f4 / 57.29578F;
glare1.rotateAngleY = f4 / 57.29578F;
glare2.rotateAngleX = f4 / 57.29578F;
glare2.rotateAngleY = f4 / 57.29578F;
shoulder1.rotateAngleX = -MathHelper.cos(f * 0.4F) * 1.0F * f1;
arm1.rotateAngleX = -MathHelper.cos(f * 0.4F) * 1.0F * f1;
arm3.rotateAngleX = -MathHelper.cos(f * 0.4F) * 1.0F * f1;
arm5.rotateAngleX = -MathHelper.cos(f * 0.4F) * 1.0F * f1;
arm2.rotateAngleX = MathHelper.cos(f * 0.4F) * 1.0F * f1;
arm4.rotateAngleX = MathHelper.cos(f * 0.4F) * 1.0F * f1;
arm6.rotateAngleX = MathHelper.cos(f * 0.4F) * 1.0F * f1;
shoulder2.rotateAngleX = MathHelper.cos(f * 0.4F) * 1.0F * f1;
thigh1.rotateAngleX = MathHelper.cos(f * 0.4F) * 0.7F * f1;
leg1.rotateAngleX = MathHelper.cos(f * 0.4F) * 0.7F * f1;
foot1.rotateAngleX = MathHelper.cos(f * 0.4F) * 0.7F * f1;
thigh2.rotateAngleX = -MathHelper.cos(f * 0.4F) * 0.7F * f1;
leg2.rotateAngleX = -MathHelper.cos(f * 0.4F) * 0.7F * f1;
foot2.rotateAngleX = -MathHelper.cos(f * 0.4F) * 0.7F * f1;
}
@Override
public void setRotationAngles(
float f, float f1, float f2, float f3, float f4, float f5, Entity par7Entity) {
super.setRotationAngles(f, f1, f2, f3, f4, f5, par7Entity);
HEADROT.rotateAngleX = Math.min(Math.max(f4, -15), +15) * (float) (Math.PI / 180f);
HEADROT.rotateAngleY = Math.min(Math.max(f3, -45), +45) * (float) (Math.PI / 180f);
}
public void setRotationAngles(float f, float f1, float f2, float f3, float f4, float f5) {
super.setRotationAngles(f, f1, f2, f3, f4, f5, null);
leg1.rotateAngleX = MathHelper.cos(f * 0.6662F) * 1.0F * f1;
leg2.rotateAngleX = MathHelper.cos(f * 0.6662F + (float) Math.PI) * 1.0F * f1;
leg1.rotateAngleZ = MathHelper.cos(f * 0.6662F) * 1.0F * f1;
leg2.rotateAngleZ = MathHelper.cos(f * 0.6662F + (float) Math.PI) * 1.0F * f1;
}
public void setRotationAngles(
float f, float f1, float f2, float f3, float f4, float f5, Entity entity) {
super.setRotationAngles(f, f1, f2, f3, f4, f5, entity);
this.inner1.rotateAngleY = f3 / (180F / (float) Math.PI);
this.inner2.rotateAngleY = f3 / (180F / (float) Math.PI);
this.inner3.rotateAngleY = f3 / (180F / (float) Math.PI);
this.bottom.rotateAngleY = f3 / (180F / (float) Math.PI);
this.Aleg.rotateAngleY = f3 / (180F / (float) Math.PI);
this.Aleg2.rotateAngleY = f3 / (180F / (float) Math.PI);
this.Bside1.rotateAngleY = f3 / (180F / (float) Math.PI);
this.Bside2.rotateAngleY = f3 / (180F / (float) Math.PI);
this.Bside3.rotateAngleY = f3 / (180F / (float) Math.PI);
this.Bside4.rotateAngleY = f3 / (180F / (float) Math.PI);
this.Cside1.rotateAngleY = f3 / (180F / (float) Math.PI);
this.Cside2.rotateAngleY = f3 / (180F / (float) Math.PI);
this.Cside3.rotateAngleY = f3 / (180F / (float) Math.PI);
this.Cside4.rotateAngleY = f3 / (180F / (float) Math.PI);
this.apple.rotateAngleY = f3 / (180F / (float) Math.PI);
this.pine.rotateAngleY = f3 / (180F / (float) Math.PI);
this.lemon.rotateAngleY = f3 / (180F / (float) Math.PI);
this.lime.rotateAngleY = f3 / (180F / (float) Math.PI);
this.bubble.rotateAngleY = f3 / (180F / (float) Math.PI);
}
@Override
public void setRotationAngles(
float f, float f1, float f2, float f3, float f4, float f5, Entity e) {
super.setRotationAngles(f, f1, f2, f3, f4, f5, e);
if ((e instanceof EntityBunny && ((EntityBunny) e).isSitting())) {
Body.rotateAngleX = 0.95993f;
Leg1.rotateAngleX = Leg2.rotateAngleX = -1.5708f;
Leg3.rotateAngleX = Leg4.rotateAngleX = -0.2818f;
Leg1.rotationPointY = Leg2.rotationPointY = 23;
Leg1.rotationPointZ = Leg2.rotationPointZ = 2;
} else {
Leg1.rotationPointY = Leg2.rotationPointY = 19;
Leg1.rotationPointZ = Leg2.rotationPointZ = 3;
this.Body.rotateAngleX = ((float) Math.PI / 2F);
this.Leg1.rotateAngleX = MathHelper.cos(f * 0.6662F) * 1.4F * f1;
this.Leg2.rotateAngleX = MathHelper.cos(f * 0.6662F + (float) Math.PI) * 1.4F * f1;
this.Leg3.rotateAngleX = MathHelper.cos(f * 0.6662F + (float) Math.PI) * 1.4F * f1;
this.Leg4.rotateAngleX = MathHelper.cos(f * 0.6662F) * 1.4F * f1;
}
this.Head.rotateAngleX = f4 / (180F / (float) Math.PI);
this.Head.rotateAngleY = f3 / (180F / (float) Math.PI);
this.Ear1.rotateAngleX = f4 / (180F / (float) Math.PI);
this.Ear1.rotateAngleY = f3 / (180F / (float) Math.PI);
this.Ear2.rotateAngleX = f4 / (180F / (float) Math.PI);
this.Ear2.rotateAngleY = f3 / (180F / (float) Math.PI);
this.tail.rotateAngleX = ((float) Math.PI / 2F);
}
/**
* The standard setRotationAngles method from ModelBase with correct parameter mappings. Calls the
* superclass method.
*
* @param swingProgress - The arm swing progress of the Entity being rendered.
* @param swingProgressPrev - The previous tick's arm swing progress of the Entity being rendered.
* @param idleProgress - The idle arm swing progress of the Entity being rendered.
* @param headYaw - The head rotation yaw of the Entity being rendered.
* @param headPitch - The head rotation pitch of the Entity being rendered.
* @param boxTranslation - The box translation offset. Default value is 0.0625F
* @param entity - The Entity instance being rendered.
*/
@Override
public void setRotationAngles(
float swingProgress,
float swingProgressPrev,
float idleProgress,
float headYaw,
float headPitch,
float boxTranslation,
Entity entity) {
super.setRotationAngles(
swingProgress, swingProgressPrev, idleProgress, headYaw, headPitch, boxTranslation, entity);
}
public void setRotationAngles(
float time, float distance, float f2, float f3, float f4, float f5, Entity entity) {
super.setRotationAngles(time, distance, f2, f3, f4, f5, entity);
float baseRotation = MathHelper.cos(time * 0.6662F) * 1.4F * distance;
Ball1.rotateAngleX = baseRotation;
Ball2.rotateAngleX = -baseRotation;
Base1.rotateAngleY = baseRotation;
Base2.rotateAngleY = baseRotation;
Base3.rotateAngleY = baseRotation;
Base4.rotateAngleY = baseRotation;
Base5.rotateAngleY = baseRotation;
Dickehead6.rotateAngleY = baseRotation;
}
public void setRotationAngles(
float f, float f1, float f2, float f3, float f4, float f5, Entity entity) {
super.setRotationAngles(f, f1, f2, f3, f4, f5, entity);
this.head.rotateAngleY = f3 / (180F / (float) Math.PI);
this.head.rotateAngleX = f4 / (180F / (float) Math.PI);
this.rightarm.rotateAngleX =
MathHelper.cos(f * 0.6662F + (float) Math.PI) * 2.0F * f1 * 0.5F * 0.5F;
this.leftarm.rotateAngleX = MathHelper.cos(f * 0.6662F) * 2.0F * f1 * 0.5F * 0.5F;
this.rightarm.rotateAngleZ = 0.0F;
this.leftarm.rotateAngleZ = 0.0F;
this.rightleg.rotateAngleX = MathHelper.cos(f * 0.6662F) * 1.4F * f1 * 0.5F;
this.leftleg.rotateAngleX = MathHelper.cos(f * 0.6662F + (float) Math.PI) * 1.4F * f1 * 0.5F;
this.rightleg.rotateAngleY = 0.0F;
this.leftleg.rotateAngleY = 0.0F;
}
public void setRotationAngles(
float par1, float par2, float par3, float par4, float par5, float par6, Entity par7Entity) {
super.setRotationAngles(par1, par2, par3, par4, par5, par6, par7Entity);
this.head.rotateAngleX = par5 / (180F / (float) Math.PI);
this.head.rotateAngleY = par4 / (180F / (float) Math.PI);
this.snout.rotateAngleX = this.head.rotateAngleX;
this.snout.rotateAngleY = this.head.rotateAngleY;
this.rightear.rotateAngleX = this.head.rotateAngleX;
this.rightear.rotateAngleY = this.head.rotateAngleY;
this.leftear.rotateAngleX = this.head.rotateAngleX;
this.leftear.rotateAngleY = this.head.rotateAngleY;
this.righthorn.rotateAngleX = this.head.rotateAngleX;
this.righthorn.rotateAngleY = this.head.rotateAngleY;
this.lefthorn.rotateAngleX = this.head.rotateAngleX;
this.lefthorn.rotateAngleY = this.head.rotateAngleY;
}
@Override
public void setRotationAngles(
float limbSwing,
float prevLimbSwing,
float entityTickTime,
float rotationYaw,
float rotationPitch,
float unitPixel,
Entity entity) {
super.setRotationAngles(
limbSwing, prevLimbSwing, entityTickTime, rotationYaw, rotationPitch, unitPixel, entity);
EntityBotFly var8 = (EntityBotFly) entity;
RWing1.rotateAngleX = var8.wingFloat;
RWing2.rotateAngleX = var8.wingFloat;
LWing1.rotateAngleX = var8.wingFloat;
LWing2.rotateAngleX = var8.wingFloat;
}
public void setRotationAngles(float f, float f1, float f2, float f3, float f4, float f5) {
super.setRotationAngles(f, f1, f2, f3, f4, f5, null);
rightarm.rotateAngleX = MathHelper.cos(f * .5F + (float) Math.PI) * 0.7F * f1;
RightHandle.rotateAngleX = MathHelper.cos(f * .5F + (float) Math.PI) * 0.7F * f1;
RightTopRung.rotateAngleX = MathHelper.cos(f * .5F + (float) Math.PI) * 0.7F * f1;
RightBack1.rotateAngleX = MathHelper.cos(f * .5F + (float) Math.PI) * 0.7F * f1 + 0.446141063F;
RightBack2.rotateAngleX = MathHelper.cos(f * .5F + (float) Math.PI) * 0.7F * f1 + -0.446141063F;
RightBack3.rotateAngleX = MathHelper.cos(f * .5F + (float) Math.PI) * 0.7F * f1;
RightBack4.rotateAngleX = MathHelper.cos(f * .5F + (float) Math.PI) * 0.7F * f1;
RightFront1.rotateAngleX = MathHelper.cos(f * .5F + (float) Math.PI) * 0.7F * f1 + 0.446141063F;
RightFront2.rotateAngleX =
MathHelper.cos(f * .5F + (float) Math.PI) * 0.7F * f1 + -0.446141063F;
RightFront3.rotateAngleX = MathHelper.cos(f * .5F + (float) Math.PI) * 0.7F * f1;
RightFront4.rotateAngleX = MathHelper.cos(f * .5F + (float) Math.PI) * 0.7F * f1;
RightTopSpike.rotateAngleX = MathHelper.cos(f * .5F + (float) Math.PI) * 0.7F * f1;
RightMain.rotateAngleX = MathHelper.cos(f * .5F + (float) Math.PI) * 0.7F * f1;
RightBottomRung.rotateAngleX = MathHelper.cos(f * .5F + (float) Math.PI) * 0.7F * f1;
RightBottomSpike.rotateAngleX = MathHelper.cos(f * .5F + (float) Math.PI) * 0.7F * f1;
RightHammerSpike1.rotateAngleX = MathHelper.cos(f * .5F + (float) Math.PI) * 0.7F * f1;
RightHammerSpike2.rotateAngleX = MathHelper.cos(f * .5F + (float) Math.PI) * 0.7F * f1;
RightHammerSpike3.rotateAngleX = MathHelper.cos(f * .5F + (float) Math.PI) * 0.7F * f1;
RightHammerSpike4.rotateAngleX = MathHelper.cos(f * .5F + (float) Math.PI) * 0.7F * f1;
LeftHandle.rotateAngleX = MathHelper.cos(f * .5F) * 0.7F * f1;
LeftTopRung.rotateAngleX = MathHelper.cos(f * .5F) * 0.7F * f1;
LeftBack1.rotateAngleX = MathHelper.cos(f * .5F) * 0.7F * f1 + 0.446141063F;
LeftBack2.rotateAngleX = MathHelper.cos(f * .5F) * 0.7F * f1 + -0.446141063F;
LeftBack3.rotateAngleX = MathHelper.cos(f * .5F) * 0.7F * f1;
LeftBack4.rotateAngleX = MathHelper.cos(f * .5F) * 0.7F * f1;
LeftFront1.rotateAngleX = MathHelper.cos(f * .5F) * 0.7F * f1 + 0.446141063F;
LeftFront2.rotateAngleX = MathHelper.cos(f * .5F) * 0.7F * f1 + -0.446141063F;
LeftFront3.rotateAngleX = MathHelper.cos(f * .5F) * 0.7F * f1;
LeftFront4.rotateAngleX = MathHelper.cos(f * .5F) * 0.7F * f1;
LeftTopSpike.rotateAngleX = MathHelper.cos(f * .5F) * 0.7F * f1;
LeftMain.rotateAngleX = MathHelper.cos(f * .5F) * 0.7F * f1;
LeftBottomRung.rotateAngleX = MathHelper.cos(f * .5F) * 0.7F * f1;
LeftBottomSpike.rotateAngleX = MathHelper.cos(f * .5F) * 0.7F * f1;
LeftHammerSpike1.rotateAngleX = MathHelper.cos(f * .5F) * 0.7F * f1;
LeftHammerSpike2.rotateAngleX = MathHelper.cos(f * .5F) * 0.7F * f1;
LeftHammerSpike3.rotateAngleX = MathHelper.cos(f * .5F) * 0.7F * f1;
LeftHammerSpike4.rotateAngleX = MathHelper.cos(f * .5F) * 0.7F * f1;
rightleg.rotateAngleX = MathHelper.cos(f * 0.6662F + (float) Math.PI) * 1.0F * f1;
leftleg.rotateAngleX = MathHelper.cos(f * 0.6662F) * 1.0F * f1;
}
public void setRotationAngles(
float f, float f1, float f2, float f3, float f4, float f5, Entity entity) {
super.setRotationAngles(f, f1, f2, f3, f4, f5, entity);
this.golemHead.rotateAngleY = f3 / (180F / (float) Math.PI);
this.golemHead.rotateAngleX = f4 / (180F / (float) Math.PI);
this.legLeftTop.rotateAngleX = -1.5F * this.func_78172_a(f, 13.0F) * f1 + -0.2974289F;
this.legLeftMiddle.rotateAngleX = -1.5F * this.func_78172_a(f, 13.0F) * f1;
this.legLeftBottom.rotateAngleX = -1.5F * this.func_78172_a(f, 13.0F) * f1;
this.legRightTop.rotateAngleX = 1.5F * this.func_78172_a(f, 13.0F) * f1 + -0.2974289F;
this.legRightMiddle.rotateAngleX = 1.5F * this.func_78172_a(f, 13.0F) * f1;
this.legRightBottom.rotateAngleX = 1.5F * this.func_78172_a(f, 13.0F) * f1;
this.legLeftTop.rotateAngleY = -0.185895F;
this.legLeftMiddle.rotateAngleY = -6.391F;
this.legLeftBottom.rotateAngleY = 0.0F;
this.legRightTop.rotateAngleY = 0.185895F;
this.legRightMiddle.rotateAngleY = 6.391F;
this.legRightBottom.rotateAngleY = 0.0F;
}
/**
* Sets the model's various rotation angles. For bipeds, par1 and par2 are used for animating the
* movement of arms and legs, where par1 represents the time(so that arms and legs swing back and
* forth) and par2 represents how "far" arms and legs can swing at most.
*/
public void setRotationAngles(
float var1, float var2, float var3, float var4, float var5, float var6, Entity var7) {
super.setRotationAngles(var1, var2, var3, var4, var5, var6, var7);
float var8 =
(float) (Math.sin((double) (var1 * 20.0F) / (180D / Math.PI)) * (double) var2 * 0.5D);
float var9 = (float) Math.PI;
float var10 = var9 / 2.0F;
float var11 = var9 * 3.0F / 11.0F;
this.LeftFace.rotationPointY = var8 + 8.0F;
this.LeftFace.rotationPointX = var8 * 0.5F;
this.BodyLeftSide1.rotationPointY = 8.0F - var8 * 0.5F;
this.BodyLeftSide2.rotationPointY = 9.0F + var8 * 0.5F;
this.RightFace.rotationPointY = 8.0F - var8;
this.RightFace.rotationPointX = -var8 * 0.5F;
this.BodyRightSide1.rotationPointY = 8.0F - var8 * 0.5F;
this.BodyRightSide2.rotationPointY = 9.0F + var8 * 0.5F;
this.Tail1.rotationPointX =
(float) (Math.sin((double) (var1 * 20.0F) / (180D / Math.PI)) * (double) var2 * 0.75D);
this.Tail1.rotateAngleY =
(float) Math.pow(0.9900000095367432D, -4.0D)
* 1.0F
* var9
/ 4.0F
* MathHelper.cos(-0.055F * var1 + var10);
this.Tail1.rotationPointY = 8.0F - var8;
this.Tail2.rotationPointX =
(float) Math.pow(0.9900000095367432D, 1.0D)
* 1.0F
* var9
/ 4.0F
* MathHelper.cos(-0.055F * var1 + var10);
this.Tail2.rotationPointY = var8 * 1.25F;
this.Tail2.rotateAngleY = this.Tail1.rotateAngleY + 0.25F;
this.Tail3.rotationPointX =
(float) Math.pow(0.9900000095367432D, 2.0D)
* 1.0F
* var9
/ 4.0F
* MathHelper.cos(-0.055F * var1 + var10);
this.Tail3.rotationPointY = -var8;
this.Tail3.rotateAngleY = this.Tail2.rotateAngleY + 0.35F;
}
@Override
public void setRotationAngles(
float limbSwing,
float limbSwingAngle,
float entityTickTime,
float rotationYaw,
float rotationPitch,
float unitPixel,
Entity entity) {
super.setRotationAngles(
limbSwing, limbSwingAngle, entityTickTime, rotationYaw, rotationPitch, unitPixel, entity);
EntityMidgeSwarm midge = (EntityMidgeSwarm) entity;
WingL.rotateAngleX = midge.wingFloat;
WingL2.rotateAngleX = midge.wingFloat;
WingL3.rotateAngleX = midge.wingFloat;
WingL4.rotateAngleX = midge.wingFloat;
WingR.rotateAngleX = midge.wingFloat;
WingR2.rotateAngleX = midge.wingFloat;
WingR3.rotateAngleX = midge.wingFloat;
WingR4.rotateAngleX = midge.wingFloat;
}
public void setRotationAngles(
float par1, float par2, float par3, float par4, float par5, float par6, Entity par7Entity) {
super.setRotationAngles(par1, par2, par3, par4, par5, par6, par7Entity);
this.Leg1MidB.rotateAngleX = MathHelper.cos(par1 * 0.6662F) * 1.4F * par2;
this.Leg1MidT.rotateAngleX = MathHelper.cos(par1 * 0.6662F) * 1.4F * par2;
this.Foot1.rotateAngleX = MathHelper.cos(par1 * 0.6662F) * 1.4F * par2;
this.Heel1.rotateAngleX = MathHelper.cos(par1 * 0.6662F) * 1.4F * par2;
this.Foot1.rotateAngleX = MathHelper.cos(par1 * 0.6662F) * 1.4F * par2;
this.Toe1.rotateAngleX = MathHelper.cos(par1 * 0.6662F) * 1.4F * par2;
this.Leg2MidB.rotateAngleX = MathHelper.cos(par1 * 0.6662F + (float) Math.PI) * 1.4F * par2;
this.Leg2MidT.rotateAngleX = MathHelper.cos(par1 * 0.6662F + (float) Math.PI) * 1.4F * par2;
this.Foot2.rotateAngleX = MathHelper.cos(par1 * 0.6662F + (float) Math.PI) * 1.4F * par2;
this.Heel2.rotateAngleX = MathHelper.cos(par1 * 0.6662F + (float) Math.PI) * 1.4F * par2;
this.Toe2.rotateAngleX = MathHelper.cos(par1 * 0.6662F + (float) Math.PI) * 1.4F * par2;
this.Arm1.rotateAngleX = MathHelper.cos(par1 * 0.6662F) * 1.4F * par2;
this.Arm2.rotateAngleX = MathHelper.cos(par1 * 0.6662F) * 1.4F * par2;
this.Arm2.rotateAngleX = MathHelper.cos(par1 * 0.6662F + (float) Math.PI) * 1.4F * par2;
this.Arm4.rotateAngleX = MathHelper.cos(par1 * 0.6662F + (float) Math.PI) * 1.4F * par2;
{
}
}
@Override
public void superSetRotationAngles(
float par1, float par2, float par3, float par4, float par5, float par6, Object entity) {
super.setRotationAngles(par1, par2, par3, par4, par5, par6, (Entity) entity);
}
public void setRotationAngles(
float var1, float var2, float var3, float var4, float var5, float var6) {
super.setRotationAngles(var1, var2, var3, var4, var5, var6, (Entity) null);
}
@Override
public void setRotationAngles(
float f, float f1, float f2, float f3, float f4, float f5, Entity entity) {
super.setRotationAngles(f, f1, f2, f3, f4, f5, entity);
if (entity instanceof EntityStatue) return;
EntityOverlordCore core = (EntityOverlordCore) entity;
brainSac.rotateAngleY = brain.rotateAngleY = (f3 / (180F / (float) Math.PI)) * 0.35F;
brainSac.rotateAngleX = brain.rotateAngleX = (f4 / (180F / (float) Math.PI)) * 0.35F;
brainSac.rotateAngleZ = 0F;
head.rotateAngleX = 0F;
brain.rotateAngleZ = 0F;
upperLegFR.rotateAngleY =
upperLegFL.rotateAngleY =
upperLegFMR.rotateAngleY =
upperLegFML.rotateAngleY =
legBMR.rotateAngleY =
legBML.rotateAngleY =
legBR.rotateAngleY =
legBL.rotateAngleY = (f3 / (180F / (float) Math.PI));
upperLegFR.rotateAngleZ =
upperLegFL.rotateAngleZ =
upperLegFMR.rotateAngleZ =
upperLegFML.rotateAngleZ =
legBMR.rotateAngleZ =
legBML.rotateAngleZ =
legBR.rotateAngleZ =
legBL.rotateAngleZ = (f4 / (180F / (float) Math.PI));
if (core.getTransformationTicks() > 0) {
upperLegFL.rotateAngleZ = this.simplifyAngle(core.ticksExisted, 10.0F) * 0.38F - 0.38F;
upperLegFR.rotateAngleZ = this.simplifyAngle(core.ticksExisted - 7, 10.0F) * -0.38F + 0.38F;
upperLegFML.rotateAngleZ = this.simplifyAngle(core.ticksExisted + 4, 10.0F) * 0.21F - 0.21F;
upperLegFMR.rotateAngleZ = this.simplifyAngle(core.ticksExisted - 2, 10.0F) * -0.21F + 0.21F;
legBML.rotateAngleZ = this.simplifyAngle(core.ticksExisted + 4, 6.0F) * 0.22F - 0.22F;
legBMR.rotateAngleZ = this.simplifyAngle(core.ticksExisted + 2, 6.0F) * -0.22F + 0.22F;
legBR.rotateAngleZ = this.simplifyAngle(core.ticksExisted, 6.0F) * -0.22F + 0.22F;
legBL.rotateAngleZ = this.simplifyAngle(core.ticksExisted - 3, 6.0F) * 0.22F - 0.22F;
head.rotateAngleX = -0.23F;
if (core.getTransformationTicks() >= 20) {
pincerLeft.rotateAngleY = 0.57F - this.simplifyAngle(core.ticksExisted, 3F) * 0.125F;
pincerRight.rotateAngleY = -0.57F + this.simplifyAngle(core.ticksExisted, 3F) * 0.125F;
lowerJaw.rotateAngleX = 0.35F + this.simplifyAngle(core.ticksExisted, 5F) * 0.0125F;
} else {
pincerRight.rotateAngleY = -0.47F;
pincerLeft.rotateAngleY = 0.47F;
lowerJaw.rotateAngleX = -0.13F;
}
return;
}
if (core.getHoverTicks() > 0) {
upperLegFL.rotateAngleZ = this.simplifyAngle(core.getHoverTicks(), 10.0F) * 0.38F - 0.38F;
upperLegFR.rotateAngleZ =
this.simplifyAngle(core.getHoverTicks() - 7, 10.0F) * -0.38F + 0.38F;
upperLegFML.rotateAngleZ =
this.simplifyAngle(core.getHoverTicks() + 4, 10.0F) * 0.21F - 0.21F;
upperLegFMR.rotateAngleZ =
this.simplifyAngle(core.getHoverTicks() - 2, 10.0F) * -0.21F + 0.21F;
legBML.rotateAngleZ = this.simplifyAngle(core.getHoverTicks() + 4, 6.0F) * 0.22F - 0.22F;
legBMR.rotateAngleZ = this.simplifyAngle(core.getHoverTicks() + 2, 6.0F) * -0.22F + 0.22F;
legBR.rotateAngleZ = this.simplifyAngle(core.getHoverTicks(), 6.0F) * -0.22F + 0.22F;
legBL.rotateAngleZ = this.simplifyAngle(core.getHoverTicks() - 3, 6.0F) * 0.22F - 0.22F;
pincerLeft.rotateAngleY = this.simplifyAngle(core.getHoverTicks(), 5.0F) * 0.15F + 0.36F;
pincerRight.rotateAngleY = this.simplifyAngle(core.getHoverTicks(), 5.0F) * -0.15F - 0.36F;
lowerJaw.rotateAngleX = this.simplifyAngle(core.getHoverTicks(), 5.0F) * -0.15F + 0.25F;
brainSac.rotateAngleZ =
brain.rotateAngleZ = this.simplifyAngle(core.getHoverTicks() + 2, 5.0F) * -0.05F + 0.025F;
brainSac.rotateAngleX =
brain.rotateAngleX = this.simplifyAngle(core.getHoverTicks(), 3.0F) * -0.025F + 0.025F;
} else {
if (core.getDropTicks() > 10 && core.isNearTarget()) {
upperLegFL.rotateAngleZ = this.simplifyAngle(core.getDropTicks(), 10.0F) * 0.38F - 0.38F;
upperLegFR.rotateAngleZ =
this.simplifyAngle(core.getDropTicks() - 7, 10.0F) * -0.38F + 0.38F;
upperLegFML.rotateAngleZ =
this.simplifyAngle(core.getDropTicks() + 4, 10.0F) * 0.21F - 0.21F;
upperLegFMR.rotateAngleZ =
this.simplifyAngle(core.getDropTicks() - 2, 10.0F) * -0.21F + 0.21F;
legBML.rotateAngleZ = this.simplifyAngle(core.getDropTicks() + 4, 6.0F) * 0.22F - 0.22F;
legBMR.rotateAngleZ = this.simplifyAngle(core.getDropTicks() + 2, 6.0F) * -0.22F + 0.22F;
legBR.rotateAngleZ = this.simplifyAngle(core.getDropTicks(), 6.0F) * -0.22F + 0.22F;
legBL.rotateAngleZ = this.simplifyAngle(core.getDropTicks() - 3, 6.0F) * 0.22F - 0.22F;
pincerLeft.rotateAngleY = this.simplifyAngle(core.getDropTicks(), 5.0F) * 0.25F + 0.36F;
pincerRight.rotateAngleY = this.simplifyAngle(core.getDropTicks(), 5.0F) * -0.25F - 0.36F;
lowerJaw.rotateAngleX = this.simplifyAngle(core.getDropTicks(), 5.0F) * -0.15F + 0.25F;
head.rotateAngleX = 1.05F;
} else if (core.isNearTarget() || core.getHurtTicks() > 0) {
upperLegFL.rotateAngleZ = this.simplifyAngle(core.ticksExisted, 10.0F) * 0.38F - 0.38F;
upperLegFR.rotateAngleZ = this.simplifyAngle(core.ticksExisted - 7, 10.0F) * -0.38F + 0.38F;
upperLegFML.rotateAngleZ = this.simplifyAngle(core.ticksExisted + 4, 10.0F) * 0.21F - 0.21F;
upperLegFMR.rotateAngleZ =
this.simplifyAngle(core.ticksExisted - 2, 10.0F) * -0.21F + 0.21F;
legBML.rotateAngleZ = this.simplifyAngle(core.ticksExisted + 4, 6.0F) * 0.22F - 0.22F;
legBMR.rotateAngleZ = this.simplifyAngle(core.ticksExisted + 2, 6.0F) * -0.22F + 0.22F;
legBR.rotateAngleZ = this.simplifyAngle(core.ticksExisted, 6.0F) * -0.22F + 0.22F;
legBL.rotateAngleZ = this.simplifyAngle(core.ticksExisted - 3, 6.0F) * 0.22F - 0.22F;
pincerLeft.rotateAngleY = this.simplifyAngle(core.ticksExisted, 5.0F) * 0.25F + 0.36F;
pincerRight.rotateAngleY = this.simplifyAngle(core.ticksExisted, 5.0F) * -0.25F - 0.36F;
lowerJaw.rotateAngleX = this.simplifyAngle(core.getHoverTicks(), 5.0F) * -0.15F + 0.25F;
}
if (core.getVulnerableTicks() > 0 || core.getHurtTicks() > 0) {
brainSac.rotateAngleZ =
brain.rotateAngleZ =
this.simplifyAngle(core.getVulnerableTicks() + 6, 15.0F) * -0.05F + 0.05F;
brainSac.rotateAngleX =
brain.rotateAngleX =
this.simplifyAngle(core.getVulnerableTicks() - 12, 15.0F) * -0.05F + 0.05F;
brainSac.rotateAngleY =
brain.rotateAngleY =
this.simplifyAngle(core.getVulnerableTicks(), 15.0F) * -0.05F + 0.05F;
}
}
}
public void setRotationAngles(float f, float f1, float f2, float f3, float f4, float f5) {
super.setRotationAngles(f, f1, f2, f3, f4, f5, null);
}
public void setRotationAngles(
Entity entity, float f, float f1, float f2, float f3, float f4, float f5) {
super.setRotationAngles(f, f1, f2, f3, f4, f5, entity);
}
public void setRotationAngles(float f, float f1, float f2, float f3, float f4, float f5) {
super.setRotationAngles(f, f1, f2, f3, f4, f5, null);
rightleg1.rotateAngleX = MathHelper.cos(f * 0.6662F) * 1.4F * f1;
Leftleg1.rotateAngleX = MathHelper.cos(f * 0.6662F + (float) Math.PI) * 1.4F * f1;
Jaw2.rotateAngleX = MathHelper.cos(f * 0.6662F) * 1.4F * f1;
}
@Override
public void setRotationAngles(
float par1, float par2, float par3, float par4, float par5, float par6, Entity entity) {
super.setRotationAngles(par1, par2, par3, par4, par5, par6, entity);
}
public void setRotationAngles(float f, float f1, float f2, float f3, float f4, float f5) {
super.setRotationAngles(f, f1, f2, f3, f4, f5, null);
this.Shape1.rotationPointY = (MathHelper.sin(f2 * 0.3F) * 6F) + 7;
this.Shape2.rotationPointY = (MathHelper.sin(f2 * 0.2F) * 6F) + 7;
this.Shape3.rotationPointY = (MathHelper.sin(f2 * 0.4F) * 6F) + 7;
}
@Override
public void setRotationAngles(
float par1, float par2, float par3, float par4, float par5, float par6, Entity e) {
final EntitySkeletonBoss boss = (EntitySkeletonBoss) e;
super.setRotationAngles(par1, par2, par3, par4, par5, par6, e);
this.UpperHead.rotateAngleY = 0;
this.UpperHead.rotateAngleX = 0;
this.RightArm.rotateAngleX =
MathHelper.cos(par1 * 0.6662F + (float) Math.PI) * 2.0F * par2 * 0.5F;
this.LeftArm.rotateAngleX = MathHelper.cos(par1 * 0.6662F) * 2.0F * par2 * 0.5F;
this.RightArm.rotateAngleZ = 0.0F;
this.LeftArm.rotateAngleZ = 0.0F;
this.RightLeg.rotateAngleX = MathHelper.cos(par1 * 0.6662F) * 1.4F * par2;
this.LeftLeg.rotateAngleX = MathHelper.cos(par1 * 0.6662F + (float) Math.PI) * 1.4F * par2;
this.RightLeg.rotateAngleY = 0.0F;
this.LeftLeg.rotateAngleY = 0.0F;
if (this.isRiding) {
this.RightArm.rotateAngleX += -((float) Math.PI / 5F);
this.LeftArm.rotateAngleX += -((float) Math.PI / 5F);
this.RightLeg.rotateAngleX = -((float) Math.PI * 2F / 5F);
this.LeftLeg.rotateAngleX = -((float) Math.PI * 2F / 5F);
this.RightLeg.rotateAngleY = (float) Math.PI / 10F;
this.LeftLeg.rotateAngleY = -((float) Math.PI / 10F);
}
this.RightArm.rotateAngleY = 0.0F;
this.LeftArm.rotateAngleY = 0.0F;
float var7;
float var8;
if (this.onGround > -9990.0F) {
var7 = this.onGround;
this.Spine.rotateAngleY =
MathHelper.sin(MathHelper.sqrt_float(var7) * (float) Math.PI * 2.0F) * 0.2F;
this.RightArm.rotationPointZ = MathHelper.sin(this.Spine.rotateAngleY) * 5.0F;
this.RightArm.rotationPointX = -MathHelper.cos(this.Spine.rotateAngleY) * 5.0F;
this.LeftArm.rotationPointZ = -MathHelper.sin(this.Spine.rotateAngleY) * 5.0F;
this.LeftArm.rotationPointX = MathHelper.cos(this.Spine.rotateAngleY) * 5.0F;
this.RightArm.rotateAngleY += this.Spine.rotateAngleY;
this.LeftArm.rotateAngleY += this.Spine.rotateAngleY;
this.LeftArm.rotateAngleX += this.Spine.rotateAngleY;
var7 = 1.0F - this.onGround;
var7 *= var7;
var7 *= var7;
var7 = 1.0F - var7;
var8 = MathHelper.sin(var7 * (float) Math.PI);
final float var9 =
MathHelper.sin(this.onGround * (float) Math.PI)
* -(this.UpperHead.rotateAngleX - 0.7F)
* 0.75F;
this.RightArm.rotateAngleX = (float) (this.RightArm.rotateAngleX - (var8 * 1.2D + var9));
this.RightArm.rotateAngleY += this.Spine.rotateAngleY * 2.0F;
this.RightArm.rotateAngleZ = MathHelper.sin(this.onGround * (float) Math.PI) * -0.4F;
}
this.RightArm.rotateAngleZ += MathHelper.cos(par3 * 0.09F) * 0.05F + 0.05F;
this.LeftArm.rotateAngleZ -= MathHelper.cos(par3 * 0.09F) * 0.05F + 0.05F;
this.RightArm.rotateAngleX += MathHelper.sin(par3 * 0.067F) * 0.05F;
this.LeftArm.rotateAngleX -= MathHelper.sin(par3 * 0.067F) * 0.05F;
MathHelper.sin(this.onGround * (float) Math.PI);
MathHelper.sin((1.0F - (1.0F - this.onGround) * (1.0F - this.onGround)) * (float) Math.PI);
var7 = 0.0F;
var8 = 0.0F;
this.RightArm.rotateAngleZ = 0.0F;
this.LeftArm.rotateAngleZ = 0.0F;
this.RightArm.rotateAngleY = -(0.1F - var7 * 0.6F) + this.UpperHead.rotateAngleY;
this.LeftArm.rotateAngleY = 0.1F - var7 * 0.6F + this.UpperHead.rotateAngleY + 0.4F;
this.RightArm.rotateAngleX = -((float) Math.PI / 2F) + this.UpperHead.rotateAngleX;
this.LeftArm.rotateAngleX = -((float) Math.PI / 2F) + this.UpperHead.rotateAngleX;
this.RightArm.rotateAngleX -= var7 * 1.2F - var8 * 0.4F;
this.LeftArm.rotateAngleX -= var7 * 1.2F - var8 * 0.4F;
this.RightArm.rotateAngleZ += MathHelper.cos(par3 * 0.09F) * 0.05F + 0.05F;
this.LeftArm.rotateAngleZ -= MathHelper.cos(par3 * 0.09F) * 0.05F + 0.05F;
this.RightArm.rotateAngleX += MathHelper.sin(par3 * 0.067F) * 0.05F;
this.LeftArm.rotateAngleX -= MathHelper.sin(par3 * 0.067F) * 0.05F;
final float f6 = MathHelper.sin(this.onGround * (float) Math.PI);
final float f7 =
MathHelper.sin((1.0F - (1.0F - this.onGround) * (1.0F - this.onGround)) * (float) Math.PI);
this.RightArm.rotateAngleZ = 0.0F;
this.LeftArm.rotateAngleZ = 0.0F;
this.RightArm.rotateAngleY = -(0.1F - f6 * 0.6F);
this.LeftArm.rotateAngleY = 0.1F - f6 * 0.6F;
this.RightArm.rotateAngleX = -((float) Math.PI / 2F);
this.LeftArm.rotateAngleX = -((float) Math.PI / 2F);
this.RightArm.rotateAngleX -= f6 * 1.2F - f7 * 0.4F;
this.LeftArm.rotateAngleX -= f6 * 1.2F - f7 * 0.4F;
this.RightArm.rotateAngleZ += MathHelper.cos(par3 * 0.09F) * 0.05F + 0.05F;
this.LeftArm.rotateAngleZ -= MathHelper.cos(par3 * 0.09F) * 0.05F + 0.05F;
this.RightArm.rotateAngleX += MathHelper.sin(par3 * 0.067F) * 0.05F;
this.LeftArm.rotateAngleX -= MathHelper.sin(par3 * 0.067F) * 0.05F;
if (boss.throwTimer + boss.postThrowDelay > 0) {
this.RightArm.rotateAngleX -=
MathHelper.cos((boss.throwTimer + boss.postThrowDelay) * 0.05F) * 1.2F + 0.05F;
this.LeftArm.rotateAngleX -=
MathHelper.cos((boss.throwTimer + boss.postThrowDelay) * 0.05F) * 1.2F + 0.05F;
}
}
@Override
public void setRotationAngles(
float par1, float par2, float par3, float par4, float par5, float par6, Entity entity) {
if (master != null) master.setRotationAngles(par1, par2, par3, par4, par5, par6, entity);
else super.setRotationAngles(par1, par2, par3, par4, par5, par6, entity);
}
@Override
public void setRotationAngles(
float f, float f1, float f2, float f3, float f4, float f5, Entity ent) {
super.setRotationAngles(f, f1, f2, f3, f4, f5, ent);
}
public void setRotationAngles(
float f, float f1, float f2, float f3, float f4, float f5, Entity ent) {
super.setRotationAngles(f, f1, f2, f3, f4, f5, ent);
FootRight.rotateAngleX = MathHelper.cos(f * 0.6662F + (float) Math.PI) * 1.0F * f1;
Footleft.rotateAngleX = MathHelper.cos(f * 0.6662F) * 1.0F * f1;
}
public void setRotationAngles(
float par1, float par2, float par3, float par4, float par5, float par6, Entity par7Entity) {
super.setRotationAngles(par1, par2, par3, par4, par5, par6, par7Entity);
}
public void setRotationAngles(
float f, float f1, float f2, float f3, float f4, float f5, Entity e) {
super.setRotationAngles(f, f1, f2, f3, f4, f5, e);
}
/**
* Sets the model's various rotation angles. For bipeds, par1 and par2 are used for animating the
* movement of arms and legs, where par1 represents the time(so that arms and legs swing back and
* forth) and par2 represents how "far" arms and legs can swing at most.
*/
public void setRotationAngles(
float var1, float var2, float var3, float var4, float var5, float var6, Entity var7) {
super.setRotationAngles(var1, var2, var3, var4, var5, var6, var7);
}