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;
}
/** Sets the models various rotation angles. */
public void setRotationAngles(float f, float f1, float f2, float f3, float f4, float f5) {
headCamel.rotateAngleY = f3 / (180F / (float) Math.PI);
headCamel.rotateAngleX = f4 / (180F / (float) Math.PI);
mouth.rotateAngleY = earR.rotateAngleY = earL.rotateAngleY = headCamel.rotateAngleY;
earR.rotateAngleX = earL.rotateAngleX = headCamel.rotateAngleX;
mouth.rotateAngleX = headCamel.rotateAngleX + 0.29382F;
if (taildirection > 0) {
tailwag += 0.0002F;
if (tailwag > 0.067F) {
taildirection = taildirection * -1;
}
} else {
tailwag -= 0.0002F;
if ((double) tailwag < -0.067000000000000004D) {
taildirection = taildirection * -1;
}
}
leg1.rotateAngleX = MathHelper.cos(f * 0.6662F) * 1.4F * f1;
leg2.rotateAngleX = MathHelper.cos(f * 0.6662F + (float) Math.PI) * 1.4F * f1;
leg3.rotateAngleX = MathHelper.cos(f * 0.6662F + (float) Math.PI) * 1.4F * f1;
leg4.rotateAngleX = MathHelper.cos(f * 0.6662F) * 1.4F * f1;
}
@Override
public void setRotationAngles(
float f, float f1, float f2, float f3, float f4, float f5, Entity entity) {
if (!(entity instanceof EntityTimeController)) return;
EntityTimeController ctrl = (EntityTimeController) entity;
if (ctrl.ticksExisted % 4 == 0
|| ctrl.getFluxTicks() > 0
|| ctrl.hurtTime > 0
|| ctrl.getSpazTicks() > 0) {
ModelRenderer cube = this.getRandomCube(entity.worldObj.rand);
if (ctrl.ticksExisted % 7 == 0) {
cube.offsetX += MathHelper.cos(ctrl.ticksExisted + ctrl.getEntityId()) * 0.45F;
} else if (ctrl.ticksExisted % 13 == 0) {
cube.offsetY += MathHelper.cos(ctrl.ticksExisted * ctrl.getEntityId()) * 0.45F;
} else if (ctrl.ticksExisted % 3 == 0) {
cube.offsetZ += MathHelper.cos(ctrl.ticksExisted - ctrl.getEntityId()) * 0.45F;
}
cube.offsetX += MathHelper.cos(ctrl.ticksExisted + ctrl.getEntityId()) * 0.25F;
cube.offsetY += MathHelper.cos(ctrl.ticksExisted * ctrl.getEntityId()) * 0.25F;
cube.offsetZ += MathHelper.cos(ctrl.ticksExisted - ctrl.getEntityId()) * 0.25F;
if (Math.abs(cube.offsetX) > 0.5F) cube.offsetX = 0.0F;
if (Math.abs(cube.offsetY) > 0.5F) cube.offsetY = 0.0F;
if (Math.abs(cube.offsetZ) > 0.5F) cube.offsetZ = 0.0F;
}
center.offsetY = 0.0F;
center.offsetX = 0.0F;
center.offsetZ = 0.0F;
center.rotateAngleX = this.simplifyAngle(ctrl.ticksExisted, 120.0F) * 0.05F;
center.rotateAngleY = this.simplifyAngle(ctrl.ticksExisted + 72, 120.0F) * 0.25F;
center.rotateAngleZ = this.simplifyAngle(ctrl.ticksExisted + 35, 120.0F) * 0.05F;
if (ctrl.getFluxTicks() > 0) {
center.rotateAngleY =
(float) (Math.sin(Math.PI * this.simplifyAngle(ctrl.ticksExisted, 10.0F)));
center.rotateAngleX =
(float) (Math.sin(Math.PI * this.simplifyAngle(ctrl.ticksExisted + 6, 10.0F)));
center.rotateAngleZ =
(float) (Math.sin(Math.PI * this.simplifyAngle(ctrl.ticksExisted + 2, 10.0F)));
} else if (ctrl.getLeapTicks() > 0) {
center.offsetY = this.simplifyAngle(ctrl.ticksExisted, 30.0F) * 0.725F;
center.offsetX = this.simplifyAngle(ctrl.ticksExisted, 40.0F) * 0.725F;
center.offsetZ = this.simplifyAngle(ctrl.ticksExisted, 20.0F) * 0.725F;
} else if (ctrl.getPurgeTicks() > 0) {
center.rotateAngleY = (float) (this.simplifyAngle(ctrl.ticksExisted, 20.0F) * Math.PI);
} else if (ctrl.getSpazTicks() > 0) {
center.rotateAngleZ =
(float) (Math.sin(Math.PI * this.simplifyAngle(ctrl.ticksExisted + 2, 10.0F)));
center.offsetX = ctrl.worldObj.rand.nextFloat() - ctrl.worldObj.rand.nextFloat();
}
}
@Override
public void setRotationAngles(
float f, float f1, float f2, float f3, float f4, float f5, Entity par7Entity) {
head.rotateAngleX = f4 / (180F / (float) Math.PI);
head.rotateAngleY = f3 / (180F / (float) Math.PI);
light.rotateAngleX = head.rotateAngleX;
light.rotateAngleY = head.rotateAngleY;
leg1.rotateAngleX = MathHelper.cos(f * 0.6662F) * 1.4F * f1;
leg2.rotateAngleX = MathHelper.cos(f * 0.6662F + (float) Math.PI) * 1.4F * f1;
leg1.rotateAngleY = 0.0F;
leg2.rotateAngleY = 0.0F;
}
public ModelCowTFC() {
super(12, 0.0F);
this.head = new ModelRenderer(this, 0, 0);
this.head.addBox(-4.0F, -4.0F, -6.0F, 8, 8, 6, 0.0F);
this.head.setRotationPoint(0.0F, 4.0F, -8.0F);
horn1 = new ModelRenderer(this, 22, 0);
horn1.addBox(0F, 0F, 0F, 1, 3, 1, 0.15F);
horn1.setRotationPoint(-5.5F, -2.5F, -2F);
horn1.rotateAngleZ = (float) -Math.PI / 2;
horn1b = new ModelRenderer(this, 22, 0);
horn1b.addBox(0, -2.1f, -0.5f, 1, 3, 1, 0F);
horn1b.setRotationPoint(0f, 0f, 0f);
horn1b.rotateAngleX = (float) Math.PI / 3f;
horn1b.rotateAngleY = (float) -Math.PI / 12f;
horn1.addChild(horn1b);
this.head.addChild(horn1);
horn2 = new ModelRenderer(this, 22, 0);
horn2.addBox(0F, -3F, 0F, 1, 3, 1, 0.15F);
horn2.setRotationPoint(5.5F, -2.5F, -2F);
horn2.rotateAngleZ = (float) -Math.PI / 2;
horn2b = new ModelRenderer(this, 22, 0);
horn2b.addBox(0f, -0.8F, -0.5f, 1, 3, 1, 0F);
horn2b.setRotationPoint(0F, 0F, 0F);
horn2b.rotateAngleX = (float) -Math.PI / 3F;
horn2b.rotateAngleY = (float) -Math.PI / 12F;
horn2.addChild(horn2b);
this.head.addChild(horn2);
this.body = new ModelRenderer(this, 18, 4);
this.body.addBox(-6.0F, -10.0F, -7.0F, 12, 18, 10, 0.0F);
this.body.setRotationPoint(0.0F, 5.0F, 2.0F);
this.udders = new ModelRenderer(this, 18, 4);
this.udders.setRotationPoint(0.0F, 5.0F, 2.0F);
this.udders.setTextureOffset(52, 0).addBox(-2.0F, 2.0F, -8.0F, 4, 6, 1);
--this.leg1.rotationPointX;
++this.leg2.rotationPointX;
this.leg1.rotationPointZ += 0.0F;
this.leg2.rotationPointZ += 0.0F;
--this.leg3.rotationPointX;
++this.leg4.rotationPointX;
--this.leg3.rotationPointZ;
--this.leg4.rotationPointZ;
this.field_78151_h += 2.0F;
}
@Override
public void setRotationAngles(
float f, float f1, float f2, float f3, float f4, float f5, Entity entity) {
if (!(entity instanceof EntityClaymation)) return;
EntityClaymation clay = (EntityClaymation) entity;
head.rotateAngleY = f3 / (180F / (float) Math.PI);
head.rotateAngleX = f4 / (180F / (float) Math.PI);
legLeft.rotateAngleX = -1.5F * this.simplifyAngle(f, 13.0F) * f1;
legRight.rotateAngleX = 1.5F * this.simplifyAngle(f, 13.0F) * f1;
armLeft.rotateAngleX = 0.55F * this.simplifyAngle(f, 13.0F) * f1;
armRight.rotateAngleX = -0.55F * this.simplifyAngle(f, 13.0F) * f1;
if (clay.getUtilityInt() > 0) {
armRight.rotateAngleX = -0.556F;
armLeft.rotateAngleX = -0.446F;
head.rotateAngleX = 0.336F;
armRight.rotateAngleZ = -0.246F;
armLeft.rotateAngleZ = 0.246F;
legLeft.rotateAngleX = 0.656F;
legRight.rotateAngleX = -0.656F;
} else {
if (clay.getUtilityInt2() > 0) {
armRight.rotateAngleZ = -0.246F + this.simplifyAngle(clay.getUtilityInt2(), 10.0F) * 0.246F;
armLeft.rotateAngleZ = 0.246F + this.simplifyAngle(clay.getUtilityInt2(), 10.0F) * -0.246F;
}
}
}
public void setRotationAngles(
float f, float f1, float f2, float f3, float f4, float f5, Entity entity) {
HEADBASE.rotateAngleY = f3 / (270F / (float) Math.PI);
HEADBASE.rotateAngleX = f4 / (270F / (float) Math.PI);
LEFTLEG.rotateAngleX = MathHelper.cos(f * 0.6662F) * 1.4F * f1;
RIGHTLEG.rotateAngleX = MathHelper.cos(f * 0.6662F + (float) Math.PI) * 1.4F * 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);
}
protected void convertToChild(ModelRenderer parParent, ModelRenderer parChild) {
parChild.rotationPointX -= parParent.rotationPointX;
parChild.rotationPointY -= parParent.rotationPointY;
parChild.rotationPointZ -= parParent.rotationPointZ;
parChild.rotateAngleX -= parParent.rotateAngleX;
parChild.rotateAngleY -= parParent.rotateAngleY;
parChild.rotateAngleZ -= parParent.rotateAngleZ;
parParent.addChild(parChild);
}
public RenderPlayerTFC() {
super();
this.modelBipedMain = (ModelBiped) this.mainModel;
this.modelArmorChestplate = new ModelBiped(1.0F);
this.modelArmor = new ModelBiped(0.5F);
// Bronze
plume = new ModelRenderer(modelArmorChestplate, 40, 0);
plume2 = new ModelRenderer(modelArmorChestplate, 40, 0);
plume.addBox(-1, -6, -10, 2, 6, 10, 0.5f);
plume2.addBox(-1, -6, -10, 2, 6, 10);
plume.setRotationPoint(0, -8, 2);
plume2.setRotationPoint(0, -2, 4);
plume2.rotateAngleX = (float) (Math.PI / -3f);
// Iron
HornR1 = new ModelRenderer(modelArmorChestplate, 40, 0);
HornR1.addBox(-6, -1.5f, -1.5f, 3, 3, 6);
HornL1 = new ModelRenderer(modelArmorChestplate, 40, 0);
HornL1.addBox(6, -1.5f, -1.5f, 3, 3, 6);
HornR1.setRotationPoint(-6, -6, 5);
HornL1.setRotationPoint(6, -6, 8);
HornR1.rotateAngleY = (float) (Math.PI / -2);
HornR1.rotateAngleX = (float) Math.PI * (-1f / 12f);
HornL1.rotateAngleY = (float) (Math.PI / 2);
HornL1.rotateAngleX = (float) Math.PI * (-1f / 12f);
HornR2 = new ModelRenderer(modelArmorChestplate, 40, 9);
HornR2.addBox(0, 0, -5f, 2, 2, 5);
HornR2.setRotationPoint(-6, 0f, 2f);
HornR2.rotateAngleX = (float) Math.PI * (6f / 12f);
HornR2.rotateAngleZ = (float) Math.PI * (1f / 6f);
HornL2 = new ModelRenderer(modelArmorChestplate, 40, 9);
HornL2.addBox(0, 0, -5f, 2, 2, 5);
HornL2.setRotationPoint(7, 0f, 2f);
HornL2.rotateAngleX = (float) Math.PI * (6f / 12f);
HornL2.rotateAngleZ = (float) Math.PI * (-1f / 6f);
modelArmorChestplate.bipedHead.addChild(plume);
modelArmorChestplate.bipedHead.addChild(plume2);
modelArmorChestplate.bipedHead.addChild(HornR1);
modelArmorChestplate.bipedHead.addChild(HornL1);
HornR1.addChild(HornR2);
HornL1.addChild(HornL2);
}
@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);
helmFront.rotateAngleY = bipedHead.rotateAngleY;
helmFront.rotateAngleX = bipedHead.rotateAngleX;
}
public ModelWorker() {
bod = new ModelRenderer(this, 10, 0);
bod.addBox(-2F, -4F, -2F, 4, 8, 4, 0F);
bod.setRotationPoint(0F, 14F, 0F);
bod.rotateAngleX = 0.3839724F;
bod.rotateAngleY = 0F;
bod.rotateAngleZ = 0F;
bod.mirror = false;
leg1 = new ModelRenderer(this, 33, 21);
leg1.addBox(0F, 0F, -1F, 3, 8, 3, 0F);
leg1.setRotationPoint(2F, 16F, 0F);
leg1.rotateAngleX = 0F;
leg1.rotateAngleY = 0F;
leg1.rotateAngleZ = 0F;
leg1.mirror = false;
leg2 = new ModelRenderer(this, 33, 21);
leg2.addBox(-3F, 0F, -1F, 3, 8, 3, 0F);
leg2.setRotationPoint(-2F, 16F, 0F);
leg2.rotateAngleX = 0F;
leg2.rotateAngleY = 0F;
leg2.rotateAngleZ = 0F;
leg2.mirror = false;
head = new ModelRenderer(this, 7, 20);
head.addBox(-2.5F, -5F, -4F, 5, 5, 7, 0F);
head.setRotationPoint(0F, 12F, -2F);
head.rotateAngleX = 0F;
head.rotateAngleY = 0F;
head.rotateAngleZ = 0F;
head.mirror = false;
light = new ModelRenderer(this, 28, 0);
light.addBox(-1.5F, -6F, -1.5F, 3, 5, 3, 0F);
light.setRotationPoint(0F, 12F, -2F);
light.rotateAngleX = 0F;
light.rotateAngleY = 0F;
light.rotateAngleZ = 0F;
light.mirror = false;
}
public ModelTreeFrog() {
frontleft_leg = new ModelRenderer(this, 12, 19);
frontleft_leg.addBox(-2F, 0.0F, -2F, 4, 1, 4, 0.0F);
frontleft_leg.setRotationPoint(2.0F, 23F, -3F);
frontleft_leg.rotateAngleX = 0.0F;
frontleft_leg.rotateAngleY = 0.0F;
frontleft_leg.rotateAngleZ = 0.0F;
frontleft_leg.mirror = false;
frontright_leg = new ModelRenderer(this, 12, 14);
frontright_leg.addBox(-2F, 0.0F, -2F, 4, 1, 4, 0.0F);
frontright_leg.setRotationPoint(-2F, 23F, -3F);
frontright_leg.rotateAngleX = 0.0F;
frontright_leg.rotateAngleY = 0.0F;
frontright_leg.rotateAngleZ = 0.0F;
frontright_leg.mirror = false;
body = new ModelRenderer(this, 28, 8);
body.addBox(-2F, -5F, -2F, 4, 9, 4, 0.0F);
body.setRotationPoint(0.0F, 21F, 1.0F);
body.rotateAngleX = 1.570796F;
body.rotateAngleY = 0.0F;
body.rotateAngleZ = 0.0F;
body.mirror = false;
rear_right_leg = new ModelRenderer(this, 0, 16);
rear_right_leg.addBox(-3F, 0.0F, -2F, 3, 5, 3, 0.0F);
rear_right_leg.setRotationPoint(-2F, 19F, 4F);
rear_right_leg.rotateAngleX = 0.0F;
rear_right_leg.rotateAngleY = 0.0F;
rear_right_leg.rotateAngleZ = 0.0F;
rear_right_leg.mirror = false;
rear_left_leg = new ModelRenderer(this, 0, 8);
rear_left_leg.addBox(0.0F, 0.0F, -2F, 3, 5, 3, 0.0F);
rear_left_leg.setRotationPoint(2.0F, 19F, 4F);
rear_left_leg.rotateAngleX = 0.0F;
rear_left_leg.rotateAngleY = 0.0F;
rear_left_leg.rotateAngleZ = 0.0F;
rear_left_leg.mirror = false;
right_eye = new ModelRenderer(this, 0, 0);
right_eye.addBox(-2F, -1F, -1F, 2, 2, 2, 0.0F);
right_eye.setRotationPoint(-1F, 19F, -1F);
right_eye.rotateAngleX = 0.0F;
right_eye.rotateAngleY = 0.0F;
right_eye.rotateAngleZ = 0.0F;
right_eye.mirror = false;
left_eye = new ModelRenderer(this, 0, 4);
left_eye.addBox(0.0F, -1F, -1F, 2, 2, 2, 0.0F);
left_eye.setRotationPoint(1.0F, 19F, -1F);
left_eye.rotateAngleX = 0.0F;
left_eye.rotateAngleY = 0.0F;
left_eye.rotateAngleZ = 0.0F;
left_eye.mirror = false;
}
public CREEPSModelCamel(float f, float f1) {
float f2 = 0.0F;
body = new ModelRenderer(this, 36, 0);
body.addBox(-1F, -3F, -4.5F, 2, 6, 9, 3.9F);
body.setRotationPoint(0.0F, 4F, 0.0F);
leg1 = new ModelRenderer(this, 38, 15);
leg1.addBox(-1.5F, 0.0F, -1.5F, 3, 14, 3, -0.25F);
leg1.setRotationPoint(3F, 10F, -6F);
leg2 = new ModelRenderer(this, 38, 15);
leg2.addBox(-1.5F, 0.0F, -1.5F, 3, 14, 3, -0.25F);
leg2.setRotationPoint(-3F, 10F, -6F);
leg3 = new ModelRenderer(this, 38, 15);
leg3.addBox(-1.5F, 0.0F, -2F, 3, 14, 3, -0.25F);
leg3.setRotationPoint(3F, 10F, 7F);
leg4 = new ModelRenderer(this, 38, 15);
leg4.addBox(-1.5F, 0.0F, -2F, 3, 14, 3, -0.25F);
leg4.setRotationPoint(-3F, 10F, 7F);
hump1 = new ModelRenderer(this, 28, 0);
hump1.addBox(-4F, -5F, -4F, 8, 5, 8, 0.45F);
hump1.setRotationPoint(0.0F, -2F, 0.0F);
neck1 = new ModelRenderer(this, 36, 0);
neck1.addBox(-2.5F, -2F, 0.0F, 5, 5, 9, f2);
neck1.setRotationPoint(0.0F, 2.0F, -7F);
neck1.rotateAngleX = -2.53136F;
tail = new ModelRenderer(this, 0, 22);
tail.addBox(-1F, -1F, -7.5F, 2, 2, 8, f2);
tail.setRotationPoint(0.0F, 4F, 8F);
tail.rotateAngleX = 2.16973F;
tail.rotateAngleY = -0.0452F;
neck2 = new ModelRenderer(this, 32, 0);
neck2.addBox(-2.5F, -2F, 0.0F, 5, 5, 11, -0.5F);
neck2.setRotationPoint(0.0F, 7F, -12F);
neck2.rotateAngleX = 2.53136F;
headCamel = new ModelRenderer(this, 0, 0);
headCamel.addBox(-2.5F, -2F, -8F, 5, 5, 8, f2);
headCamel.setRotationPoint(0.0F, 0.0F, -19F);
earR = new ModelRenderer(this, 0, 0);
earR.addBox(-2.5F, -4F, -1.5F, 1, 2, 1, f2);
earR.setRotationPoint(0.0F, 0.0F, -19F);
earL = new ModelRenderer(this, 0, 3);
earL.addBox(1.5F, -4F, -1.5F, 1, 2, 1, f2);
earL.setRotationPoint(0.0F, 0.0F, -19F);
mouth = new ModelRenderer(this, 20, 25);
mouth.addBox(-2F, 0.5F, -9F, 4, 1, 4, f2);
mouth.setRotationPoint(0.0F, 0.0F, -19F);
mouth.rotateAngleX = 0.29382F;
}
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 createChildren(ModelBase base) {
for (CubeInfo child : getChildren()) {
child.modelCube = new ModelRenderer(base, child.txOffset[0], child.txOffset[1]);
child.modelCube.mirror = child.txMirror;
child.modelCube.addBox(
(float) child.offset[0],
(float) child.offset[1],
(float) child.offset[2],
child.dimensions[0],
child.dimensions[1],
child.dimensions[2]);
child.modelCube.setRotationPoint(
(float) child.position[0], (float) child.position[1], (float) child.position[2]);
child.modelCube.rotateAngleX = (float) Math.toRadians(child.rotation[0]);
child.modelCube.rotateAngleY = (float) Math.toRadians(child.rotation[1]);
child.modelCube.rotateAngleZ = (float) Math.toRadians(child.rotation[2]);
this.modelCube.addChild(child.modelCube);
child.createChildren(base);
}
}
@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 setPieceRotation(ModelRenderer model, float x, float y, float z) {
model.rotateAngleX = x;
model.rotateAngleY = y;
model.rotateAngleZ = z;
}
@Override
public void renderItem(ItemRenderType type, ItemStack item, Object... data) {
float time = 0.02F;
central_gem.rotateAngleY += time;
gem.rotateAngleZ += time;
gem2.rotateAngleZ -= time;
glPushMatrix();
// glTranslated(0.5D, 1.5D, 0.5D);
glRotatef(180F, 1F, 0F, 0F);
glEnable(GL11.GL_BLEND);
glBlendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA);
Minecraft.getMinecraft().renderEngine.bindTexture(this.TEXTURE_STAFF[item.getItemDamage()]);
if (type == ItemRenderType.INVENTORY) {
// GL11.glDisable(GL11.GL_LIGHTING);
render(0.0625F);
// GL11.glEnable(GL11.GL_LIGHTING);
} else {
GL11.glEnable(GL12.GL_RESCALE_NORMAL);
float scale;
switch (type) {
case EQUIPPED_FIRST_PERSON:
glTranslatef(0F, -1.2F, -0.5F);
glRotatef(200F, 0F, 1F, 0F);
// scale = 0.8F;
// glScalef(scale, scale, scale);
break;
case EQUIPPED:
scale = 2.1F;
glScalef(scale, scale, scale);
glTranslatef(0.35F, -0.2F, -0.35F);
//
glRotatef(100, 0F, 1F, 0F);
break;
case ENTITY:
glTranslatef(0, -6 / 16f, 0);
break;
default:
break;
}
render(0.0625F);
}
GL11.glDisable(GL11.GL_BLEND);
glPopMatrix();
if (type == ItemRenderType.EQUIPPED_FIRST_PERSON) {
if (item.getItemDamage() == 0) {
Block block = Staff.getBlockHolding(item);
if (block != null) {
glPushMatrix();
// glRotatef(10F, 0F, 0F, 1F);
float f = 1.5F;
glScalef(f, f, f);
glRotatef(-45, 0, 1, 0);
EntityItem entityitem = new EntityItem(FMLClientHandler.instance().getWorldClient());
entityitem.setEntityItemStack(new ItemStack(block));
entityitem.hoverStart = 0F;
itemRenderer.render(
entityitem,
-0.453F,
1.0F + (float) Math.sin(System.currentTimeMillis() / 200D) / 200F,
0.5F,
false);
glPopMatrix();
}
}
}
}
private void initSlingerSpider() {
slingerSpiderHead = new ModelRenderer(this, 32, 4);
slingerSpiderHead.addBox(-4F, -6F, -8F, 8, 8, 8, 0.0F);
slingerSpiderHead.setRotationPoint(0F, 14F, -3F);
slingerSpiderBody = new ModelRenderer(this, 0, 0);
slingerSpiderBody.addBox(-3F, -3F, -3F, 6, 4, 6, 0.0F);
slingerSpiderBody.setRotationPoint(0F, 16F, 0F);
slingerSpiderRearEnd = new ModelRenderer(this, 0, 12);
slingerSpiderRearEnd.addBox(-5F, -4F, -6F, 8, 6, 10, 0.0F);
slingerSpiderRearEnd.setRotationPoint(1F, 13F, 8F);
slingerSpiderRearEnd.rotateAngleX = 0.32023F;
slingerSpiderLeg1 = new ModelRenderer(this, 18, 0);
slingerSpiderLeg1.addBox(-15F, -1F, -1F, 16, 1, 1, 0.0F);
slingerSpiderLeg1.setRotationPoint(-4F, 15F, 2F);
slingerSpiderLeg1.rotateAngleX = 0.57596F;
slingerSpiderLeg1.rotateAngleY = 0.19199F;
slingerSpiderLeg2 = new ModelRenderer(this, 18, 0);
slingerSpiderLeg2.addBox(-1F, -1F, -1F, 16, 1, 1, 0.0F);
slingerSpiderLeg2.setRotationPoint(4F, 15F, 2F);
slingerSpiderLeg2.rotateAngleX = -0.57596F;
slingerSpiderLeg2.rotateAngleY = -0.19199F;
slingerSpiderLeg3 = new ModelRenderer(this, 18, 0);
slingerSpiderLeg3.addBox(-15F, -1F, -1F, 16, 1, 1, 0.0F);
slingerSpiderLeg3.setRotationPoint(-4F, 15F, 1F);
slingerSpiderLeg3.rotateAngleX = 0.27925F;
slingerSpiderLeg3.rotateAngleY = 0.19199F;
slingerSpiderLeg4 = new ModelRenderer(this, 18, 0);
slingerSpiderLeg4.addBox(-1F, -1F, -1F, 16, 1, 1, 0.0F);
slingerSpiderLeg4.setRotationPoint(4F, 15F, 1F);
slingerSpiderLeg4.rotateAngleX = -0.27925F;
slingerSpiderLeg4.rotateAngleY = -0.19199F;
slingerSpiderLeg5 = new ModelRenderer(this, 18, 0);
slingerSpiderLeg5.addBox(-15F, -1F, -1F, 16, 1, 1, 0.0F);
slingerSpiderLeg5.setRotationPoint(-4F, 15F, 0F);
slingerSpiderLeg5.rotateAngleX = -0.27925F;
slingerSpiderLeg5.rotateAngleY = 0.19199F;
slingerSpiderLeg6 = new ModelRenderer(this, 18, 0);
slingerSpiderLeg6.addBox(-1F, -1F, -1F, 16, 1, 1, 0.0F);
slingerSpiderLeg6.setRotationPoint(4F, 15F, 0F);
slingerSpiderLeg6.rotateAngleX = 0.27925F;
slingerSpiderLeg6.rotateAngleY = -0.19199F;
slingerSpiderLeg7 = new ModelRenderer(this, 18, 0);
slingerSpiderLeg7.addBox(-15F, -1F, -1F, 16, 1, 1, 0.0F);
slingerSpiderLeg7.setRotationPoint(-4F, 15F, -1F);
slingerSpiderLeg7.rotateAngleX = -0.57596F;
slingerSpiderLeg7.rotateAngleY = 0.19199F;
slingerSpiderLeg8 = new ModelRenderer(this, 18, 0);
slingerSpiderLeg8.addBox(-1F, -1F, -1F, 16, 1, 1, 0.0F);
slingerSpiderLeg8.setRotationPoint(4F, 15F, -1F);
slingerSpiderLeg8.rotateAngleX = 0.57596F;
slingerSpiderLeg8.rotateAngleY = -0.19199F;
}
protected final void setRotation(ModelRenderer model, float x, float y, float z) {
model.rotateAngleX = x;
model.rotateAngleY = y;
model.rotateAngleZ = z;
}
private void initBoomSpider() {
boomSpiderCharge = new ModelRenderer(this, 32, 0);
boomSpiderCharge.addBox(-4.0F, -8.0F, -4.0F, 8, 8, 8, 0.0F);
boomSpiderCharge.setRotationPoint(0.0F, 4.0F, 0.0F);
boomSpiderHead = new ModelRenderer(this, 32, 4);
boomSpiderHead.addBox(-4F, -4F, -8F, 8, 8, 8, 0.0F);
boomSpiderHead.setRotationPoint(0F, 15F, -3F);
boomSpiderBody = new ModelRenderer(this, 0, 0);
boomSpiderBody.addBox(-3F, -3F, -3F, 6, 6, 6, 0.0F);
boomSpiderBody.setRotationPoint(0F, 15F, 0F);
boomSpiderRearEnd = new ModelRenderer(this, 0, 12);
boomSpiderRearEnd.addBox(-5F, -4F, -6F, 10, 8, 12, 0.0F);
boomSpiderRearEnd.setRotationPoint(0F, 11F, 7F);
boomSpiderRearEnd.rotateAngleX = 0.63284F;
boomSpiderLeg1 = new ModelRenderer(this, 18, 0);
boomSpiderLeg1.addBox(-15F, -1F, -1F, 16, 2, 2, 0.0F);
boomSpiderLeg1.setRotationPoint(-4F, 15F, 2F);
boomSpiderLeg1.rotateAngleX = 0.57596F;
boomSpiderLeg1.rotateAngleY = 0.19199F;
boomSpiderLeg2 = new ModelRenderer(this, 18, 0);
boomSpiderLeg2.addBox(-1F, -1F, -1F, 16, 2, 2, 0.0F);
boomSpiderLeg2.setRotationPoint(4F, 15F, 2F);
boomSpiderLeg2.rotateAngleX = -0.57596F;
boomSpiderLeg2.rotateAngleY = -0.19199F;
boomSpiderLeg3 = new ModelRenderer(this, 18, 0);
boomSpiderLeg3.addBox(-15F, -1F, -1F, 16, 2, 2, 0.0F);
boomSpiderLeg3.setRotationPoint(-4F, 15F, 1F);
boomSpiderLeg3.rotateAngleX = 0.27925F;
boomSpiderLeg3.rotateAngleY = 0.19199F;
boomSpiderLeg4 = new ModelRenderer(this, 18, 0);
boomSpiderLeg4.addBox(-1F, -1F, -1F, 16, 2, 2, 0.0F);
boomSpiderLeg4.setRotationPoint(4F, 15F, 1F);
boomSpiderLeg4.rotateAngleX = -0.27925F;
boomSpiderLeg4.rotateAngleY = -0.19199F;
boomSpiderLeg5 = new ModelRenderer(this, 18, 0);
boomSpiderLeg5.addBox(-15F, -1F, -1F, 16, 2, 2, 0.0F);
boomSpiderLeg5.setRotationPoint(-4F, 15F, 0F);
boomSpiderLeg5.rotateAngleX = -0.27925F;
boomSpiderLeg5.rotateAngleY = 0.19199F;
boomSpiderLeg6 = new ModelRenderer(this, 18, 0);
boomSpiderLeg6.addBox(-1F, -1F, -1F, 16, 2, 2, 0.0F);
boomSpiderLeg6.setRotationPoint(4F, 15F, 0F);
boomSpiderLeg6.rotateAngleX = 0.27925F;
boomSpiderLeg6.rotateAngleY = -0.19199F;
boomSpiderLeg7 = new ModelRenderer(this, 18, 0);
boomSpiderLeg7.addBox(-15F, -1F, -1F, 16, 2, 2, 0.0F);
boomSpiderLeg7.setRotationPoint(-4F, 15F, -1F);
boomSpiderLeg7.rotateAngleX = -0.57596F;
boomSpiderLeg7.rotateAngleY = 0.19199F;
boomSpiderLeg8 = new ModelRenderer(this, 18, 0);
boomSpiderLeg8.addBox(-1F, -1F, -1F, 16, 2, 2, 0.0F);
boomSpiderLeg8.setRotationPoint(4F, 15F, -1F);
boomSpiderLeg8.rotateAngleX = 0.57596F;
boomSpiderLeg8.rotateAngleY = -0.19199F;
}
private void resetRotationsOnPart(ModelRenderer mr) {
mr.rotateAngleX = 0;
mr.rotateAngleY = 0;
mr.rotateAngleZ = 0;
}
@Override
public void render(Entity entity, float f, float f1, float f2, float f3, float f4, float f5) {
EntityGrimReaper reaper = (EntityGrimReaper) entity;
if (reaper.getAttackState() == EnumReaperAttackState.PRE) {
this.leftLegPreAttack.render(f5);
this.leftArmPreAttack.render(f5);
this.rightLegPreAttack.render(f5);
this.chestPreAttack.render(f5);
this.cowlPreAttack.render(f5);
this.headPreAttack.render(f5);
this.rightArmPreAttack.render(f5);
this.scytheHandlePreAttack.render(f5);
this.scytheHeadPreAttack.render(f5);
} else if (reaper.getAttackState() == EnumReaperAttackState.POST) {
this.leftLegPostAttack.render(f5);
this.leftArmPostAttack.render(f5);
this.rightLegPostAttack.render(f5);
this.chestPostAttack.render(f5);
this.cowlPostAttack.render(f5);
this.headPostAttack.render(f5);
this.rightArmPostAttack.render(f5);
this.scytheHandlePostAttack.render(f5);
this.scytheHeadPostAttack.render(f5);
} else if (reaper.getAttackState() == EnumReaperAttackState.BLOCK) {
this.cowlBlock.render(f5);
this.leftLegBlock.render(f5);
this.headBlock.render(f5);
this.rightArmBlock.render(f5);
this.scytheHandleBlock.render(f5);
this.rightLegBlock.render(f5);
this.chestBlock.render(f5);
this.leftArmBlock.render(f5);
this.scytheHeadBlock.render(f5);
} else if (reaper.getAttackState() == EnumReaperAttackState.REST) {
GL11.glPushMatrix();
{
double amt = Math.cos(reaper.getFloatingTicks()) / 4;
GL11.glTranslated(0.0D, amt, 0.0D);
this.rightArmRest.render(f5);
this.rightLegRest.render(f5);
this.leftArmRest.render(f5);
this.chestRest.render(f5);
this.leftLegRest.render(f5);
this.cowlRest.render(f5);
GL11.glPushMatrix();
{
double amt2 = Math.cos(reaper.getFloatingTicks()) / 8;
GL11.glTranslated(0.0D, amt2, 0.0D);
this.scytheHeadRest.render(f5);
this.scytheHandleRest.render(f5);
}
GL11.glPopMatrix();
}
GL11.glPopMatrix();
} else {
rightLeg.rotateAngleX =
MathHelper.clamp_float(
MathHelper.cos(100F * 0.6662F + 3.141593F) * 2.5F * f1, 0.0F, 1.1F);
leftLeg.rotateAngleX =
MathHelper.clamp_float(
MathHelper.cos(100F * 0.6662F + 3.141593F) * 2.5F * f1, 0.0F, 1.1F);
rightLeg.rotateAngleX =
MathHelper.clamp_float(
MathHelper.cos(100F * 0.6662F + 3.141593F) * 2.5F * f1, 0.0F, 1.1F);
leftLeg.rotateAngleX =
MathHelper.clamp_float(
MathHelper.cos(100F * 0.6662F + 3.141593F) * 2.5F * f1, 0.0F, 1.1F);
rightLeg.rotateAngleY = 0.0F;
leftLeg.rotateAngleY = 0.0F;
this.leftLeg.render(f5);
this.leftArm.render(f5);
this.rightLeg.render(f5);
this.chest.render(f5);
this.cowl.render(f5);
this.head.render(f5);
this.rightArm.render(f5);
}
}
public void setRotateAngle(ModelRenderer modelRenderer, float x, float y, float z) {
modelRenderer.rotateAngleX = x;
modelRenderer.rotateAngleY = y;
modelRenderer.rotateAngleZ = z;
}
private void setRotation(ModelRenderer var1, float var2, float var3, float var4) {
var1.rotateAngleX = var2;
var1.rotateAngleY = var3;
var1.rotateAngleZ = var4;
}
private void initNovaSpider() {
novaSpiderHead = new ModelRenderer(this, 0, 8);
novaSpiderHead.addBox(-3F, -2F, -4F, 4, 3, 4, 0.0F);
novaSpiderHead.setRotationPoint(0F, 19F, -3F);
novaSpiderBody = new ModelRenderer(this, 0, 0);
novaSpiderBody.addBox(-3F, -3F, -3F, 4, 4, 4, 0.0F);
novaSpiderBody.setRotationPoint(0F, 19F, 0F);
novaSpiderRearEnd = new ModelRenderer(this, 0, 15);
novaSpiderRearEnd.addBox(-3F, -4F, 0F, 6, 6, 6, 0.0F);
novaSpiderRearEnd.setRotationPoint(-1F, 18F, 1F);
novaSpiderLeg1 = new ModelRenderer(this, 18, 0);
novaSpiderLeg1.addBox(-9F, -1F, -1F, 10, 1, 1, 0.0F);
novaSpiderLeg1.setRotationPoint(-3F, 19F, 1F);
novaSpiderLeg1.rotateAngleX = 0.57596F;
novaSpiderLeg1.rotateAngleY = 0.19199F;
novaSpiderLeg2 = new ModelRenderer(this, 18, 0);
novaSpiderLeg2.addBox(-1F, -1F, -1F, 10, 1, 1, 0.0F);
novaSpiderLeg2.setRotationPoint(1F, 19F, 1F);
novaSpiderLeg2.rotateAngleX = -0.57596F;
novaSpiderLeg2.rotateAngleY = -0.19199F;
novaSpiderLeg3 = new ModelRenderer(this, 18, 0);
novaSpiderLeg3.addBox(-9F, -1F, -1F, 10, 1, 1, 0.0F);
novaSpiderLeg3.setRotationPoint(-3F, 19F, 0F);
novaSpiderLeg3.rotateAngleX = 0.27925F;
novaSpiderLeg3.rotateAngleY = 0.19199F;
novaSpiderLeg4 = new ModelRenderer(this, 18, 0);
novaSpiderLeg4.addBox(-1F, -1F, -1F, 10, 1, 1, 0.0F);
novaSpiderLeg4.setRotationPoint(1F, 19F, 0F);
novaSpiderLeg4.rotateAngleX = -0.27925F;
novaSpiderLeg4.rotateAngleY = -0.19199F;
novaSpiderLeg5 = new ModelRenderer(this, 18, 0);
novaSpiderLeg5.addBox(-9F, -1F, -1F, 10, 1, 1, 0.0F);
novaSpiderLeg5.setRotationPoint(-3F, 19F, -1F);
novaSpiderLeg5.rotateAngleX = -0.27925F;
novaSpiderLeg5.rotateAngleY = 0.19199F;
novaSpiderLeg6 = new ModelRenderer(this, 18, 0);
novaSpiderLeg6.addBox(-1F, -1F, -1F, 10, 1, 1, 0.0F);
novaSpiderLeg6.setRotationPoint(1F, 19F, -1F);
novaSpiderLeg6.rotateAngleX = 0.27925F;
novaSpiderLeg6.rotateAngleY = -0.19199F;
novaSpiderLeg7 = new ModelRenderer(this, 18, 0);
novaSpiderLeg7.addBox(-10F, -1F, -1F, 10, 1, 1, 0.0F);
novaSpiderLeg7.setRotationPoint(-2F, 19F, -2F);
novaSpiderLeg7.rotateAngleX = -0.57596F;
novaSpiderLeg7.rotateAngleY = 0.19199F;
novaSpiderLeg8 = new ModelRenderer(this, 18, 0);
novaSpiderLeg8.addBox(-1F, -1F, -1F, 10, 1, 1, 0.0F);
novaSpiderLeg8.setRotationPoint(1F, 19F, -2F);
novaSpiderLeg8.rotateAngleX = 0.57596F;
novaSpiderLeg8.rotateAngleY = -0.19199F;
}
/** Set the rotation angles of the specified ModelRenderer instance. */
public void setRotation(
ModelRenderer model, float rotateAngleX, float rotateAngleY, float rotateAngleZ) {
model.rotateAngleX = rotateAngleX;
model.rotateAngleY = rotateAngleY;
model.rotateAngleZ = rotateAngleZ;
}
private void setRotation(ModelRenderer model, float x, float y, float z) {
model.rotateAngleX = x;
model.rotateAngleY = y;
model.rotateAngleZ = z;
}
public void setRotationAngles(
float f, float f1, float f2, float f3, float f4, float f5, Entity entity) {
float PI = (float) Math.PI;
float TopAngle = 1 * PI / 4;
float initialOffset = PI / 2;
float offset = PI * 2 / 11;
float animationSpeed = -0.2f;
float dampingFactor = 0.95f;
HeadBase.rotateAngleX = f4 / 57.29578F;
HeadBase.rotateAngleY = f3 / 57.29578F;
float currentAngle = 0;
Segment1.rotateAngleX =
((float) Math.pow(dampingFactor, 1))
* TopAngle
* (MathHelper.cos(animationSpeed * f + initialOffset))
- PI / 4;
currentAngle = Segment1.rotateAngleX;
Segment2.rotateAngleX =
((float) Math.pow(dampingFactor, 2))
* TopAngle
* (MathHelper.cos(animationSpeed * f + 1f * offset + initialOffset))
- currentAngle
- PI / 5;
currentAngle = Segment1.rotateAngleX + Segment2.rotateAngleX;
Segment3.rotateAngleX =
((float) Math.pow(dampingFactor, 3))
* TopAngle
* (MathHelper.cos(animationSpeed * f + 1.1f * 2 * offset + PI / 9 + initialOffset))
- currentAngle
- PI / 6;
currentAngle = Segment1.rotateAngleX + Segment2.rotateAngleX + Segment3.rotateAngleX;
Segment4.rotateAngleX =
((float) Math.pow(dampingFactor, 5))
* TopAngle
* (MathHelper.cos(
animationSpeed * f + 1.2f * 3 * offset + 2 * PI / 9 + initialOffset))
- currentAngle; // -PI/6;
currentAngle =
Segment1.rotateAngleX
+ Segment2.rotateAngleX
+ Segment3.rotateAngleX
+ Segment4.rotateAngleX;
Segment5.rotateAngleX =
((float) Math.pow(dampingFactor, 6))
* TopAngle
* (MathHelper.cos(animationSpeed * f + 1.3f * 4 * offset + PI / 9 + initialOffset))
- currentAngle; // -PI/7;
currentAngle = currentAngle + Segment5.rotateAngleX;
Segment6.rotateAngleX =
((float) Math.pow(dampingFactor, 7))
* TopAngle
* (MathHelper.cos(animationSpeed * f + 1.4f * 5 * offset + initialOffset))
- currentAngle; // -PI/8;
currentAngle = currentAngle + Segment6.rotateAngleX;
Segment7.rotateAngleX =
((float) Math.pow(dampingFactor, 6))
* TopAngle
* (MathHelper.cos(animationSpeed * f + 1.5f * 6 * offset + initialOffset))
- currentAngle;
currentAngle = currentAngle + Segment7.rotateAngleX;
Segment8.rotateAngleX =
((float) Math.pow(dampingFactor, 6))
* TopAngle
* (MathHelper.cos(animationSpeed * f + 1.6f * 7 * offset + initialOffset))
- currentAngle;
currentAngle = currentAngle + Segment8.rotateAngleX;
Segment9.rotateAngleX =
((float) Math.pow(dampingFactor, 7))
* TopAngle
* (MathHelper.cos(animationSpeed * f + 1.7f * 8 * offset + initialOffset))
- currentAngle;
currentAngle = currentAngle + Segment9.rotateAngleX;
Segment10.rotateAngleX =
((float) Math.pow(dampingFactor, 8))
* TopAngle
* (MathHelper.cos(animationSpeed * f + 1.8f * 9 * offset + initialOffset))
- currentAngle;
currentAngle = currentAngle + Segment10.rotateAngleX;
Segment11.rotateAngleX =
((float) Math.pow(dampingFactor, 9))
* TopAngle
* (MathHelper.cos(animationSpeed * f + 1.9f * 10 * offset + initialOffset))
- currentAngle;
Segment12.rotateAngleX =
((float) Math.pow(dampingFactor, 10))
* TopAngle
* (MathHelper.cos(animationSpeed * f + 2f * 11 * offset + initialOffset))
- currentAngle;
}
