Beispiel #1
0
 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;
 }
Beispiel #2
0
 @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);
  }
Beispiel #5
0
 @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);
 }
Beispiel #6
0
 /**
  * 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);
 }
Beispiel #7
0
 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;
  }
Beispiel #9
0
 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;
 }
Beispiel #10
0
 @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;
 }
Beispiel #11
0
  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;
 }
Beispiel #13
0
 /**
  * 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;
    {
    }
  }
Beispiel #16
0
 @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);
 }
Beispiel #21
0
 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);
 }
Beispiel #23
0
 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;
    }
  }
Beispiel #25
0
 @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);
 }
Beispiel #29
0
 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);
 }