public void setRotationAngles(float f, float f1, float f2, float f3, float f4, float f5) {
TailM2.rotateAngleX = MathHelper.cos(f2 * .1F + 1F) * .5F;
TailM3.rotateAngleX = -MathHelper.cos(f2 * .1F + 1F) * .25F;
TailL.rotateAngleX = MathHelper.cos(f2 * .2F + 1F) * .25F;
TailL2.rotateAngleX = -MathHelper.cos(f2 * .1F + 1F) * .5F;
TailL3.rotateAngleX = MathHelper.cos(f2 * .1F + 1F) * .75F;
TailR.rotateAngleX = -MathHelper.cos(f2 * .2F + 1F) * .25F;
TailR2.rotateAngleX = -MathHelper.cos(f2 * .1F + 1F) * .5F;
TailR3.rotateAngleX = -MathHelper.cos(f2 * .1F + 1F) * .25F;
}
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 (((EntityPixelmon) entity).animationCounter2 * 3 - 180 < 0) {
LeftWing.rotateAngleZ =
2F + (((EntityPixelmon) entity).animationCounter2 + 90) * 0.034906585F;
} else if (((EntityPixelmon) entity).animationCounter2 * 3 >= 0) {
LeftWing.rotateAngleZ =
0F + -((((EntityPixelmon) entity).animationCounter2 - 90) * 0.034906585F);
}
if (((EntityPixelmon) entity).animationCounter2 * 3 - 180 < 0) {
RightWing.rotateAngleZ =
-2F + -(((EntityPixelmon) entity).animationCounter2 + 90) * 0.034906585F;
} else if (((EntityPixelmon) entity).animationCounter2 * 3 >= 0) {
RightWing.rotateAngleZ =
0F + ((((EntityPixelmon) entity).animationCounter2 - 90) * 0.034906585F);
}
if (((EntityPixelmon) entity).animationCounter2 * 3 - 180 < 0) {
Body.rotationPointY = 20 - (((EntityPixelmon) entity).animationCounter2 + 180) * 0.174532925F;
} else if (((EntityPixelmon) entity).animationCounter2 * 3 >= 0) {
Body.rotationPointY = 0 + (((EntityPixelmon) entity).animationCounter2 - 180) * 0.174532925F;
}
if (((EntityPixelmon) entity).animationCounter2 >= 120) {
((EntityPixelmon) entity).animationCounter2 = 0;
}
}
private void setRotation(PixelmonModelRenderer model, float x, float y, float z) {
model.rotateAngleX = x;
model.rotateAngleY = y;
model.rotateAngleZ = z;
}
public void render(Entity entity, float f, float f1, float f2, float f3, float f4, float f5) {
super.render(entity, f, f1, f2, f3, f4, f5);
setRotationAngles(f, f1, f2, f3, f4, f5);
Body.render(f5);
}
public ModelTauros() {
textureWidth = 128;
textureHeight = 64;
Body = new PixelmonModelRenderer(this, "Body");
Body.setRotationPoint(0, 8, -4);
PixelmonModelRenderer BodyMainUpper = new PixelmonModelRenderer(this, 0, 0);
BodyMainUpper.addBox(-5.5F, -8.9F, -4.4F, 11, 11, 6);
BodyMainUpper.setTextureSize(128, 64);
BodyMainUpper.mirror = true;
setRotation(BodyMainUpper, 0F, 0F, 0F);
PixelmonModelRenderer StomachLAngleFront = new PixelmonModelRenderer(this, 0, 0);
StomachLAngleFront.addBox(2.5F, -0.2F, -3.2F, 3, 3, 7);
StomachLAngleFront.setTextureSize(128, 64);
StomachLAngleFront.mirror = true;
setRotation(StomachLAngleFront, 0F, 0F, -0.7853982F);
PixelmonModelRenderer StomachRAngleFront = new PixelmonModelRenderer(this, 0, 0);
StomachRAngleFront.addBox(-5.5F, -0.2F, -3.2F, 3, 3, 7);
StomachRAngleFront.setTextureSize(128, 64);
StomachRAngleFront.mirror = true;
setRotation(StomachRAngleFront, 0F, 0F, 0.7853982F);
PixelmonModelRenderer StomachLAngleBack = new PixelmonModelRenderer(this, 0, 0);
StomachLAngleBack.addBox(0.8F, 0F, 2.8F, 4, 3, 7);
StomachLAngleBack.setTextureSize(128, 64);
StomachLAngleBack.mirror = true;
setRotation(StomachLAngleBack, 0.2443461F, 0.1745329F, -0.7853982F);
PixelmonModelRenderer StomachRAngleBack = new PixelmonModelRenderer(this, 0, 0);
StomachRAngleBack.addBox(-4.8F, 0F, 2.8F, 4, 3, 7);
StomachRAngleBack.setTextureSize(128, 64);
StomachRAngleBack.mirror = true;
setRotation(StomachRAngleBack, 0.2443461F, -0.1745329F, 0.7853982F);
PixelmonModelRenderer StomachLFront = new PixelmonModelRenderer(this, 0, 0);
StomachLFront.addBox(-0.1F, -1.9F, -3.2F, 6, 7, 7);
StomachLFront.setTextureSize(128, 64);
StomachLFront.mirror = true;
setRotation(StomachLFront, 0F, 0F, 0F);
PixelmonModelRenderer StomachRFront = new PixelmonModelRenderer(this, 0, 0);
StomachRFront.addBox(-5.9F, -1.9F, -3.2F, 6, 7, 7);
StomachRFront.setTextureSize(128, 64);
StomachRFront.mirror = true;
setRotation(StomachRFront, 0F, 0F, 0F);
PixelmonModelRenderer StomachMainBack = new PixelmonModelRenderer(this, 0, 0);
StomachMainBack.addBox(-5.5F, -1.3F, 2.8F, 11, 7, 7);
StomachMainBack.setTextureSize(128, 64);
StomachMainBack.mirror = true;
setRotation(StomachMainBack, 0.1745329F, 0F, 0F);
PixelmonModelRenderer Mane3 = new PixelmonModelRenderer(this, 104, 0);
Mane3.addBox(-6F, -10.4F, -8F, 12, 11, 2);
Mane3.setTextureSize(128, 64);
Mane3.mirror = true;
setRotation(Mane3, 0.3490659F, 0F, 0F);
PixelmonModelRenderer BodyMainUpperAngle = new PixelmonModelRenderer(this, 0, 0);
BodyMainUpperAngle.addBox(-5F, -8.5F, -3.1F, 10, 11, 6);
BodyMainUpperAngle.setTextureSize(128, 64);
BodyMainUpperAngle.mirror = true;
setRotation(BodyMainUpperAngle, -0.5235988F, 0F, 0F);
PixelmonModelRenderer Mane1 = new PixelmonModelRenderer(this, 106, 0);
Mane1.addBox(-5F, -12.8F, -7.8F, 10, 13, 3);
Mane1.setTextureSize(128, 64);
Mane1.mirror = true;
setRotation(Mane1, 0.7853982F, 0F, 0F);
PixelmonModelRenderer BodyLowerBack = new PixelmonModelRenderer(this, 0, 0);
BodyLowerBack.addBox(-4.5F, -7.5F, 3.7F, 9, 8, 12);
BodyLowerBack.setTextureSize(128, 64);
BodyLowerBack.mirror = true;
setRotation(BodyLowerBack, -0.2617994F, 0F, 0F);
PixelmonModelRenderer Mane5 = new PixelmonModelRenderer(this, 98, 0);
Mane5.addBox(-7F, -9.5F, -5.8F, 14, 10, 3);
Mane5.setTextureSize(128, 64);
Mane5.mirror = true;
setRotation(Mane5, 0.1745329F, 0F, 0F);
PixelmonModelRenderer Ass = new PixelmonModelRenderer(this, 0, 0);
Ass.addBox(-4F, -2.8F, 8F, 8, 7, 9);
Ass.setTextureSize(128, 64);
Ass.mirror = true;
setRotation(Ass, 0F, 0F, 0F);
PixelmonModelRenderer Mane2 = new PixelmonModelRenderer(this, 105, 1);
Mane2.addBox(-5.5F, -12.8F, -4.8F, 11, 13, 2);
Mane2.setTextureSize(128, 64);
Mane2.mirror = true;
setRotation(Mane2, 0.7853982F, 0F, 0F);
PixelmonModelRenderer BeardLowerFlat = new PixelmonModelRenderer(this, 88, 10);
BeardLowerFlat.addBox(-2.5F, 6.2F, -9.3F, 5, 3, 0);
BeardLowerFlat.setTextureSize(128, 64);
BeardLowerFlat.mirror = true;
setRotation(BeardLowerFlat, 0.3490659F, 0F, 0F);
PixelmonModelRenderer Mane4 = new PixelmonModelRenderer(this, 102, 0);
Mane4.addBox(-6.5F, -10.4F, -6F, 13, 11, 2);
Mane4.setTextureSize(128, 64);
Mane4.mirror = true;
setRotation(Mane4, 0.3490659F, 0F, 0F);
PixelmonModelRenderer Mane5FlatR = new PixelmonModelRenderer(this, 90, -2);
Mane5FlatR.addBox(-5.8F, -9.5F, 6.6F, 0, 10, 2);
Mane5FlatR.setTextureSize(128, 64);
Mane5FlatR.mirror = true;
setRotation(Mane5FlatR, 0F, -1.570796F, -0.1745329F);
PixelmonModelRenderer BeardUpper = new PixelmonModelRenderer(this, 102, 0);
BeardUpper.addBox(-3F, 3.2F, -11F, 6, 5, 7);
BeardUpper.setTextureSize(128, 64);
BeardUpper.mirror = true;
setRotation(BeardUpper, -0.5235988F, 0F, 0F);
PixelmonModelRenderer Mane4FlatR = new PixelmonModelRenderer(this, 90, -2);
Mane4FlatR.addBox(-6F, -10F, 6.1F, 0, 10, 2);
Mane4FlatR.setTextureSize(128, 64);
Mane4FlatR.mirror = true;
setRotation(Mane4FlatR, 0F, -1.570796F, -0.3490659F);
PixelmonModelRenderer BeardMid = new PixelmonModelRenderer(this, 112, 0);
BeardMid.addBox(-2.5F, -1.8F, -9.3F, 5, 8, 3);
BeardMid.setTextureSize(128, 64);
BeardMid.mirror = true;
setRotation(BeardMid, 0.3490659F, 0F, 0F);
PixelmonModelRenderer Mane1FlatR = new PixelmonModelRenderer(this, 90, -2);
Mane1FlatR.addBox(-7.8F, -12.7F, 4.6F, 0, 10, 2);
Mane1FlatR.setTextureSize(128, 64);
Mane1FlatR.mirror = true;
setRotation(Mane1FlatR, 0F, -1.570796F, -0.7853982F);
PixelmonModelRenderer Mane5FlatBackL = new PixelmonModelRenderer(this, 94, -2);
Mane5FlatBackL.addBox(7F, -9.5F, -2.8F, 0, 10, 2);
Mane5FlatBackL.setTextureSize(128, 64);
Mane5FlatBackL.mirror = true;
setRotation(Mane5FlatBackL, 0.1745329F, 0F, 0F);
PixelmonModelRenderer Mane3FlatR = new PixelmonModelRenderer(this, 90, -2);
Mane3FlatR.addBox(-8F, -10F, 5.9F, 0, 10, 2);
Mane3FlatR.setTextureSize(128, 64);
Mane3FlatR.mirror = true;
setRotation(Mane3FlatR, 0F, -1.570796F, -0.3490659F);
PixelmonModelRenderer Mane5FlatBackR = new PixelmonModelRenderer(this, 94, -2);
Mane5FlatBackR.addBox(-7F, -9.5F, -2.8F, 0, 10, 2);
Mane5FlatBackR.setTextureSize(128, 64);
Mane5FlatBackR.mirror = true;
setRotation(Mane5FlatBackR, 0.1745329F, 0F, 0F);
PixelmonModelRenderer BeardUpperFlatR = new PixelmonModelRenderer(this, 90, 0);
BeardUpperFlatR.addBox(-8.2F, -10.9F, 2.7F, 0, 7, 2);
BeardUpperFlatR.setTextureSize(128, 64);
BeardUpperFlatR.mirror = true;
setRotation(BeardUpperFlatR, 0F, -1.570796F, -1.047198F);
PixelmonModelRenderer Mane5FlatL = new PixelmonModelRenderer(this, 90, -2);
Mane5FlatL.addBox(5.8F, -9.5F, 6.6F, 0, 10, 2);
Mane5FlatL.setTextureSize(128, 64);
Mane5FlatL.mirror = true;
setRotation(Mane5FlatL, 0F, 1.570796F, 0.1745329F);
PixelmonModelRenderer BeardMidFlatR = new PixelmonModelRenderer(this, 90, 2);
BeardMidFlatR.addBox(-9.3F, 1.3F, 2.2F, 0, 6, 2);
BeardMidFlatR.setTextureSize(128, 64);
BeardMidFlatR.mirror = true;
setRotation(BeardMidFlatR, 0F, -1.570796F, -0.3490659F);
PixelmonModelRenderer Mane4FlatL = new PixelmonModelRenderer(this, 90, -2);
Mane4FlatL.addBox(6F, -10F, 6.1F, 0, 10, 2);
Mane4FlatL.setTextureSize(128, 64);
Mane4FlatL.mirror = true;
setRotation(Mane4FlatL, 0F, 1.570796F, 0.3490659F);
PixelmonModelRenderer BeardMidFlatL = new PixelmonModelRenderer(this, 90, 2);
BeardMidFlatL.addBox(9.3F, 1.3F, 2.2F, 0, 6, 2);
BeardMidFlatL.setTextureSize(128, 64);
BeardMidFlatL.mirror = true;
setRotation(BeardMidFlatL, 0F, 1.570796F, 0.3490659F);
PixelmonModelRenderer Mane3FlatL = new PixelmonModelRenderer(this, 90, -2);
Mane3FlatL.addBox(8F, -10F, 5.9F, 0, 10, 2);
Mane3FlatL.setTextureSize(128, 64);
Mane3FlatL.mirror = true;
setRotation(Mane3FlatL, 0F, 1.570796F, 0.3490659F);
PixelmonModelRenderer BeardUpperFlatL = new PixelmonModelRenderer(this, 90, 0);
BeardUpperFlatL.addBox(8.2F, -10.9F, 2.7F, 0, 7, 2);
BeardUpperFlatL.setTextureSize(128, 64);
BeardUpperFlatL.mirror = true;
setRotation(BeardUpperFlatL, 0F, 1.570796F, 1.047198F);
PixelmonModelRenderer Mane1FlatL = new PixelmonModelRenderer(this, 90, -2);
Mane1FlatL.addBox(7.8F, -12.7F, 4.6F, 0, 10, 2);
Mane1FlatL.setTextureSize(128, 64);
Mane1FlatL.mirror = true;
setRotation(Mane1FlatL, 0F, 1.570796F, 0.7853982F);
Body.addChild(BodyMainUpper);
Body.addChild(StomachLAngleFront);
Body.addChild(StomachRAngleFront);
Body.addChild(StomachLAngleBack);
Body.addChild(StomachRAngleBack);
Body.addChild(StomachLFront);
Body.addChild(StomachRFront);
Body.addChild(StomachMainBack);
Body.addChild(Mane3);
Body.addChild(BodyMainUpperAngle);
Body.addChild(Mane1);
Body.addChild(BodyLowerBack);
Body.addChild(Mane5);
Body.addChild(Ass);
Body.addChild(Mane2);
Body.addChild(BeardLowerFlat);
Body.addChild(Mane4);
Body.addChild(Mane5FlatR);
Body.addChild(BeardUpper);
Body.addChild(Mane4FlatR);
Body.addChild(BeardMid);
Body.addChild(Mane1FlatR);
Body.addChild(Mane5FlatBackL);
Body.addChild(Mane3FlatR);
Body.addChild(Mane5FlatBackR);
Body.addChild(BeardUpperFlatR);
Body.addChild(Mane5FlatL);
Body.addChild(BeardMidFlatR);
Body.addChild(Mane4FlatL);
Body.addChild(BeardMidFlatL);
Body.addChild(Mane3FlatL);
Body.addChild(BeardUpperFlatL);
Body.addChild(Mane1FlatL);
PixelmonModelRenderer Head = new PixelmonModelRenderer(this, "Head");
Head.setRotationPoint(0, -1, -17);
PixelmonModelRenderer RHornLevel1X4 = new PixelmonModelRenderer(this, 8, 27);
RHornLevel1X4.addBox(-4F, -1F, 2.2F, 2, 1, 1);
RHornLevel1X4.setTextureSize(128, 64);
RHornLevel1X4.mirror = true;
setRotation(RHornLevel1X4, 0.3490659F, -0.2617994F, -0.0872665F);
PixelmonModelRenderer HeadR = new PixelmonModelRenderer(this, 16, 54);
HeadR.addBox(-2F, -2F, 0F, 3, 5, 5);
HeadR.setTextureSize(128, 64);
HeadR.mirror = true;
setRotation(HeadR, 0.3490659F, -0.2617994F, -0.0872665F);
PixelmonModelRenderer BrowR = new PixelmonModelRenderer(this, 12, 47);
BrowR.addBox(-2F, -1.5F, -2.7F, 2, 3, 4);
BrowR.setTextureSize(128, 64);
BrowR.mirror = true;
setRotation(BrowR, 0.9773844F, -0.2094395F, -0.0698132F);
PixelmonModelRenderer BrowL = new PixelmonModelRenderer(this, 0, 47);
BrowL.addBox(0F, -1.5F, -2.7F, 2, 3, 4);
BrowL.setTextureSize(128, 64);
BrowL.mirror = true;
setRotation(BrowL, 0.9773844F, 0.2094395F, 0.0698132F);
PixelmonModelRenderer HeadL = new PixelmonModelRenderer(this, 0, 54);
HeadL.addBox(-1F, -2F, 0F, 3, 5, 5);
HeadL.setTextureSize(128, 64);
HeadL.mirror = true;
setRotation(HeadL, 0.3490659F, 0.2617994F, 0.0872665F);
PixelmonModelRenderer RHornLevel3 = new PixelmonModelRenderer(this, 8, 25);
RHornLevel3.addBox(-6.2F, 1.5F, 1.5F, 1, 1, 1);
RHornLevel3.setTextureSize(128, 64);
RHornLevel3.mirror = true;
setRotation(RHornLevel3, 0.3490659F, -0.2617994F, 0.5235988F);
PixelmonModelRenderer RHornLevel4 = new PixelmonModelRenderer(this, 8, 25);
RHornLevel4.addBox(-4.9F, 4.4F, 1.5F, 1, 1, 1);
RHornLevel4.setTextureSize(128, 64);
RHornLevel4.mirror = true;
setRotation(RHornLevel4, 0.5759587F, -0.5934119F, 1.047198F);
PixelmonModelRenderer LHornLevel2X4 = new PixelmonModelRenderer(this, 14, 27);
LHornLevel2X4.addBox(3.6F, -0.2F, 2F, 2, 1, 1);
LHornLevel2X4.setTextureSize(128, 64);
LHornLevel2X4.mirror = true;
setRotation(LHornLevel2X4, 0.3490659F, 0.2617994F, -0.1745329F);
PixelmonModelRenderer LHornLevel2X2 = new PixelmonModelRenderer(this, 14, 31);
LHornLevel2X2.addBox(3.6F, -0.4F, 2.2F, 2, 1, 1);
LHornLevel2X2.setTextureSize(128, 64);
LHornLevel2X2.mirror = true;
setRotation(LHornLevel2X2, 0.3490659F, 0.2617994F, -0.1745329F);
PixelmonModelRenderer LHornBase = new PixelmonModelRenderer(this, 0, 31);
LHornBase.addBox(0.4F, -1.8F, 2F, 2, 2, 2);
LHornBase.setTextureSize(128, 64);
LHornBase.mirror = true;
setRotation(LHornBase, 0.3490659F, 0.2617994F, 0.0872665F);
PixelmonModelRenderer RHornLevel2X2 = new PixelmonModelRenderer(this, 14, 31);
RHornLevel2X2.addBox(-5.6F, -0.4F, 2.2F, 2, 1, 1);
RHornLevel2X2.setTextureSize(128, 64);
RHornLevel2X2.mirror = true;
setRotation(RHornLevel2X2, 0.3490659F, -0.2617994F, 0.1745329F);
PixelmonModelRenderer RHornLevel2X1 = new PixelmonModelRenderer(this, 14, 33);
RHornLevel2X1.addBox(-5.6F, -0.4F, 2F, 2, 1, 1);
RHornLevel2X1.setTextureSize(128, 64);
RHornLevel2X1.mirror = true;
setRotation(RHornLevel2X1, 0.3490659F, -0.2617994F, 0.1745329F);
PixelmonModelRenderer LHornLevel1X1 = new PixelmonModelRenderer(this, 8, 33);
LHornLevel1X1.addBox(2F, -1.6F, 2.2F, 2, 1, 1);
LHornLevel1X1.setTextureSize(128, 64);
LHornLevel1X1.mirror = true;
setRotation(LHornLevel1X1, 0.3490659F, 0.2617994F, 0.0872665F);
PixelmonModelRenderer LHornLevel4 = new PixelmonModelRenderer(this, 8, 25);
LHornLevel4.addBox(3.9F, 4.4F, 1.5F, 1, 1, 1);
LHornLevel4.setTextureSize(128, 64);
LHornLevel4.mirror = true;
setRotation(LHornLevel4, 0.5759587F, 0.5934119F, -1.047198F);
PixelmonModelRenderer LHornLevel1X2 = new PixelmonModelRenderer(this, 8, 31);
LHornLevel1X2.addBox(2F, -1.6F, 2.8F, 2, 1, 1);
LHornLevel1X2.setTextureSize(128, 64);
LHornLevel1X2.mirror = true;
setRotation(LHornLevel1X2, 0.3490659F, 0.2617994F, 0.0872665F);
PixelmonModelRenderer LHornLevel3 = new PixelmonModelRenderer(this, 8, 25);
LHornLevel3.addBox(5.2F, 1.5F, 1.5F, 1, 1, 1);
LHornLevel3.setTextureSize(128, 64);
LHornLevel3.mirror = true;
setRotation(LHornLevel3, 0.3490659F, 0.2617994F, -0.5235988F);
PixelmonModelRenderer LHornLevel1X4 = new PixelmonModelRenderer(this, 8, 27);
LHornLevel1X4.addBox(2F, -1F, 2.2F, 2, 1, 1);
LHornLevel1X4.setTextureSize(128, 64);
LHornLevel1X4.mirror = true;
setRotation(LHornLevel1X4, 0.3490659F, 0.2617994F, 0.0872665F);
PixelmonModelRenderer LHornLevel2X1 = new PixelmonModelRenderer(this, 14, 33);
LHornLevel2X1.addBox(3.6F, -0.4F, 2F, 2, 1, 1);
LHornLevel2X1.setTextureSize(128, 64);
LHornLevel2X1.mirror = true;
setRotation(LHornLevel2X1, 0.3490659F, 0.2617994F, -0.1745329F);
PixelmonModelRenderer JawFillL = new PixelmonModelRenderer(this, 0, 42);
JawFillL.addBox(0F, 0.8F, -2.7F, 2, 2, 3);
JawFillL.setTextureSize(128, 64);
JawFillL.mirror = true;
setRotation(JawFillL, 0.5061455F, 0.2268928F, 0.0698132F);
PixelmonModelRenderer LHornLevel1X3 = new PixelmonModelRenderer(this, 8, 29);
LHornLevel1X3.addBox(2F, -1F, 2.8F, 2, 1, 1);
LHornLevel1X3.setTextureSize(128, 64);
LHornLevel1X3.mirror = true;
setRotation(LHornLevel1X3, 0.3490659F, 0.2617994F, 0.0872665F);
PixelmonModelRenderer JawFillR = new PixelmonModelRenderer(this, 10, 42);
JawFillR.addBox(-2F, 0.8F, -2.7F, 2, 2, 3);
JawFillR.setTextureSize(128, 64);
JawFillR.mirror = true;
setRotation(JawFillR, 0.5061455F, -0.2268928F, -0.0698132F);
PixelmonModelRenderer LHornLevel2X3 = new PixelmonModelRenderer(this, 14, 29);
LHornLevel2X3.addBox(3.6F, -0.2F, 2.2F, 2, 1, 1);
LHornLevel2X3.setTextureSize(128, 64);
LHornLevel2X3.mirror = true;
setRotation(LHornLevel2X3, 0.3490659F, 0.2617994F, -0.1745329F);
PixelmonModelRenderer LowerMouth = new PixelmonModelRenderer(this, 35, 16);
LowerMouth.addBox(-1.5F, 0.5F, -1.8F, 3, 3, 7);
LowerMouth.setTextureSize(128, 64);
LowerMouth.mirror = true;
setRotation(LowerMouth, 0.1342561F, 0F, 0F);
PixelmonModelRenderer RHornLevel2X4 = new PixelmonModelRenderer(this, 14, 27);
RHornLevel2X4.addBox(-5.6F, -0.2F, 2F, 2, 1, 1);
RHornLevel2X4.setTextureSize(128, 64);
RHornLevel2X4.mirror = true;
setRotation(RHornLevel2X4, 0.3490659F, -0.2617994F, 0.1745329F);
PixelmonModelRenderer ForeheadDot = new PixelmonModelRenderer(this, 11, 40);
ForeheadDot.addBox(-0.5F, -1.8F, -0.7F, 1, 1, 1);
ForeheadDot.setTextureSize(128, 64);
ForeheadDot.mirror = true;
setRotation(ForeheadDot, 0.9773844F, 0F, 0F);
PixelmonModelRenderer RHornBase = new PixelmonModelRenderer(this, 0, 27);
RHornBase.addBox(-2.4F, -1.8F, 2F, 2, 2, 2);
RHornBase.setTextureSize(128, 64);
RHornBase.mirror = true;
setRotation(RHornBase, 0.3490659F, -0.2617994F, -0.0872665F);
PixelmonModelRenderer Snout = new PixelmonModelRenderer(this, 0, 35);
Snout.addBox(-1.5F, -0.2F, -4F, 3, 3, 4);
Snout.setTextureSize(128, 64);
Snout.mirror = true;
setRotation(Snout, 0.4833219F, 0F, 0F);
PixelmonModelRenderer RHornLevel2X3 = new PixelmonModelRenderer(this, 14, 29);
RHornLevel2X3.addBox(-5.6F, -0.2F, 2.2F, 2, 1, 1);
RHornLevel2X3.setTextureSize(128, 64);
RHornLevel2X3.mirror = true;
setRotation(RHornLevel2X3, 0.3490659F, -0.2617994F, 0.1745329F);
PixelmonModelRenderer RHornLevel1X1 = new PixelmonModelRenderer(this, 8, 33);
RHornLevel1X1.addBox(-4F, -1.6F, 2.2F, 2, 1, 1);
RHornLevel1X1.setTextureSize(128, 64);
RHornLevel1X1.mirror = true;
setRotation(RHornLevel1X1, 0.3490659F, -0.2617994F, -0.0872665F);
PixelmonModelRenderer RHornLevel1X2 = new PixelmonModelRenderer(this, 8, 31);
RHornLevel1X2.addBox(-4F, -1.6F, 2.8F, 2, 1, 1);
RHornLevel1X2.setTextureSize(128, 64);
RHornLevel1X2.mirror = true;
setRotation(RHornLevel1X2, 0.3490659F, -0.2617994F, -0.0872665F);
PixelmonModelRenderer RHornLevel1X3 = new PixelmonModelRenderer(this, 8, 29);
RHornLevel1X3.addBox(-4F, -1F, 2.8F, 2, 1, 1);
RHornLevel1X3.setTextureSize(128, 64);
RHornLevel1X3.mirror = true;
setRotation(RHornLevel1X3, 0.3490659F, -0.2617994F, -0.0872665F);
Head.addChild(RHornLevel1X4);
Head.addChild(HeadR);
Head.addChild(BrowR);
Head.addChild(BrowL);
Head.addChild(HeadL);
Head.addChild(RHornLevel3);
Head.addChild(RHornLevel4);
Head.addChild(LHornLevel2X4);
Head.addChild(LHornLevel2X2);
Head.addChild(LHornBase);
Head.addChild(RHornLevel2X2);
Head.addChild(RHornLevel2X1);
Head.addChild(LHornLevel1X1);
Head.addChild(LHornLevel4);
Head.addChild(LHornLevel1X2);
Head.addChild(LHornLevel3);
Head.addChild(LHornLevel1X4);
Head.addChild(LHornLevel2X1);
Head.addChild(JawFillL);
Head.addChild(LHornLevel1X3);
Head.addChild(JawFillR);
Head.addChild(LHornLevel2X3);
Head.addChild(LowerMouth);
Head.addChild(RHornLevel2X4);
Head.addChild(ForeheadDot);
Head.addChild(RHornBase);
Head.addChild(Snout);
Head.addChild(RHornLevel2X3);
Head.addChild(RHornLevel1X1);
Head.addChild(RHornLevel1X2);
Head.addChild(RHornLevel1X3);
TailL = new PixelmonModelRenderer(this, "Tail Left");
TailL.setRotationPoint(0, 0, 17);
TailL2 = new PixelmonModelRenderer(this, "Tail Left2");
TailL2.setRotationPoint(1.5F, 2, 6);
TailL3 = new PixelmonModelRenderer(this, "Tail Left3");
TailL3.setRotationPoint(0, -1, 7);
PixelmonModelRenderer LTailSeg3 = new PixelmonModelRenderer(this, 42, 56);
LTailSeg3.addBox(-0.5F, -0.6F, -0.1F, 1, 1, 7);
LTailSeg3.setTextureSize(128, 64);
LTailSeg3.mirror = true;
setRotation(LTailSeg3, 0.3839724F, 0F, 0F);
PixelmonModelRenderer LTailWhipFlat = new PixelmonModelRenderer(this, 47, 56);
LTailWhipFlat.addBox(-1.5F, 0F, 0F, 3, 0, 4);
LTailWhipFlat.setRotationPoint(0, -2.5F, 6.3F);
LTailWhipFlat.setTextureSize(128, 64);
LTailWhipFlat.mirror = true;
setRotation(LTailWhipFlat, 0.8551081F, 0F, 0F);
PixelmonModelRenderer LTailSeg1 = new PixelmonModelRenderer(this, 42, 56);
LTailSeg1.addBox(1F, 0F, 0F, 1, 1, 7);
LTailSeg1.setTextureSize(128, 64);
LTailSeg1.mirror = true;
setRotation(LTailSeg1, -0.2974289F, 0F, 0F);
PixelmonModelRenderer LTailSeg2 = new PixelmonModelRenderer(this, 42, 56);
LTailSeg2.addBox(-0.5F, 0F, 0F, 1, 1, 7);
LTailSeg2.mirror = true;
setRotation(LTailSeg2, 0.2230717F, 0F, 0F);
PixelmonModelRenderer LTailWhip = new PixelmonModelRenderer(this, 51, 60);
LTailWhip.addBox(-1F, -0.5F, 0F, 2, 1, 2);
LTailWhip.setRotationPoint(0, -2.5F, 6.3F);
LTailWhip.setTextureSize(128, 64);
LTailWhip.mirror = true;
setRotation(LTailWhip, 0.8551081F, 0F, 0F);
TailR = new PixelmonModelRenderer(this, "Tail Left");
TailR.setRotationPoint(0, 0, 17);
TailR2 = new PixelmonModelRenderer(this, "Tail Left2");
TailR2.setRotationPoint(-1.5F, -1, 6.5F);
TailR3 = new PixelmonModelRenderer(this, "Tail Left3");
TailR3.setRotationPoint(0, -2, 7F);
PixelmonModelRenderer RTailWhipFlat = new PixelmonModelRenderer(this, 47, 56);
RTailWhipFlat.addBox(-1.5F, -0.2F, 0F, 3, 0, 4);
RTailWhipFlat.setRotationPoint(0, -1, 5.9F);
RTailWhipFlat.setTextureSize(128, 64);
RTailWhipFlat.mirror = true;
setRotation(RTailWhipFlat, 0.2617994F, 0F, 0F);
PixelmonModelRenderer RTailSeg1 = new PixelmonModelRenderer(this, 42, 56);
RTailSeg1.addBox(-2F, 0F, 0F, 1, 1, 7);
RTailSeg1.setTextureSize(128, 64);
RTailSeg1.mirror = true;
setRotation(RTailSeg1, 0.1487144F, 0F, 0F);
PixelmonModelRenderer RTailSeg2 = new PixelmonModelRenderer(this, 42, 56);
RTailSeg2.addBox(-0.5F, 0F, 0F, 1, 1, 7);
RTailSeg2.setTextureSize(128, 64);
RTailSeg2.mirror = true;
setRotation(RTailSeg2, 0.3717861F, 0F, 0F);
PixelmonModelRenderer RTailSeg3 = new PixelmonModelRenderer(this, 42, 56);
RTailSeg3.addBox(-0.5F, -0.6F, -0.5F, 1, 1, 7);
RTailSeg3.setTextureSize(128, 64);
RTailSeg3.mirror = true;
setRotation(RTailSeg3, 0.1745329F, 0F, 0F);
PixelmonModelRenderer RTailWhip = new PixelmonModelRenderer(this, 51, 60);
RTailWhip.addBox(-1F, -0.7F, 0F, 2, 1, 2);
RTailWhip.setRotationPoint(0, -1, 5.9F);
RTailWhip.setTextureSize(128, 64);
RTailWhip.mirror = true;
setRotation(RTailWhip, 0.2617994F, 0F, 0F);
TailM = new PixelmonModelRenderer(this, "Tail Left");
TailM.setRotationPoint(0, 0, 17);
TailM2 = new PixelmonModelRenderer(this, "Tail Left2");
TailM2.setRotationPoint(-0.5F, -2.3F, 6);
TailM3 = new PixelmonModelRenderer(this, "Tail Left3");
TailM3.setRotationPoint(0.5F, -4.5F, 5);
PixelmonModelRenderer MidTailSeg3 = new PixelmonModelRenderer(this, 42, 56);
MidTailSeg3.addBox(-0.5F, -0.4F, 0F, 1, 1, 7);
MidTailSeg3.setTextureSize(128, 64);
MidTailSeg3.mirror = true;
setRotation(MidTailSeg3, 0.1745329F, 0F, 0F);
PixelmonModelRenderer MidTailWhipFlat = new PixelmonModelRenderer(this, 47, 56);
MidTailWhipFlat.addBox(-1.5F, 0.1F, 0F, 3, 0, 4);
MidTailWhipFlat.setRotationPoint(0, -1.2F, 6.7F);
MidTailWhipFlat.setTextureSize(128, 64);
MidTailWhipFlat.mirror = true;
setRotation(MidTailWhipFlat, 0F, 0F, 0F);
PixelmonModelRenderer MidTailWhip = new PixelmonModelRenderer(this, 51, 60);
MidTailWhip.addBox(-1F, -0.4F, 0F, 2, 1, 2);
MidTailWhip.setRotationPoint(0, -1.2F, 6.7F);
MidTailWhip.setTextureSize(128, 64);
MidTailWhip.mirror = true;
setRotation(MidTailWhip, 0F, 0F, 0F);
PixelmonModelRenderer MidTailSeg2 = new PixelmonModelRenderer(this, 42, 56);
MidTailSeg2.addBox(0F, 0F, 0F, 1, 1, 7);
MidTailSeg2.setTextureSize(128, 64);
MidTailSeg2.mirror = true;
setRotation(MidTailSeg2, 0.7807508F, 0F, 0F);
PixelmonModelRenderer MidTailSeg1 = new PixelmonModelRenderer(this, 42, 56);
MidTailSeg1.addBox(-0.5F, 0F, 0F, 1, 1, 7);
MidTailSeg1.setTextureSize(128, 64);
MidTailSeg1.mirror = true;
setRotation(MidTailSeg1, 0.3717861F, 0F, 0F);
TailL.addChild(LTailSeg1);
TailL2.addChild(LTailSeg2);
TailL3.addChild(LTailSeg3);
TailL3.addChild(LTailWhipFlat);
TailL3.addChild(LTailWhip);
TailR.addChild(RTailSeg1);
TailR2.addChild(RTailSeg2);
TailR3.addChild(RTailSeg3);
TailR3.addChild(RTailWhip);
TailR3.addChild(RTailWhipFlat);
TailM.addChild(MidTailSeg1);
TailM2.addChild(MidTailSeg2);
TailM3.addChild(MidTailSeg3);
TailM3.addChild(MidTailWhipFlat);
TailM3.addChild(MidTailWhip);
TailL.addChild(TailL2);
TailL2.addChild(TailL3);
TailR.addChild(TailR2);
TailR2.addChild(TailR3);
TailM.addChild(TailM2);
TailM2.addChild(TailM3);
PixelmonModelRenderer FLLeg = new PixelmonModelRenderer(this, "Front Left Leg");
FLLeg.setRotationPoint(4, 4, -6);
PixelmonModelRenderer LFrontThighFill1 = new PixelmonModelRenderer(this, 0, 0);
LFrontThighFill1.addBox(0.1F, -0.8F, -1.9F, 2, 8, 2);
LFrontThighFill1.setTextureSize(128, 64);
LFrontThighFill1.mirror = true;
setRotation(LFrontThighFill1, 0F, 0F, 0F);
PixelmonModelRenderer LFrontThighFill2 = new PixelmonModelRenderer(this, 0, 0);
LFrontThighFill2.addBox(0.1F, -2.1F, -2F, 2, 2, 5);
LFrontThighFill2.setTextureSize(128, 64);
LFrontThighFill2.mirror = true;
setRotation(LFrontThighFill2, -0.296706F, 0F, 0F);
PixelmonModelRenderer LFrontThighFill3 = new PixelmonModelRenderer(this, 0, 0);
LFrontThighFill3.addBox(0.1F, -3.1F, -1.5F, 2, 1, 4);
LFrontThighFill3.setTextureSize(128, 64);
LFrontThighFill3.mirror = true;
setRotation(LFrontThighFill3, -0.296706F, 0F, 0F);
PixelmonModelRenderer LFrontHoof = new PixelmonModelRenderer(this, 33, 60);
LFrontHoof.addBox(-0.1F, 10F, -1.6F, 2, 2, 2);
LFrontHoof.setTextureSize(128, 64);
LFrontHoof.mirror = true;
setRotation(LFrontHoof, 0F, 0F, 0F);
PixelmonModelRenderer LFrontThighInner = new PixelmonModelRenderer(this, 0, 0);
LFrontThighInner.addBox(-1.8F, 0F, 0F, 2, 7, 3);
LFrontThighInner.setTextureSize(128, 64);
LFrontThighInner.mirror = true;
setRotation(LFrontThighInner, -0.2676412F, -0.0523599F, -0.2094395F);
PixelmonModelRenderer LFrontThighOuter = new PixelmonModelRenderer(this, 0, 0);
LFrontThighOuter.addBox(0.1F, -1F, 0F, 2, 8, 3);
LFrontThighOuter.setTextureSize(128, 64);
LFrontThighOuter.mirror = true;
setRotation(LFrontThighOuter, -0.2676412F, 0F, 0F);
PixelmonModelRenderer LFrontCalf = new PixelmonModelRenderer(this, 0, 0);
LFrontCalf.addBox(-0.1F, 6F, -1.3F, 2, 4, 2);
LFrontCalf.setTextureSize(128, 64);
LFrontCalf.mirror = true;
setRotation(LFrontCalf, 0F, 0F, 0F);
FLLeg.addChild(LFrontThighFill1);
FLLeg.addChild(LFrontThighFill2);
FLLeg.addChild(LFrontThighFill3);
FLLeg.addChild(LFrontHoof);
FLLeg.addChild(LFrontThighInner);
FLLeg.addChild(LFrontThighOuter);
FLLeg.addChild(LFrontCalf);
PixelmonModelRenderer FRLeg = new PixelmonModelRenderer(this, "Front Right Leg");
FRLeg.setRotationPoint(-4, 4, -6);
PixelmonModelRenderer RFrontHoof = new PixelmonModelRenderer(this, 33, 60);
RFrontHoof.addBox(-1.9F, 10F, -1.6F, 2, 2, 2);
RFrontHoof.setTextureSize(128, 64);
RFrontHoof.mirror = true;
setRotation(RFrontHoof, 0F, 0F, 0F);
PixelmonModelRenderer RFrontThighFill3 = new PixelmonModelRenderer(this, 0, 0);
RFrontThighFill3.addBox(-2.1F, -3.1F, -1.5F, 2, 1, 4);
RFrontThighFill3.setTextureSize(128, 64);
RFrontThighFill3.mirror = true;
setRotation(RFrontThighFill3, -0.296706F, 0F, 0F);
PixelmonModelRenderer RFrontThighFill1 = new PixelmonModelRenderer(this, 0, 0);
RFrontThighFill1.addBox(-2.1F, -0.8F, -1.9F, 2, 8, 2);
RFrontThighFill1.setTextureSize(128, 64);
RFrontThighFill1.mirror = true;
setRotation(RFrontThighFill1, 0F, 0F, 0F);
PixelmonModelRenderer RFrontCalf = new PixelmonModelRenderer(this, 0, 0);
RFrontCalf.addBox(-1.9F, 6F, -1.3F, 2, 4, 2);
RFrontCalf.setTextureSize(128, 64);
RFrontCalf.mirror = true;
setRotation(RFrontCalf, 0F, 0F, 0F);
PixelmonModelRenderer RFrontThighInner = new PixelmonModelRenderer(this, 0, 0);
RFrontThighInner.addBox(-0.1F, 0F, 0F, 2, 7, 3);
RFrontThighInner.setTextureSize(128, 64);
RFrontThighInner.mirror = true;
setRotation(RFrontThighInner, -0.2676412F, 0.0523599F, 0.2094395F);
PixelmonModelRenderer RFrontThighOuter = new PixelmonModelRenderer(this, 0, 0);
RFrontThighOuter.addBox(-2.1F, -1F, 0F, 2, 8, 3);
RFrontThighOuter.setTextureSize(128, 64);
RFrontThighOuter.mirror = true;
setRotation(RFrontThighOuter, -0.2676412F, 0F, 0F);
PixelmonModelRenderer RFrontThighFill2 = new PixelmonModelRenderer(this, 0, 0);
RFrontThighFill2.addBox(-2.1F, -2.1F, -2F, 2, 2, 5);
RFrontThighFill2.setTextureSize(128, 64);
RFrontThighFill2.mirror = true;
setRotation(RFrontThighFill2, -0.296706F, 0F, 0F);
FRLeg.addChild(RFrontHoof);
FRLeg.addChild(RFrontThighFill3);
FRLeg.addChild(RFrontThighFill1);
FRLeg.addChild(RFrontCalf);
FRLeg.addChild(RFrontThighInner);
FRLeg.addChild(RFrontThighOuter);
FRLeg.addChild(RFrontThighFill2);
PixelmonModelRenderer BRLeg = new PixelmonModelRenderer(this, "Back Right Leg");
BRLeg.setRotationPoint(-5, -1, 15);
PixelmonModelRenderer HipRAngle = new PixelmonModelRenderer(this, 0, 0);
HipRAngle.addBox(-1.4F, -2F, -3F, 2, 2, 5);
HipRAngle.setTextureSize(128, 64);
HipRAngle.mirror = true;
setRotation(HipRAngle, 0.1570796F, -0.1047198F, 0.7853982F);
PixelmonModelRenderer HipR = new PixelmonModelRenderer(this, 0, 0);
HipR.addBox(-1F, -1F, -3F, 2, 6, 5);
HipR.setTextureSize(128, 64);
HipR.mirror = true;
setRotation(HipR, 0.1135515F, 0F, 0F);
PixelmonModelRenderer ThighBackR = new PixelmonModelRenderer(this, 0, 0);
ThighBackR.addBox(-0.4F, 5F, -2F, 2, 6, 3);
ThighBackR.setTextureSize(128, 64);
ThighBackR.mirror = true;
setRotation(ThighBackR, 0.1135515F, 0F, 0.0872665F);
PixelmonModelRenderer ThighBackRInner = new PixelmonModelRenderer(this, 0, 0);
ThighBackRInner.addBox(2.6F, 3.7F, -2F, 2, 7, 3);
ThighBackRInner.setTextureSize(128, 64);
ThighBackRInner.mirror = true;
setRotation(ThighBackRInner, 0.1135515F, -0.0174533F, 0.3490659F);
PixelmonModelRenderer CalfBackR = new PixelmonModelRenderer(this, 0, 0);
CalfBackR.addBox(-0.7F, 10F, 2.5F, 2, 5, 2);
CalfBackR.setTextureSize(128, 64);
CalfBackR.mirror = true;
setRotation(CalfBackR, -0.2268928F, 0F, 0.0523599F);
PixelmonModelRenderer BackRightHoof = new PixelmonModelRenderer(this, 32, 59);
BackRightHoof.addBox(-1.6F, 15F, -2F, 2, 2, 3);
BackRightHoof.setTextureSize(128, 64);
BackRightHoof.mirror = true;
setRotation(BackRightHoof, 0F, 0F, 0F);
BRLeg.addChild(HipRAngle);
BRLeg.addChild(HipR);
BRLeg.addChild(ThighBackR);
BRLeg.addChild(ThighBackRInner);
BRLeg.addChild(CalfBackR);
BRLeg.addChild(BackRightHoof);
PixelmonModelRenderer BLLeg = new PixelmonModelRenderer(this, "Back Left Leg");
BLLeg.setRotationPoint(5, -1, 15);
PixelmonModelRenderer BackLeftHoof = new PixelmonModelRenderer(this, 32, 59);
BackLeftHoof.addBox(-0.4F, 15F, -2F, 2, 2, 3);
BackLeftHoof.setTextureSize(128, 64);
BackLeftHoof.mirror = true;
setRotation(BackLeftHoof, 0F, 0F, 0F);
PixelmonModelRenderer CalfBackLeft = new PixelmonModelRenderer(this, 0, 0);
CalfBackLeft.addBox(-1.3F, 10F, 2.5F, 2, 5, 2);
CalfBackLeft.setTextureSize(128, 64);
CalfBackLeft.mirror = true;
setRotation(CalfBackLeft, -0.2268928F, 0F, -0.0523599F);
PixelmonModelRenderer ThighBackL = new PixelmonModelRenderer(this, 0, 0);
ThighBackL.addBox(-1.6F, 5F, -2F, 2, 6, 3);
ThighBackL.setTextureSize(128, 64);
ThighBackL.mirror = true;
setRotation(ThighBackL, 0.1135515F, 0F, -0.0872665F);
PixelmonModelRenderer ThighBackLInner = new PixelmonModelRenderer(this, 0, 0);
ThighBackLInner.addBox(-4.6F, 3.7F, -2F, 2, 7, 3);
ThighBackLInner.setTextureSize(128, 64);
ThighBackLInner.mirror = true;
setRotation(ThighBackLInner, 0.1135515F, 0.0174533F, -0.3490659F);
PixelmonModelRenderer HipL = new PixelmonModelRenderer(this, 0, 0);
HipL.addBox(-1F, -1F, -3F, 2, 6, 5);
HipL.setTextureSize(128, 64);
HipL.mirror = true;
setRotation(HipL, 0.1135515F, 0F, 0F);
PixelmonModelRenderer HipLAngle = new PixelmonModelRenderer(this, 0, 0);
HipLAngle.addBox(-0.6F, -2F, -3F, 2, 2, 5);
HipLAngle.setTextureSize(128, 64);
HipLAngle.mirror = true;
setRotation(HipLAngle, 0.1570796F, 0.1047198F, -0.7853982F);
BLLeg.addChild(BackLeftHoof);
BLLeg.addChild(CalfBackLeft);
BLLeg.addChild(ThighBackL);
BLLeg.addChild(ThighBackLInner);
BLLeg.addChild(HipL);
BLLeg.addChild(HipLAngle);
Body.addChild(Head);
Body.addChild(FLLeg);
Body.addChild(FRLeg);
Body.addChild(BRLeg);
Body.addChild(BLLeg);
Body.addChild(TailL);
Body.addChild(TailM);
Body.addChild(TailR);
ModuleHead headModule = new ModuleHead(Head);
skeleton =
new SkeletonQuadruped(Body, headModule, FLLeg, FRLeg, BLLeg, BRLeg, 1.1f, 1.1f, 0.8f);
}
public ModelHitmonlee() {
textureWidth = 128;
textureHeight = 64;
Body = new PixelmonModelRenderer(this, "Body");
Body.setRotationPoint(0, -1, 0);
PixelmonModelRenderer Waist_Middle = new PixelmonModelRenderer(this, 52, 0);
Waist_Middle.addBox(-6F, -8F, -2F, 12, 8, 4);
Waist_Middle.setRotationPoint(0F, 8F, 0F);
Waist_Middle.setTextureSize(128, 64);
Waist_Middle.mirror = true;
setRotation(Waist_Middle, 0F, 0F, 0F);
PixelmonModelRenderer Waist_Middle_Front = new PixelmonModelRenderer(this, 84, 0);
Waist_Middle_Front.addBox(-5F, -4F, -1F, 10, 8, 1);
Waist_Middle_Front.setRotationPoint(0F, 4F, -2F);
Waist_Middle_Front.setTextureSize(128, 64);
Waist_Middle_Front.mirror = true;
setRotation(Waist_Middle_Front, 0F, 0F, 0F);
PixelmonModelRenderer Waist_Middle_Front2 = new PixelmonModelRenderer(this, 84, 9);
Waist_Middle_Front2.addBox(-5F, -4F, -1F, 10, 8, 1);
Waist_Middle_Front2.setRotationPoint(0F, 4F, 3F);
Waist_Middle_Front2.setTextureSize(128, 64);
Waist_Middle_Front2.mirror = true;
setRotation(Waist_Middle_Front2, 0F, 0F, 0F);
PixelmonModelRenderer Waist_Middle_Bottom = new PixelmonModelRenderer(this, 52, 12);
Waist_Middle_Bottom.addBox(-5F, 0F, -2F, 10, 1, 4);
Waist_Middle_Bottom.setRotationPoint(0F, 8F, 0F);
Waist_Middle_Bottom.setTextureSize(128, 64);
Waist_Middle_Bottom.mirror = true;
setRotation(Waist_Middle_Bottom, 0F, 0F, 0F);
PixelmonModelRenderer Body_Middle = new PixelmonModelRenderer(this, 0, 46);
Body_Middle.addBox(-7F, -12F, -3F, 14, 12, 6);
Body_Middle.setTextureSize(128, 64);
Body_Middle.mirror = true;
setRotation(Body_Middle, 0F, 0F, 0F);
PixelmonModelRenderer Body_Front = new PixelmonModelRenderer(this, 40, 51);
Body_Front.addBox(-6F, -6F, -1F, 12, 12, 1);
Body_Front.setRotationPoint(0F, -6F, -3F);
Body_Front.setTextureSize(128, 64);
Body_Front.mirror = true;
setRotation(Body_Front, 0F, 0F, 0F);
PixelmonModelRenderer Body_Top = new PixelmonModelRenderer(this, 0, 39);
Body_Top.addBox(-6F, -1F, -3F, 12, 1, 6);
Body_Top.setRotationPoint(0F, -12F, 0F);
Body_Top.setTextureSize(128, 64);
Body_Top.mirror = true;
setRotation(Body_Top, 0F, 0F, 0F);
PixelmonModelRenderer Body_Back = new PixelmonModelRenderer(this, 40, 38);
Body_Back.addBox(-6F, -6F, 0F, 12, 12, 1);
Body_Back.setRotationPoint(0F, -6F, 3F);
Body_Back.setTextureSize(128, 64);
Body_Back.mirror = true;
setRotation(Body_Back, 0F, 0F, 0F);
PixelmonModelRenderer Body_Toppest = new PixelmonModelRenderer(this, 0, 34);
Body_Toppest.addBox(-4F, -1F, -2F, 8, 1, 4);
Body_Toppest.setRotationPoint(0F, -13F, 0F);
Body_Toppest.setTextureSize(128, 64);
Body_Toppest.mirror = true;
setRotation(Body_Toppest, 0F, 0F, 0F);
Body.addChild(Waist_Middle);
Body.addChild(Waist_Middle_Front);
Body.addChild(Waist_Middle_Front2);
Body.addChild(Waist_Middle_Bottom);
Body.addChild(Body_Middle);
Body.addChild(Body_Front);
Body.addChild(Body_Top);
Body.addChild(Body_Back);
Body.addChild(Body_Toppest);
PixelmonModelRenderer LeftArm = new PixelmonModelRenderer(this, "Left Arm");
LeftArm.setRotationPoint(-5.5F, -7, 0);
PixelmonModelRenderer Shoulder_Left = new PixelmonModelRenderer(this, 106, 22);
Shoulder_Left.addBox(-1.5F, 0F, -1.5F, 3, 7, 3);
Shoulder_Left.setTextureSize(128, 64);
Shoulder_Left.mirror = true;
setRotation(Shoulder_Left, 0F, 0F, 0.5235988F);
PixelmonModelRenderer Arm_Upper_Inner_Left = new PixelmonModelRenderer(this, 106, 32);
Arm_Upper_Inner_Left.addBox(-1F, 0F, -1F, 2, 5, 2);
Arm_Upper_Inner_Left.setRotationPoint(-2.8F, 5F, 0F);
Arm_Upper_Inner_Left.setTextureSize(128, 64);
Arm_Upper_Inner_Left.mirror = true;
setRotation(Arm_Upper_Inner_Left, 0F, 0F, 0.5235988F);
PixelmonModelRenderer Arm_Lower_Inner_Left = new PixelmonModelRenderer(this, 114, 32);
Arm_Lower_Inner_Left.addBox(-0.5F, 0F, -0.5F, 1, 6, 1);
Arm_Lower_Inner_Left.setRotationPoint(-5.1F, 9F, 0F);
Arm_Lower_Inner_Left.setTextureSize(128, 64);
Arm_Lower_Inner_Left.mirror = true;
setRotation(Arm_Lower_Inner_Left, 0F, 0F, 0.5235988F);
PixelmonModelRenderer Arm_Ring_1st_Left = new PixelmonModelRenderer(this, 118, 22);
Arm_Ring_1st_Left.addBox(-1F, 0F, -1F, 2, 1, 2);
Arm_Ring_1st_Left.setRotationPoint(-5.3F, 9.466667F, 0F);
Arm_Ring_1st_Left.setTextureSize(128, 64);
Arm_Ring_1st_Left.mirror = true;
setRotation(Arm_Ring_1st_Left, 0F, 0F, 0.5235988F);
PixelmonModelRenderer Arm_Ring_2nd_Left = new PixelmonModelRenderer(this, 118, 22);
Arm_Ring_2nd_Left.addBox(-1F, 0F, -1F, 2, 1, 2);
Arm_Ring_2nd_Left.setRotationPoint(-5.9F, 10.466667F, 0F);
Arm_Ring_2nd_Left.setTextureSize(128, 64);
Arm_Ring_2nd_Left.mirror = true;
setRotation(Arm_Ring_2nd_Left, 0F, 0F, 0.5235988F);
PixelmonModelRenderer Arm_Ring_3rd_Left = new PixelmonModelRenderer(this, 118, 22);
Arm_Ring_3rd_Left.addBox(-1F, 0F, -1F, 2, 1, 2);
Arm_Ring_3rd_Left.setRotationPoint(-6.5F, 11.466667F, 0F);
Arm_Ring_3rd_Left.setTextureSize(128, 64);
Arm_Ring_3rd_Left.mirror = true;
setRotation(Arm_Ring_3rd_Left, 0F, 0F, 0.5235988F);
PixelmonModelRenderer Arm_Ring_4th_Left = new PixelmonModelRenderer(this, 118, 22);
Arm_Ring_4th_Left.addBox(-1F, 0F, -1F, 2, 1, 2);
Arm_Ring_4th_Left.setRotationPoint(-7.1F, 12.466667F, 0F);
Arm_Ring_4th_Left.setTextureSize(128, 64);
Arm_Ring_4th_Left.mirror = true;
setRotation(Arm_Ring_4th_Left, 0F, 0F, 0.5235988F);
PixelmonModelRenderer Palm_Left = new PixelmonModelRenderer(this, 106, 39);
Palm_Left.addBox(-1F, 0F, -1.5F, 2, 2, 3);
Palm_Left.setRotationPoint(-8F, 13.7F, 0F);
Palm_Left.setTextureSize(128, 64);
Palm_Left.mirror = true;
setRotation(Palm_Left, 0F, 0F, 0.5235988F);
PixelmonModelRenderer Finger_2nd_Left = new PixelmonModelRenderer(this, 118, 25);
Finger_2nd_Left.addBox(-0.5F, 0F, -0.5F, 1, 3, 1);
Finger_2nd_Left.setRotationPoint(-8.7F, 14.7F, 0F);
Finger_2nd_Left.setTextureSize(128, 64);
Finger_2nd_Left.mirror = true;
setRotation(Finger_2nd_Left, 0F, 0F, 0.5235988F);
PixelmonModelRenderer Finger_1st_Left = new PixelmonModelRenderer(this, 118, 25);
Finger_1st_Left.addBox(-0.5F, 0F, -0.5F, 1, 3, 1);
Finger_1st_Left.setRotationPoint(-8.7F, 14.7F, -1.5F);
Finger_1st_Left.setTextureSize(128, 64);
Finger_1st_Left.mirror = true;
setRotation(Finger_1st_Left, 0F, 0F, 0.5235988F);
PixelmonModelRenderer Finger_3rd_Left = new PixelmonModelRenderer(this, 118, 25);
Finger_3rd_Left.addBox(-0.5F, 0F, -0.5F, 1, 3, 1);
Finger_3rd_Left.setRotationPoint(-8.7F, 14.7F, 1.5F);
Finger_3rd_Left.setTextureSize(128, 64);
Finger_3rd_Left.mirror = true;
setRotation(Finger_3rd_Left, 0F, 0F, 0.5235988F);
LeftArm.addChild(Shoulder_Left);
LeftArm.addChild(Arm_Upper_Inner_Left);
LeftArm.addChild(Arm_Lower_Inner_Left);
LeftArm.addChild(Arm_Ring_1st_Left);
LeftArm.addChild(Arm_Ring_2nd_Left);
LeftArm.addChild(Arm_Ring_3rd_Left);
LeftArm.addChild(Arm_Ring_4th_Left);
LeftArm.addChild(Palm_Left);
LeftArm.addChild(Finger_2nd_Left);
LeftArm.addChild(Finger_1st_Left);
LeftArm.addChild(Finger_3rd_Left);
Body.addChild(LeftArm);
PixelmonModelRenderer RightArm = new PixelmonModelRenderer(this, "Right Arm");
RightArm.setRotationPoint(5.5F, -7, 0);
PixelmonModelRenderer Shoulder_Right = new PixelmonModelRenderer(this, 106, 0);
Shoulder_Right.addBox(-1.5F, 0F, -1.5F, 3, 7, 3);
Shoulder_Right.setTextureSize(128, 64);
Shoulder_Right.mirror = true;
setRotation(Shoulder_Right, 0F, 0F, -0.5235988F);
PixelmonModelRenderer Arm_Upper_Inner_Right = new PixelmonModelRenderer(this, 106, 10);
Arm_Upper_Inner_Right.addBox(-1F, 0F, -1F, 2, 5, 2);
Arm_Upper_Inner_Right.setRotationPoint(2.8F, 5F, 0F);
Arm_Upper_Inner_Right.setTextureSize(128, 64);
Arm_Upper_Inner_Right.mirror = true;
setRotation(Arm_Upper_Inner_Right, 0F, 0F, -0.5235988F);
PixelmonModelRenderer Arm_Lower_Inner_Right = new PixelmonModelRenderer(this, 114, 10);
Arm_Lower_Inner_Right.addBox(-0.5F, 0F, -0.5F, 1, 6, 1);
Arm_Lower_Inner_Right.setRotationPoint(5.1F, 9F, 0F);
Arm_Lower_Inner_Right.setTextureSize(128, 64);
Arm_Lower_Inner_Right.mirror = true;
setRotation(Arm_Lower_Inner_Right, 0F, 0F, -0.5235988F);
PixelmonModelRenderer Arm_Ring_1st_Right = new PixelmonModelRenderer(this, 118, 0);
Arm_Ring_1st_Right.addBox(-1F, 0F, -1F, 2, 1, 2);
Arm_Ring_1st_Right.setRotationPoint(5.3F, 9.466667F, 0F);
Arm_Ring_1st_Right.setTextureSize(128, 64);
Arm_Ring_1st_Right.mirror = true;
setRotation(Arm_Ring_1st_Right, 0F, 0F, -0.5235988F);
PixelmonModelRenderer Arm_Ring_2nd_Right = new PixelmonModelRenderer(this, 118, 0);
Arm_Ring_2nd_Right.addBox(-1F, 0F, -1F, 2, 1, 2);
Arm_Ring_2nd_Right.setRotationPoint(5.9F, 10.466667F, 0F);
Arm_Ring_2nd_Right.setTextureSize(128, 64);
Arm_Ring_2nd_Right.mirror = true;
setRotation(Arm_Ring_2nd_Right, 0F, 0F, -0.5235988F);
PixelmonModelRenderer Arm_Ring_3rd_Right = new PixelmonModelRenderer(this, 118, 0);
Arm_Ring_3rd_Right.addBox(-1F, 0F, -1F, 2, 1, 2);
Arm_Ring_3rd_Right.setRotationPoint(6.5F, 11.466667F, 0F);
Arm_Ring_3rd_Right.setTextureSize(128, 64);
Arm_Ring_3rd_Right.mirror = true;
setRotation(Arm_Ring_3rd_Right, 0F, 0F, -0.5235988F);
PixelmonModelRenderer Arm_Ring_4th_Right = new PixelmonModelRenderer(this, 118, 0);
Arm_Ring_4th_Right.addBox(-1F, 0F, -1F, 2, 1, 2);
Arm_Ring_4th_Right.setRotationPoint(7.1F, 12.466667F, 0F);
Arm_Ring_4th_Right.setTextureSize(128, 64);
Arm_Ring_4th_Right.mirror = true;
setRotation(Arm_Ring_4th_Right, 0F, 0F, -0.5235988F);
PixelmonModelRenderer Palm_Right = new PixelmonModelRenderer(this, 106, 17);
Palm_Right.addBox(-1F, 0F, -1.5F, 2, 2, 3);
Palm_Right.setRotationPoint(8F, 13.7F, 0F);
Palm_Right.setTextureSize(128, 64);
Palm_Right.mirror = true;
setRotation(Palm_Right, 0F, 0F, -0.5235988F);
PixelmonModelRenderer Finger_1st_Right = new PixelmonModelRenderer(this, 118, 3);
Finger_1st_Right.addBox(-0.5F, 0F, -0.5F, 1, 3, 1);
Finger_1st_Right.setRotationPoint(8.7F, 14.7F, -1.5F);
Finger_1st_Right.setTextureSize(128, 64);
Finger_1st_Right.mirror = true;
setRotation(Finger_1st_Right, 0F, 0F, -0.5235988F);
PixelmonModelRenderer Finger_2nd_Right = new PixelmonModelRenderer(this, 118, 3);
Finger_2nd_Right.addBox(-0.5F, 0F, -0.5F, 1, 3, 1);
Finger_2nd_Right.setRotationPoint(8.7F, 14.7F, 0F);
Finger_2nd_Right.setTextureSize(128, 64);
Finger_2nd_Right.mirror = true;
setRotation(Finger_2nd_Right, 0F, 0F, -0.5235988F);
PixelmonModelRenderer Finger_3rd_Right = new PixelmonModelRenderer(this, 118, 3);
Finger_3rd_Right.addBox(-0.5F, 0F, -0.5F, 1, 3, 1);
Finger_3rd_Right.setRotationPoint(8.7F, 14.7F, 1.5F);
Finger_3rd_Right.setTextureSize(128, 64);
Finger_3rd_Right.mirror = true;
setRotation(Finger_3rd_Right, 0F, 0F, -0.5235988F);
RightArm.addChild(Shoulder_Right);
RightArm.addChild(Arm_Upper_Inner_Right);
RightArm.addChild(Arm_Lower_Inner_Right);
RightArm.addChild(Arm_Ring_1st_Right);
RightArm.addChild(Arm_Ring_2nd_Right);
RightArm.addChild(Arm_Ring_3rd_Right);
RightArm.addChild(Arm_Ring_4th_Right);
RightArm.addChild(Palm_Right);
RightArm.addChild(Finger_1st_Right);
RightArm.addChild(Finger_2nd_Right);
RightArm.addChild(Finger_3rd_Right);
Body.addChild(RightArm);
PixelmonModelRenderer LeftLeg = new PixelmonModelRenderer(this, "Left Leg");
LeftLeg.setRotationPoint(-4.5F, 7, 0);
PixelmonModelRenderer Leg_Claw_1st_Left = new PixelmonModelRenderer(this, 0, 0);
Leg_Claw_1st_Left.addBox(-0.5F, -0.5F, -2F, 1, 1, 2);
Leg_Claw_1st_Left.setRotationPoint(-1F, 17.5F, -2.9F);
Leg_Claw_1st_Left.setTextureSize(128, 64);
Leg_Claw_1st_Left.mirror = true;
setRotation(Leg_Claw_1st_Left, 0F, 0.2617994F, 0F);
PixelmonModelRenderer Leg_Claw_2nd_Left = new PixelmonModelRenderer(this, 0, 0);
Leg_Claw_2nd_Left.addBox(-0.5F, -0.5F, -2F, 1, 1, 2);
Leg_Claw_2nd_Left.setRotationPoint(0F, 17.5F, -3F);
Leg_Claw_2nd_Left.setTextureSize(128, 64);
Leg_Claw_2nd_Left.mirror = true;
setRotation(Leg_Claw_2nd_Left, 0F, 0F, 0F);
PixelmonModelRenderer Leg_Claw_3rd_Left = new PixelmonModelRenderer(this, 0, 0);
Leg_Claw_3rd_Left.addBox(-0.5F, -0.5F, -2F, 1, 1, 2);
Leg_Claw_3rd_Left.setRotationPoint(1F, 17.5F, -2.9F);
Leg_Claw_3rd_Left.setTextureSize(128, 64);
Leg_Claw_3rd_Left.mirror = true;
setRotation(Leg_Claw_3rd_Left, 0F, -0.2617994F, 0F);
PixelmonModelRenderer Leg_Bottom_Left = new PixelmonModelRenderer(this, 6, 16);
Leg_Bottom_Left.addBox(-2F, 0F, -3F, 4, 2, 5);
Leg_Bottom_Left.setRotationPoint(0F, 16F, 0F);
Leg_Bottom_Left.setTextureSize(128, 64);
Leg_Bottom_Left.mirror = true;
setRotation(Leg_Bottom_Left, 0F, 0F, 0F);
PixelmonModelRenderer Leg_Middle_6th_Left = new PixelmonModelRenderer(this, 24, 9);
Leg_Middle_6th_Left.addBox(-1.5F, 0F, -1.5F, 3, 2, 3);
Leg_Middle_6th_Left.setRotationPoint(0F, 14F, 0F);
Leg_Middle_6th_Left.setTextureSize(128, 64);
Leg_Middle_6th_Left.mirror = true;
setRotation(Leg_Middle_6th_Left, 0F, 0F, 0F);
PixelmonModelRenderer Leg_Middle_5th_Left = new PixelmonModelRenderer(this, 24, 9);
Leg_Middle_5th_Left.addBox(-1.5F, 0F, -1.5F, 3, 2, 3);
Leg_Middle_5th_Left.setRotationPoint(0F, 11.8F, 0F);
Leg_Middle_5th_Left.setTextureSize(128, 64);
Leg_Middle_5th_Left.mirror = true;
setRotation(Leg_Middle_5th_Left, 0F, 0F, 0F);
PixelmonModelRenderer Leg_Middle_4th_Left = new PixelmonModelRenderer(this, 24, 9);
Leg_Middle_4th_Left.addBox(-1.5F, 0F, -1.5F, 3, 2, 3);
Leg_Middle_4th_Left.setRotationPoint(0F, 9.6F, 0F);
Leg_Middle_4th_Left.setTextureSize(128, 64);
Leg_Middle_4th_Left.mirror = true;
setRotation(Leg_Middle_4th_Left, 0F, 0F, 0F);
PixelmonModelRenderer Leg_Middle_3rd_Left = new PixelmonModelRenderer(this, 24, 9);
Leg_Middle_3rd_Left.addBox(-1.5F, 0F, -1.5F, 3, 2, 3);
Leg_Middle_3rd_Left.setRotationPoint(0F, 7.4F, 0F);
Leg_Middle_3rd_Left.setTextureSize(128, 64);
Leg_Middle_3rd_Left.mirror = true;
setRotation(Leg_Middle_3rd_Left, 0F, 0F, 0F);
PixelmonModelRenderer Leg_Middle_2nd_Left = new PixelmonModelRenderer(this, 24, 9);
Leg_Middle_2nd_Left.addBox(-1.5F, 0F, -1.5F, 3, 2, 3);
Leg_Middle_2nd_Left.setRotationPoint(0F, 5.2F, 0F);
Leg_Middle_2nd_Left.setTextureSize(128, 64);
Leg_Middle_2nd_Left.mirror = true;
setRotation(Leg_Middle_2nd_Left, 0F, 0F, 0F);
PixelmonModelRenderer Leg_Middle_1st_Left = new PixelmonModelRenderer(this, 24, 9);
Leg_Middle_1st_Left.addBox(-1.5F, 0F, -1.5F, 3, 2, 3);
Leg_Middle_1st_Left.setRotationPoint(0F, 3F, 0F);
Leg_Middle_1st_Left.setTextureSize(128, 64);
Leg_Middle_1st_Left.mirror = true;
setRotation(Leg_Middle_1st_Left, 0F, 0F, 0F);
PixelmonModelRenderer Leg_Inner_Bottom_Left = new PixelmonModelRenderer(this, 16, 23);
Leg_Inner_Bottom_Left.addBox(-1F, 0F, -1F, 2, 7, 2);
Leg_Inner_Bottom_Left.setRotationPoint(0F, 9F, 0F);
Leg_Inner_Bottom_Left.setTextureSize(128, 64);
Leg_Inner_Bottom_Left.mirror = true;
setRotation(Leg_Inner_Bottom_Left, 0F, 0F, 0F);
PixelmonModelRenderer Leg_Inner_Top_Left = new PixelmonModelRenderer(this, 8, 23);
Leg_Inner_Top_Left.addBox(-1F, 0F, -1F, 2, 7, 2);
Leg_Inner_Top_Left.setRotationPoint(0F, 2F, 0F);
Leg_Inner_Top_Left.setTextureSize(128, 64);
Leg_Inner_Top_Left.mirror = true;
setRotation(Leg_Inner_Top_Left, 0F, 0F, 0F);
PixelmonModelRenderer Knee_Left = new PixelmonModelRenderer(this, 24, 14);
Knee_Left.addBox(-1F, 0F, -1F, 2, 2, 2);
Knee_Left.setRotationPoint(0F, 8F, 0F);
Knee_Left.setTextureSize(128, 64);
Knee_Left.mirror = true;
setRotation(Knee_Left, 0F, 0F, 0F);
PixelmonModelRenderer Waist_Left = new PixelmonModelRenderer(this, 36, 9);
Waist_Left.addBox(-2F, -2F, -2F, 4, 5, 4);
Waist_Left.setTextureSize(128, 64);
Waist_Left.mirror = true;
setRotation(Waist_Left, 0F, 0F, 0F);
LeftLeg.addChild(Leg_Claw_1st_Left);
LeftLeg.addChild(Leg_Claw_2nd_Left);
LeftLeg.addChild(Leg_Claw_3rd_Left);
LeftLeg.addChild(Leg_Bottom_Left);
LeftLeg.addChild(Leg_Middle_6th_Left);
LeftLeg.addChild(Leg_Middle_5th_Left);
LeftLeg.addChild(Leg_Middle_4th_Left);
LeftLeg.addChild(Leg_Middle_3rd_Left);
LeftLeg.addChild(Leg_Middle_2nd_Left);
LeftLeg.addChild(Leg_Middle_1st_Left);
LeftLeg.addChild(Leg_Inner_Bottom_Left);
LeftLeg.addChild(Leg_Inner_Top_Left);
LeftLeg.addChild(Knee_Left);
LeftLeg.addChild(Waist_Left);
Body.addChild(LeftLeg);
PixelmonModelRenderer RightLeg = new PixelmonModelRenderer(this, "Right Leg");
RightLeg.setRotationPoint(4.5F, 7, 0);
PixelmonModelRenderer Waist_Right = new PixelmonModelRenderer(this, 36, 0);
Waist_Right.addBox(-2F, -2F, -2F, 4, 5, 4);
Waist_Right.setTextureSize(128, 64);
Waist_Right.mirror = true;
setRotation(Waist_Right, 0F, 0F, 0F);
PixelmonModelRenderer Leg_Inner_Top_Right = new PixelmonModelRenderer(this, 6, 7);
Leg_Inner_Top_Right.addBox(-1F, 0F, -1F, 2, 7, 2);
Leg_Inner_Top_Right.setRotationPoint(0F, 2F, 0F);
Leg_Inner_Top_Right.setTextureSize(128, 64);
Leg_Inner_Top_Right.mirror = true;
setRotation(Leg_Inner_Top_Right, 0F, 0F, 0F);
PixelmonModelRenderer Leg_Inner_Bottom_Right = new PixelmonModelRenderer(this, 14, 7);
Leg_Inner_Bottom_Right.addBox(-1F, 0F, -1F, 2, 7, 2);
Leg_Inner_Bottom_Right.setRotationPoint(0F, 9F, 0F);
Leg_Inner_Bottom_Right.setTextureSize(128, 64);
Leg_Inner_Bottom_Right.mirror = true;
setRotation(Leg_Inner_Bottom_Right, 0F, 0F, 0F);
PixelmonModelRenderer Knee_Right = new PixelmonModelRenderer(this, 24, 5);
Knee_Right.addBox(-1F, 0F, -1F, 2, 2, 2);
Knee_Right.setRotationPoint(0F, 8F, 0F);
Knee_Right.setTextureSize(128, 64);
Knee_Right.mirror = true;
setRotation(Knee_Right, 0F, 0F, 0F);
PixelmonModelRenderer Leg_Bottom_Right = new PixelmonModelRenderer(this, 6, 0);
Leg_Bottom_Right.addBox(-2F, 0F, -3F, 4, 2, 5);
Leg_Bottom_Right.setRotationPoint(0F, 16F, 0F);
Leg_Bottom_Right.setTextureSize(128, 64);
Leg_Bottom_Right.mirror = true;
setRotation(Leg_Bottom_Right, 0F, 0F, 0F);
PixelmonModelRenderer Leg_Claw_2nd_Right = new PixelmonModelRenderer(this, 0, 0);
Leg_Claw_2nd_Right.addBox(-0.5F, -0.5F, -2F, 1, 1, 2);
Leg_Claw_2nd_Right.setRotationPoint(0F, 17.5F, -3F);
Leg_Claw_2nd_Right.setTextureSize(128, 64);
Leg_Claw_2nd_Right.mirror = true;
setRotation(Leg_Claw_2nd_Right, 0F, 0F, 0F);
PixelmonModelRenderer Leg_Claw_3rd_Right = new PixelmonModelRenderer(this, 0, 0);
Leg_Claw_3rd_Right.addBox(-0.5F, -0.5F, -2F, 1, 1, 2);
Leg_Claw_3rd_Right.setRotationPoint(-1F, 17.5F, -2.9F);
Leg_Claw_3rd_Right.setTextureSize(128, 64);
Leg_Claw_3rd_Right.mirror = true;
setRotation(Leg_Claw_3rd_Right, 0F, 0.2617994F, 0F);
PixelmonModelRenderer Leg_Claw_1st_Right = new PixelmonModelRenderer(this, 0, 0);
Leg_Claw_1st_Right.addBox(-0.5F, -0.5F, -2F, 1, 1, 2);
Leg_Claw_1st_Right.setRotationPoint(1F, 17.5F, -2.9F);
Leg_Claw_1st_Right.setTextureSize(128, 64);
Leg_Claw_1st_Right.mirror = true;
setRotation(Leg_Claw_1st_Right, 0F, -0.2617994F, 0F);
PixelmonModelRenderer Leg_Middle_1st_Right = new PixelmonModelRenderer(this, 24, 0);
Leg_Middle_1st_Right.addBox(-1.5F, 0F, -1.5F, 3, 2, 3);
Leg_Middle_1st_Right.setRotationPoint(0F, 3F, 0F);
Leg_Middle_1st_Right.setTextureSize(128, 64);
Leg_Middle_1st_Right.mirror = true;
setRotation(Leg_Middle_1st_Right, 0F, 0F, 0F);
PixelmonModelRenderer Leg_Middle_2nd_Right = new PixelmonModelRenderer(this, 24, 0);
Leg_Middle_2nd_Right.addBox(-1.5F, 0F, -1.5F, 3, 2, 3);
Leg_Middle_2nd_Right.setRotationPoint(0F, 5.2F, 0F);
Leg_Middle_2nd_Right.setTextureSize(128, 64);
Leg_Middle_2nd_Right.mirror = true;
setRotation(Leg_Middle_2nd_Right, 0F, 0F, 0F);
PixelmonModelRenderer Leg_Middle_3rd_Right = new PixelmonModelRenderer(this, 24, 0);
Leg_Middle_3rd_Right.addBox(-1.5F, 0F, -1.5F, 3, 2, 3);
Leg_Middle_3rd_Right.setRotationPoint(0F, 7.4F, 0F);
Leg_Middle_3rd_Right.setTextureSize(128, 64);
Leg_Middle_3rd_Right.mirror = true;
setRotation(Leg_Middle_3rd_Right, 0F, 0F, 0F);
PixelmonModelRenderer Leg_Middle_4th_Right = new PixelmonModelRenderer(this, 24, 0);
Leg_Middle_4th_Right.addBox(-1.5F, 0F, -1.5F, 3, 2, 3);
Leg_Middle_4th_Right.setRotationPoint(0F, 9.6F, 0F);
Leg_Middle_4th_Right.setTextureSize(128, 64);
Leg_Middle_4th_Right.mirror = true;
setRotation(Leg_Middle_4th_Right, 0F, 0F, 0F);
PixelmonModelRenderer Leg_Middle_5th_Right = new PixelmonModelRenderer(this, 24, 0);
Leg_Middle_5th_Right.addBox(-1.5F, 0F, -1.5F, 3, 2, 3);
Leg_Middle_5th_Right.setRotationPoint(0F, 11.8F, 0F);
Leg_Middle_5th_Right.setTextureSize(128, 64);
Leg_Middle_5th_Right.mirror = true;
setRotation(Leg_Middle_5th_Right, 0F, 0F, 0F);
PixelmonModelRenderer Leg_Middle_6th_Right = new PixelmonModelRenderer(this, 24, 0);
Leg_Middle_6th_Right.addBox(-1.5F, 0F, -1.5F, 3, 2, 3);
Leg_Middle_6th_Right.setRotationPoint(0F, 14F, 0F);
Leg_Middle_6th_Right.setTextureSize(128, 64);
Leg_Middle_6th_Right.mirror = true;
setRotation(Leg_Middle_6th_Right, 0F, 0F, 0F);
RightLeg.addChild(Waist_Right);
RightLeg.addChild(Leg_Inner_Top_Right);
RightLeg.addChild(Leg_Inner_Bottom_Right);
RightLeg.addChild(Knee_Right);
RightLeg.addChild(Leg_Bottom_Right);
RightLeg.addChild(Leg_Claw_2nd_Right);
RightLeg.addChild(Leg_Claw_3rd_Right);
RightLeg.addChild(Leg_Claw_1st_Right);
RightLeg.addChild(Leg_Middle_1st_Right);
RightLeg.addChild(Leg_Middle_2nd_Right);
RightLeg.addChild(Leg_Middle_3rd_Right);
RightLeg.addChild(Leg_Middle_4th_Right);
RightLeg.addChild(Leg_Middle_5th_Right);
RightLeg.addChild(Leg_Middle_6th_Right);
Body.addChild(RightLeg);
ModuleArm leftArmModule = new ModuleArm(LeftArm, EnumArm.Left, 0, 0, 0);
ModuleArm rightArmModule = new ModuleArm(RightArm, EnumArm.Right, 0, 0, 0);
float legspeed = 0.5F;
float legRotationLimit = 1.4F;
ModuleLeg leftLegModule =
new ModuleLeg(LeftLeg, EnumLeg.FrontLeft, EnumPhase.InPhase, legRotationLimit, legspeed);
ModuleLeg rightLegModule =
new ModuleLeg(RightLeg, EnumLeg.FrontRight, EnumPhase.InPhase, legRotationLimit, legspeed);
skeleton =
new SkeletonBiped(
Body, null, leftArmModule, rightArmModule, leftLegModule, rightLegModule, null);
}
public ModelMrMime() {
textureWidth = 128;
textureHeight = 64;
Body = new PixelmonModelRenderer(this, "Body");
Body.setRotationPoint(0, 2, -1);
PixelmonModelRenderer Body_Middle = new PixelmonModelRenderer(this, 0, 0);
Body_Middle.addBox(-5F, 0F, -3F, 10, 8, 6);
Body_Middle.setRotationPoint(0F, 2F, -1F);
Body_Middle.setTextureSize(128, 64);
Body_Middle.mirror = true;
setRotation(Body_Middle, 0F, 0F, 0F);
PixelmonModelRenderer Body_Top = new PixelmonModelRenderer(this, 32, 7);
Body_Top.addBox(0F, 0F, 0F, 8, 1, 6);
Body_Top.setRotationPoint(-4F, -1F, -3F);
Body_Top.setTextureSize(128, 64);
Body_Top.mirror = true;
setRotation(Body_Top, 0F, 0F, 0F);
PixelmonModelRenderer Body_Front = new PixelmonModelRenderer(this, 0, 14);
Body_Front.addBox(0F, 0F, 0F, 8, 8, 1);
Body_Front.setRotationPoint(-4F, 0F, -4F);
Body_Front.setTextureSize(128, 64);
Body_Front.mirror = true;
setRotation(Body_Front, 0F, 0F, 0F);
PixelmonModelRenderer Body_Bottom = new PixelmonModelRenderer(this, 32, 0);
Body_Bottom.addBox(0F, 0F, 0F, 8, 1, 6);
Body_Bottom.setRotationPoint(-4F, 8F, -3F);
Body_Bottom.setTextureSize(128, 64);
Body_Bottom.mirror = true;
setRotation(Body_Bottom, 0F, 0F, 0F);
PixelmonModelRenderer Body_Back = new PixelmonModelRenderer(this, 0, 23);
Body_Back.addBox(0F, 0F, 0F, 8, 8, 1);
Body_Back.setRotationPoint(-4F, 0F, 3F);
Body_Back.setTextureSize(128, 64);
Body_Back.mirror = true;
setRotation(Body_Back, 0F, 0F, 0F);
PixelmonModelRenderer Body_Front_Front = new PixelmonModelRenderer(this, 56, 14);
Body_Front_Front.addBox(0F, 0F, 0F, 3, 3, 1);
Body_Front_Front.setRotationPoint(-1.5F, 2.5F, -5F);
Body_Front_Front.setTextureSize(128, 64);
Body_Front_Front.mirror = true;
setRotation(Body_Front_Front, 0F, 0F, 0F);
PixelmonModelRenderer Body_Front_Bottom = new PixelmonModelRenderer(this, 28, 19);
Body_Front_Bottom.addBox(0F, 0F, 0F, 3, 1, 1);
Body_Front_Bottom.setRotationPoint(-1.5F, 5.5F, -4.5F);
Body_Front_Bottom.setTextureSize(128, 64);
Body_Front_Bottom.mirror = true;
setRotation(Body_Front_Bottom, 0F, 0F, 0F);
PixelmonModelRenderer Body_Front_Middle = new PixelmonModelRenderer(this, 64, 14);
Body_Front_Middle.addBox(0F, 0F, 0F, 5, 3, 1);
Body_Front_Middle.setRotationPoint(-2.5F, 2.5F, -4.5F);
Body_Front_Middle.setTextureSize(128, 64);
Body_Front_Middle.mirror = true;
setRotation(Body_Front_Middle, 0F, 0F, 0F);
PixelmonModelRenderer Body_Front_Top = new PixelmonModelRenderer(this, 36, 19);
Body_Front_Top.addBox(0F, 0F, 0F, 3, 1, 1);
Body_Front_Top.setRotationPoint(-1.5F, 1.5F, -4.5F);
Body_Front_Top.setTextureSize(128, 64);
Body_Front_Top.mirror = true;
setRotation(Body_Front_Top, 0F, 0F, 0F);
Body.addChild(Body_Middle);
Body.addChild(Body_Top);
Body.addChild(Body_Front);
Body.addChild(Body_Bottom);
Body.addChild(Body_Back);
Body.addChild(Body_Front_Front);
Body.addChild(Body_Front_Bottom);
Body.addChild(Body_Front_Middle);
Body.addChild(Body_Front_Top);
PixelmonModelRenderer Head = new PixelmonModelRenderer(this, "Head");
Head.setRotationPoint(0, -1F, 0);
PixelmonModelRenderer HeadMain = new PixelmonModelRenderer(this, 80, 0);
HeadMain.addBox(-3.5F, -4F, -2.5F, 7, 5, 5);
HeadMain.setRotationPoint(0F, -1.5F, 0F);
HeadMain.setTextureSize(128, 64);
HeadMain.mirror = true;
setRotation(HeadMain, 0F, 0F, 0F);
PixelmonModelRenderer Neck = new PixelmonModelRenderer(this, 0, 32);
Neck.addBox(-2.5F, -1F, -2.5F, 5, 1, 5);
Neck.setTextureSize(128, 64);
Neck.mirror = true;
setRotation(Neck, 0F, 0F, 0F);
PixelmonModelRenderer Head_Top = new PixelmonModelRenderer(this, 0, 38);
Head_Top.addBox(-2.5F, -1F, -2.5F, 5, 1, 5);
Head_Top.setRotationPoint(0F, -5.5F, 0F);
Head_Top.setTextureSize(128, 64);
Head_Top.mirror = true;
setRotation(Head_Top, 0F, 0F, 0F);
PixelmonModelRenderer Head_Toppest = new PixelmonModelRenderer(this, 28, 14);
Head_Toppest.addBox(-2F, -1F, -2F, 4, 1, 4);
Head_Toppest.setRotationPoint(0F, -6.5F, 0F);
Head_Toppest.setTextureSize(128, 64);
Head_Toppest.mirror = true;
setRotation(Head_Toppest, 0F, 0F, 0F);
PixelmonModelRenderer Head_Front = new PixelmonModelRenderer(this, 92, 10);
Head_Front.addBox(0F, 0F, 0F, 5, 5, 1);
Head_Front.setRotationPoint(-2.5F, -5.5F, -3.5F);
Head_Front.setTextureSize(128, 64);
Head_Front.mirror = true;
setRotation(Head_Front, 0F, 0F, 0F);
PixelmonModelRenderer Head_Back = new PixelmonModelRenderer(this, 80, 10);
Head_Back.addBox(0F, 0F, 0F, 5, 5, 1);
Head_Back.setRotationPoint(-2.5F, -5.5F, 2.5F);
Head_Back.setTextureSize(128, 64);
Head_Back.mirror = true;
setRotation(Head_Back, 0F, 0F, 0F);
PixelmonModelRenderer Ear_Base_Left = new PixelmonModelRenderer(this, 28, 23);
Ear_Base_Left.addBox(-4F, -1F, -1F, 4, 2, 2);
Ear_Base_Left.setRotationPoint(-2F, -6.5F, 0F);
Ear_Base_Left.setTextureSize(128, 64);
Ear_Base_Left.mirror = true;
setRotation(Ear_Base_Left, 0F, 0F, 0.3490659F);
PixelmonModelRenderer Ear_Tip_Left = new PixelmonModelRenderer(this, 28, 21);
Ear_Tip_Left.addBox(-3F, -0.5F, -0.5F, 4, 1, 1);
Ear_Tip_Left.setRotationPoint(-6.3F, -7.8F, -2F);
Ear_Tip_Left.setTextureSize(128, 64);
Ear_Tip_Left.mirror = true;
setRotation(Ear_Tip_Left, 0F, 0F, -0.2617994F);
PixelmonModelRenderer Ear_Spike_1st_Left = new PixelmonModelRenderer(this, 22, 23);
Ear_Spike_1st_Left.addBox(-0.5F, 0F, -1F, 1, 2, 2);
Ear_Spike_1st_Left.setRotationPoint(-6F, -7.5F, -2F);
Ear_Spike_1st_Left.setTextureSize(128, 64);
Ear_Spike_1st_Left.mirror = true;
setRotation(Ear_Spike_1st_Left, 0F, 0F, 0.3490659F);
PixelmonModelRenderer Ear_Spike_2nd_Left = new PixelmonModelRenderer(this, 22, 23);
Ear_Spike_2nd_Left.addBox(-0.5F, 0F, -1F, 1, 2, 2);
Ear_Spike_2nd_Left.setRotationPoint(-4F, -7F, -2F);
Ear_Spike_2nd_Left.setTextureSize(128, 64);
Ear_Spike_2nd_Left.mirror = true;
setRotation(Ear_Spike_2nd_Left, 0F, 0F, 0.3490659F);
PixelmonModelRenderer Ear_Base_Right = new PixelmonModelRenderer(this, 28, 23);
Ear_Base_Right.addBox(-4F, -1F, -1F, 4, 2, 2);
Ear_Base_Right.setRotationPoint(2F, -6.5F, -2F);
Ear_Base_Right.setTextureSize(128, 64);
Ear_Base_Right.mirror = true;
setRotation(Ear_Base_Right, 0F, 0F, 2.792527F);
PixelmonModelRenderer Ear_Tip_Right = new PixelmonModelRenderer(this, 28, 21);
Ear_Tip_Right.addBox(-3F, -0.5F, -0.5F, 4, 1, 1);
Ear_Tip_Right.setRotationPoint(6.3F, -7.8F, -2F);
Ear_Tip_Right.setTextureSize(128, 64);
Ear_Tip_Right.mirror = true;
setRotation(Ear_Tip_Right, 0F, 0F, -2.879793F);
PixelmonModelRenderer Ear_Spike_1st_Right = new PixelmonModelRenderer(this, 22, 23);
Ear_Spike_1st_Right.addBox(-0.5F, -2F, -1F, 1, 2, 2);
Ear_Spike_1st_Right.setRotationPoint(6F, -7.5F, -2F);
Ear_Spike_1st_Right.setTextureSize(128, 64);
Ear_Spike_1st_Right.mirror = true;
setRotation(Ear_Spike_1st_Right, 0F, 0F, 2.792527F);
PixelmonModelRenderer Ear_Spike_2nd_Right = new PixelmonModelRenderer(this, 22, 23);
Ear_Spike_2nd_Right.addBox(-0.5F, -2F, -1F, 1, 2, 2);
Ear_Spike_2nd_Right.setRotationPoint(4F, -7F, -2F);
Ear_Spike_2nd_Right.setTextureSize(128, 64);
Ear_Spike_2nd_Right.mirror = true;
setRotation(Ear_Spike_2nd_Right, 0F, 0F, 2.792527F);
Head.addChild(HeadMain);
Head.addChild(Neck);
Head.addChild(Head_Top);
Head.addChild(Head_Toppest);
Head.addChild(Head_Front);
Head.addChild(Head_Back);
Head.addChild(Ear_Base_Left);
Head.addChild(Ear_Tip_Left);
Head.addChild(Ear_Spike_1st_Left);
Head.addChild(Ear_Spike_2nd_Left);
Head.addChild(Ear_Base_Right);
Head.addChild(Ear_Tip_Right);
Head.addChild(Ear_Spike_1st_Right);
Head.addChild(Ear_Spike_2nd_Right);
Body.addChild(Head);
PixelmonModelRenderer LeftArm = new PixelmonModelRenderer(this, "Left Arm");
LeftArm.setRotationPoint(-6.5F, -0.5F, -0.5F);
PixelmonModelRenderer Shoulder_Left = new PixelmonModelRenderer(this, 60, 0);
Shoulder_Left.addBox(-1.5F, -2.5F, -1.5F, 3, 5, 3);
Shoulder_Left.setRotationPoint(-6.5F, 1.5F, -1.5F);
Shoulder_Left.setTextureSize(128, 64);
Shoulder_Left.mirror = true;
setRotation(Shoulder_Left, 0F, 0F, 0F);
PixelmonModelRenderer Shoulder_Left_Left = new PixelmonModelRenderer(this, 60, 8);
Shoulder_Left_Left.addBox(-1F, -2F, -2F, 1, 3, 3);
Shoulder_Left_Left.setRotationPoint(-1.5F, 0.5F, 0.5F);
Shoulder_Left_Left.setTextureSize(128, 64);
Shoulder_Left_Left.mirror = true;
setRotation(Shoulder_Left_Left, 0F, 0F, 0F);
PixelmonModelRenderer Shoulder_Left_Front = new PixelmonModelRenderer(this, 72, 0);
Shoulder_Left_Front.addBox(-1.5F, -1.5F, -1F, 3, 3, 1);
Shoulder_Left_Front.setRotationPoint(0F, 0F, -1.5F);
Shoulder_Left_Front.setTextureSize(128, 64);
Shoulder_Left_Front.mirror = true;
setRotation(Shoulder_Left_Front, 0F, 0F, 0F);
PixelmonModelRenderer Shoulder_Left_Right = new PixelmonModelRenderer(this, 68, 8);
Shoulder_Left_Right.addBox(1F, -1.5F, -1.5F, 1, 3, 3);
Shoulder_Left_Right.setRotationPoint(0.5F, 0F, 0F);
Shoulder_Left_Right.setTextureSize(128, 64);
Shoulder_Left_Right.mirror = true;
setRotation(Shoulder_Left_Right, 0F, 0F, 0F);
PixelmonModelRenderer Shoulder_Left_Back = new PixelmonModelRenderer(this, 72, 4);
Shoulder_Left_Back.addBox(-1.5F, -1.5F, 0F, 3, 3, 1);
Shoulder_Left_Back.setRotationPoint(0F, 0F, 1.5F);
Shoulder_Left_Back.setTextureSize(128, 64);
Shoulder_Left_Back.mirror = true;
setRotation(Shoulder_Left_Back, 0F, 0F, 0F);
PixelmonModelRenderer Arm_Left_Back = new PixelmonModelRenderer(this, 48, 14);
Arm_Left_Back.addBox(-0.5F, 0F, -0.5F, 1, 6, 1);
Arm_Left_Back.setRotationPoint(0.5F, 2F, 0.5F);
Arm_Left_Back.setTextureSize(128, 64);
Arm_Left_Back.mirror = true;
setRotation(Arm_Left_Back, -0.5235988F, 0F, 0.5235988F);
PixelmonModelRenderer Arm_Left_Middle = new PixelmonModelRenderer(this, 52, 14);
Arm_Left_Middle.addBox(-0.5F, 0F, -0.5F, 1, 6, 1);
Arm_Left_Middle.setRotationPoint(-1.8F, 6F, -2.5F);
Arm_Left_Middle.setTextureSize(128, 64);
Arm_Left_Middle.mirror = true;
setRotation(Arm_Left_Middle, -2.356194F, 0F, 0.5235988F);
PixelmonModelRenderer Palm_Left = new PixelmonModelRenderer(this, 28, 27);
Palm_Left.addBox(-1.5F, -3F, -1F, 3, 3, 2);
Palm_Left.setRotationPoint(0F, 2.5F, -6.5F);
Palm_Left.setTextureSize(128, 64);
Palm_Left.mirror = true;
setRotation(Palm_Left, 0F, 0F, 0.5235988F);
PixelmonModelRenderer Finger_1st_Left = new PixelmonModelRenderer(this, 24, 17);
Finger_1st_Left.addBox(-0.5F, -2F, -0.5F, 1, 2, 1);
Finger_1st_Left.setRotationPoint(1.5F, 1.5F, -7F);
Finger_1st_Left.setTextureSize(128, 64);
Finger_1st_Left.mirror = true;
setRotation(Finger_1st_Left, 0.2617994F, 0F, 2.094395F);
PixelmonModelRenderer Finger_2nd_Left = new PixelmonModelRenderer(this, 24, 17);
Finger_2nd_Left.addBox(-0.5F, -2F, -0.5F, 1, 2, 1);
Finger_2nd_Left.setRotationPoint(1.5F, 0.7F, -7F);
Finger_2nd_Left.setTextureSize(128, 64);
Finger_2nd_Left.mirror = true;
setRotation(Finger_2nd_Left, 0.2617994F, 0F, 1.047198F);
PixelmonModelRenderer Finger_3rd_Left = new PixelmonModelRenderer(this, 24, 17);
Finger_3rd_Left.addBox(-0.5F, -2F, -0.5F, 1, 2, 1);
Finger_3rd_Left.setRotationPoint(1F, 0.2F, -7F);
Finger_3rd_Left.setTextureSize(128, 64);
Finger_3rd_Left.mirror = true;
setRotation(Finger_3rd_Left, 0.2617994F, 0F, 0.5235988F);
PixelmonModelRenderer Finger_4th_Left = new PixelmonModelRenderer(this, 24, 17);
Finger_4th_Left.addBox(-0.5F, -2F, -0.5F, 1, 2, 1);
Finger_4th_Left.setRotationPoint(0.2F, 0F, -7F);
Finger_4th_Left.setTextureSize(128, 64);
Finger_4th_Left.mirror = true;
setRotation(Finger_4th_Left, 0.2617994F, 0F, 0F);
PixelmonModelRenderer Finger_5th_Left = new PixelmonModelRenderer(this, 24, 17);
Finger_5th_Left.addBox(-0.5F, -2F, -0.5F, 1, 2, 1);
Finger_5th_Left.setRotationPoint(0F, 0.5F, -7F);
Finger_5th_Left.setTextureSize(128, 64);
Finger_5th_Left.mirror = true;
setRotation(Finger_5th_Left, 0.2617994F, 0F, -1.047198F);
LeftArm.addChild(Shoulder_Left);
LeftArm.addChild(Shoulder_Left_Left);
LeftArm.addChild(Shoulder_Left_Front);
LeftArm.addChild(Shoulder_Left_Right);
LeftArm.addChild(Shoulder_Left_Back);
LeftArm.addChild(Arm_Left_Back);
LeftArm.addChild(Arm_Left_Middle);
LeftArm.addChild(Palm_Left);
LeftArm.addChild(Finger_1st_Left);
LeftArm.addChild(Finger_2nd_Left);
LeftArm.addChild(Finger_3rd_Left);
LeftArm.addChild(Finger_4th_Left);
LeftArm.addChild(Finger_5th_Left);
Body.addChild(LeftArm);
PixelmonModelRenderer RightArm = new PixelmonModelRenderer(this, "Right Arm");
RightArm.setRotationPoint(6.5F, -0.5F, -0.5F);
PixelmonModelRenderer Shoulder_Right = new PixelmonModelRenderer(this, 60, 0);
Shoulder_Right.addBox(-1.5F, -2.5F, -1.5F, 3, 5, 3);
Shoulder_Right.setTextureSize(128, 64);
Shoulder_Right.mirror = true;
setRotation(Shoulder_Right, 0F, 0F, 0F);
PixelmonModelRenderer Shoulder_Right_Left = new PixelmonModelRenderer(this, 68, 8);
Shoulder_Right_Left.addBox(-1F, -2F, -2F, 1, 3, 3);
Shoulder_Right_Left.setRotationPoint(-1.5F, 0.5F, .5F);
Shoulder_Right_Left.setTextureSize(128, 64);
Shoulder_Right_Left.mirror = true;
setRotation(Shoulder_Right_Left, 0F, 0F, 0F);
PixelmonModelRenderer Shoulder_Right_Right = new PixelmonModelRenderer(this, 60, 8);
Shoulder_Right_Right.addBox(0F, -2F, -2F, 1, 3, 3);
Shoulder_Right_Right.setRotationPoint(1.5F, 0.5F, 0.5F);
Shoulder_Right_Right.setTextureSize(128, 64);
Shoulder_Right_Right.mirror = true;
setRotation(Shoulder_Right_Right, 0F, 0F, 0F);
PixelmonModelRenderer Shoulder_Right_Front = new PixelmonModelRenderer(this, 72, 0);
Shoulder_Right_Front.addBox(-1.5F, -1.5F, -1F, 3, 3, 1);
Shoulder_Right_Front.setRotationPoint(0F, 0F, -1.5F);
Shoulder_Right_Front.setTextureSize(128, 64);
Shoulder_Right_Front.mirror = true;
setRotation(Shoulder_Right_Front, 0F, 0F, 0F);
PixelmonModelRenderer Shoulder_Right_Back = new PixelmonModelRenderer(this, 72, 4);
Shoulder_Right_Back.addBox(-1.5F, -1.5F, 0F, 3, 3, 1);
Shoulder_Right_Back.setRotationPoint(0F, 0F, 1.5F);
Shoulder_Right_Back.setTextureSize(128, 64);
Shoulder_Right_Back.mirror = true;
setRotation(Shoulder_Right_Back, 0F, 0F, 0F);
PixelmonModelRenderer Arm_Right_Back = new PixelmonModelRenderer(this, 48, 14);
Arm_Right_Back.addBox(-0.5F, 0F, -0.5F, 1, 6, 1);
Arm_Right_Back.setRotationPoint(-0.5F, 2F, 0.5F);
Arm_Right_Back.setTextureSize(128, 64);
Arm_Right_Back.mirror = true;
setRotation(Arm_Right_Back, -0.5235988F, 0F, -0.5410521F);
PixelmonModelRenderer Arm_Right_Middle = new PixelmonModelRenderer(this, 52, 14);
Arm_Right_Middle.addBox(-0.5F, 0F, -0.5F, 1, 6, 1);
Arm_Right_Middle.setRotationPoint(1.8F, 6F, -2.5F);
Arm_Right_Middle.setTextureSize(128, 64);
Arm_Right_Middle.mirror = true;
setRotation(Arm_Right_Middle, -2.356194F, 0F, -0.5235988F);
PixelmonModelRenderer Palm_Right = new PixelmonModelRenderer(this, 28, 27);
Palm_Right.addBox(-1.5F, -3F, -1F, 3, 3, 2);
Palm_Right.setRotationPoint(0F, 2.5F, -6.5F);
Palm_Right.setTextureSize(128, 64);
Palm_Right.mirror = true;
setRotation(Palm_Right, 0F, 0F, -0.5235988F);
PixelmonModelRenderer Finger_1st_Right = new PixelmonModelRenderer(this, 24, 17);
Finger_1st_Right.addBox(-0.5F, -2F, -0.5F, 1, 2, 1);
Finger_1st_Right.setRotationPoint(-1.5F, 1.5F, -7F);
Finger_1st_Right.setTextureSize(128, 64);
Finger_1st_Right.mirror = true;
setRotation(Finger_1st_Right, 0.2617994F, 0F, -2.094395F);
PixelmonModelRenderer Finger_2nd_Right = new PixelmonModelRenderer(this, 24, 17);
Finger_2nd_Right.addBox(-0.5F, -2F, -0.5F, 1, 2, 1);
Finger_2nd_Right.setRotationPoint(-1.5F, 0.7F, -7F);
Finger_2nd_Right.setTextureSize(128, 64);
Finger_2nd_Right.mirror = true;
setRotation(Finger_2nd_Right, 0.2617994F, 0F, -1.047198F);
PixelmonModelRenderer Finger_3rd_Right = new PixelmonModelRenderer(this, 24, 17);
Finger_3rd_Right.addBox(-0.5F, -2F, -0.5F, 1, 2, 1);
Finger_3rd_Right.setRotationPoint(-1F, 0.2F, -7F);
Finger_3rd_Right.setTextureSize(128, 64);
Finger_3rd_Right.mirror = true;
setRotation(Finger_3rd_Right, 0.2617994F, 0F, -0.5235988F);
PixelmonModelRenderer Finger_4th_Right = new PixelmonModelRenderer(this, 24, 17);
Finger_4th_Right.addBox(-0.5F, -2F, -0.5F, 1, 2, 1);
Finger_4th_Right.setRotationPoint(-0.2F, 0F, -7F);
Finger_4th_Right.setTextureSize(128, 64);
Finger_4th_Right.mirror = true;
setRotation(Finger_4th_Right, 0.2617994F, 0F, 0F);
PixelmonModelRenderer Finger_5th_Right = new PixelmonModelRenderer(this, 24, 17);
Finger_5th_Right.addBox(-0.5F, -2F, -0.5F, 1, 2, 1);
Finger_5th_Right.setRotationPoint(0F, 0.5F, -7F);
Finger_5th_Right.setTextureSize(128, 64);
Finger_5th_Right.mirror = true;
setRotation(Finger_5th_Right, 0.2617994F, 0F, 1.047198F);
RightArm.addChild(Shoulder_Right);
RightArm.addChild(Shoulder_Right_Left);
RightArm.addChild(Shoulder_Right_Right);
RightArm.addChild(Shoulder_Right_Front);
RightArm.addChild(Shoulder_Right_Back);
RightArm.addChild(Arm_Right_Back);
RightArm.addChild(Arm_Right_Middle);
RightArm.addChild(Palm_Right);
RightArm.addChild(Finger_1st_Right);
RightArm.addChild(Finger_2nd_Right);
RightArm.addChild(Finger_3rd_Right);
RightArm.addChild(Finger_4th_Right);
RightArm.addChild(Finger_5th_Right);
PixelmonModelRenderer LeftLeg = new PixelmonModelRenderer(this, "Left Leg");
LeftLeg.setRotationPoint(-5, 8, 0);
PixelmonModelRenderer Waist_Left = new PixelmonModelRenderer(this, 0, 50);
Waist_Left.addBox(-1F, -1F, -1F, 2, 4, 2);
Waist_Left.setTextureSize(128, 64);
Waist_Left.mirror = true;
setRotation(Waist_Left, 0F, 0F, 0F);
PixelmonModelRenderer Waist_Left_Back = new PixelmonModelRenderer(this, 0, 44);
Waist_Left_Back.addBox(-1F, -1F, 0F, 2, 2, 1);
Waist_Left_Back.setRotationPoint(0, 1F, 1F);
Waist_Left_Back.setTextureSize(128, 64);
Waist_Left_Back.mirror = true;
setRotation(Waist_Left_Back, 0F, 0F, 0F);
PixelmonModelRenderer Waist_Left_Front = new PixelmonModelRenderer(this, 0, 47);
Waist_Left_Front.addBox(-1F, -1F, -1F, 2, 2, 1);
Waist_Left_Front.setRotationPoint(0F, 1F, -1F);
Waist_Left_Front.setTextureSize(128, 64);
Waist_Left_Front.mirror = true;
setRotation(Waist_Left_Front, 0F, 0F, 0F);
PixelmonModelRenderer Waist_Left_Right = new PixelmonModelRenderer(this, 8, 48);
Waist_Left_Right.addBox(-1F, 0F, -1F, 1, 2, 2);
Waist_Left_Right.setRotationPoint(2F, 0F, 0F);
Waist_Left_Right.setTextureSize(128, 64);
Waist_Left_Right.mirror = true;
setRotation(Waist_Left_Right, 0F, 0F, 0F);
PixelmonModelRenderer Waist_Left_Left = new PixelmonModelRenderer(this, 8, 52);
Waist_Left_Left.addBox(-1F, 0F, -1F, 1, 2, 2);
Waist_Left_Left.setRotationPoint(-1F, 0F, 0F);
Waist_Left_Left.setTextureSize(128, 64);
Waist_Left_Left.mirror = true;
setRotation(Waist_Left_Left, 0F, 0F, 0F);
PixelmonModelRenderer Leg_Left_Top = new PixelmonModelRenderer(this, 36, 52);
Leg_Left_Top.addBox(-0.5F, 0F, -0.5F, 1, 6, 1);
Leg_Left_Top.setRotationPoint(0F, 2F, 0F);
Leg_Left_Top.setTextureSize(128, 64);
Leg_Left_Top.mirror = true;
setRotation(Leg_Left_Top, 0F, 0F, 0.2617994F);
PixelmonModelRenderer Leg_Left_Joint = new PixelmonModelRenderer(this, 40, 60);
Leg_Left_Joint.addBox(-1F, 0F, -1F, 2, 2, 2);
Leg_Left_Joint.setRotationPoint(-1.5F, 6F, 0F);
Leg_Left_Joint.setTextureSize(128, 64);
Leg_Left_Joint.mirror = true;
setRotation(Leg_Left_Joint, 0F, 0F, 0F);
PixelmonModelRenderer Leg_Left_Bottom = new PixelmonModelRenderer(this, 36, 59);
Leg_Left_Bottom.addBox(-0.5F, 0F, -0.5F, 1, 4, 1);
Leg_Left_Bottom.setRotationPoint(-1.5F, 8F, 0F);
Leg_Left_Bottom.setTextureSize(128, 64);
Leg_Left_Bottom.mirror = true;
setRotation(Leg_Left_Bottom, 0F, 0F, 0F);
PixelmonModelRenderer Feet_Left_Middle = new PixelmonModelRenderer(this, 0, 56);
Feet_Left_Middle.addBox(0F, 0F, 0F, 3, 2, 6);
Feet_Left_Middle.setRotationPoint(-3F, 12F, -4F);
Feet_Left_Middle.setTextureSize(128, 64);
Feet_Left_Middle.mirror = true;
setRotation(Feet_Left_Middle, 0F, 0F, 0F);
PixelmonModelRenderer Feet_Left_Front = new PixelmonModelRenderer(this, 18, 58);
Feet_Left_Front.addBox(-1F, -1F, 0F, 2, 2, 4);
Feet_Left_Front.setRotationPoint(-1.5F, 10F, -6F);
Feet_Left_Front.setTextureSize(128, 64);
Feet_Left_Front.mirror = true;
setRotation(Feet_Left_Front, -0.7853982F, 0F, 0F);
PixelmonModelRenderer Feet_Left_Top = new PixelmonModelRenderer(this, 30, 61);
Feet_Left_Top.addBox(-0.5F, -0.5F, 0F, 1, 1, 2);
Feet_Left_Top.setRotationPoint(-1.5F, 8.5F, -3.5F);
Feet_Left_Top.setTextureSize(128, 64);
Feet_Left_Top.mirror = true;
setRotation(Feet_Left_Top, -2.356194F, 0F, 0F);
PixelmonModelRenderer Feet_Left_Inner = new PixelmonModelRenderer(this, 30, 59);
Feet_Left_Inner.addBox(-0.5F, -0.5F, 0F, 1, 1, 1);
Feet_Left_Inner.setRotationPoint(-1.5F, 9F, -3F);
Feet_Left_Inner.setTextureSize(128, 64);
Feet_Left_Inner.mirror = true;
setRotation(Feet_Left_Inner, -2.356194F, 0F, 0F);
LeftLeg.addChild(Waist_Left);
LeftLeg.addChild(Waist_Left_Back);
LeftLeg.addChild(Waist_Left_Front);
LeftLeg.addChild(Waist_Left_Right);
LeftLeg.addChild(Waist_Left_Left);
LeftLeg.addChild(Leg_Left_Top);
LeftLeg.addChild(Leg_Left_Joint);
LeftLeg.addChild(Leg_Left_Bottom);
LeftLeg.addChild(Feet_Left_Middle);
LeftLeg.addChild(Feet_Left_Front);
LeftLeg.addChild(Feet_Left_Top);
LeftLeg.addChild(Feet_Left_Inner);
PixelmonModelRenderer RightLeg = new PixelmonModelRenderer(this, "Right Leg");
RightLeg.setRotationPoint(5, 8, 0);
PixelmonModelRenderer Waist_Right = new PixelmonModelRenderer(this, 0, 50);
Waist_Right.addBox(-1F, -1F, -1F, 2, 4, 2);
Waist_Right.setTextureSize(128, 64);
Waist_Right.mirror = true;
setRotation(Waist_Right, 0F, 0F, 0F);
PixelmonModelRenderer Waist_Right_Right = new PixelmonModelRenderer(this, 8, 52);
Waist_Right_Right.addBox(0F, 0F, -1F, 1, 2, 2);
Waist_Right_Right.setRotationPoint(1F, 0F, 0F);
Waist_Right_Right.setTextureSize(128, 64);
Waist_Right_Right.mirror = true;
setRotation(Waist_Right_Right, 0F, 0F, 0F);
PixelmonModelRenderer Waist_Right_Left = new PixelmonModelRenderer(this, 8, 48);
Waist_Right_Left.addBox(0F, 0F, -1F, 1, 2, 2);
Waist_Right_Left.setRotationPoint(-2F, 0F, 0F);
Waist_Right_Left.setTextureSize(128, 64);
Waist_Right_Left.mirror = true;
setRotation(Waist_Right_Left, 0F, 0F, 0F);
PixelmonModelRenderer Waist_Right_Front = new PixelmonModelRenderer(this, 0, 47);
Waist_Right_Front.addBox(-1F, -1F, -1F, 2, 2, 1);
Waist_Right_Front.setRotationPoint(0F, 1F, -1F);
Waist_Right_Front.setTextureSize(128, 64);
Waist_Right_Front.mirror = true;
setRotation(Waist_Right_Front, 0F, 0F, 0F);
PixelmonModelRenderer Waist_Right_Back = new PixelmonModelRenderer(this, 0, 44);
Waist_Right_Back.addBox(-1F, -1F, 0F, 2, 2, 1);
Waist_Right_Back.setRotationPoint(0F, 1F, 1F);
Waist_Right_Back.setTextureSize(128, 64);
Waist_Right_Back.mirror = true;
setRotation(Waist_Right_Back, 0F, 0F, 0F);
PixelmonModelRenderer Feet_Right_Inner = new PixelmonModelRenderer(this, 30, 59);
Feet_Right_Inner.addBox(-0.5F, -0.5F, 0F, 1, 1, 1);
Feet_Right_Inner.setRotationPoint(1.5F, 9F, -3F);
Feet_Right_Inner.setTextureSize(128, 64);
Feet_Right_Inner.mirror = true;
setRotation(Feet_Right_Inner, -2.356194F, 0F, 0F);
PixelmonModelRenderer Feet_Right_Top = new PixelmonModelRenderer(this, 30, 61);
Feet_Right_Top.addBox(-0.5F, -0.5F, 0F, 1, 1, 2);
Feet_Right_Top.setRotationPoint(1.5F, 8.5F, -3.5F);
Feet_Right_Top.setTextureSize(128, 64);
Feet_Right_Top.mirror = true;
setRotation(Feet_Right_Top, -2.356194F, 0F, 0F);
PixelmonModelRenderer Feet_Right_Front = new PixelmonModelRenderer(this, 18, 58);
Feet_Right_Front.addBox(-1F, -1F, 0F, 2, 2, 4);
Feet_Right_Front.setRotationPoint(1.5F, 10F, -6F);
Feet_Right_Front.setTextureSize(128, 64);
Feet_Right_Front.mirror = true;
setRotation(Feet_Right_Front, -0.7853982F, 0F, 0F);
PixelmonModelRenderer Feet_Right_Middle = new PixelmonModelRenderer(this, 0, 56);
Feet_Right_Middle.addBox(0F, 0F, 0F, 3, 2, 6);
Feet_Right_Middle.setRotationPoint(0F, 12F, -4F);
Feet_Right_Middle.setTextureSize(128, 64);
Feet_Right_Middle.mirror = true;
setRotation(Feet_Right_Middle, 0F, 0F, 0F);
PixelmonModelRenderer Leg_Right_Bottom = new PixelmonModelRenderer(this, 36, 59);
Leg_Right_Bottom.addBox(-0.5F, 0F, -0.5F, 1, 4, 1);
Leg_Right_Bottom.setRotationPoint(1.5F, 8F, 0F);
Leg_Right_Bottom.setTextureSize(128, 64);
Leg_Right_Bottom.mirror = true;
setRotation(Leg_Right_Bottom, 0F, 0F, 0F);
PixelmonModelRenderer Leg_Right_Joint = new PixelmonModelRenderer(this, 40, 60);
Leg_Right_Joint.addBox(-1F, 0F, -1F, 2, 2, 2);
Leg_Right_Joint.setRotationPoint(1.5F, 6F, 0F);
Leg_Right_Joint.setTextureSize(128, 64);
Leg_Right_Joint.mirror = true;
setRotation(Leg_Right_Joint, 0F, 0F, 0F);
PixelmonModelRenderer Leg_Right_Top = new PixelmonModelRenderer(this, 36, 52);
Leg_Right_Top.addBox(-0.5F, 0F, -0.5F, 1, 6, 1);
Leg_Right_Top.setRotationPoint(0F, 2F, 0F);
Leg_Right_Top.setTextureSize(128, 64);
Leg_Right_Top.mirror = true;
setRotation(Leg_Right_Top, 0F, 0F, -0.2617994F);
RightLeg.addChild(Waist_Right);
RightLeg.addChild(Waist_Right_Right);
RightLeg.addChild(Waist_Right_Left);
RightLeg.addChild(Waist_Right_Front);
RightLeg.addChild(Waist_Right_Back);
RightLeg.addChild(Feet_Right_Inner);
RightLeg.addChild(Feet_Right_Top);
RightLeg.addChild(Feet_Right_Front);
RightLeg.addChild(Feet_Right_Middle);
RightLeg.addChild(Leg_Right_Bottom);
RightLeg.addChild(Leg_Right_Joint);
RightLeg.addChild(Leg_Right_Top);
ModuleHead headModule = new ModuleHead(Head);
ModuleArm leftArmModule = new ModuleArm(LeftArm, EnumArm.Left);
ModuleArm rightArmModule = new ModuleArm(RightArm, EnumArm.Right);
float legspeed = 0.35F;
float legRotationLimit = 0.7F;
ModuleLeg leftLegModule =
new ModuleLeg(LeftLeg, EnumLeg.FrontLeft, EnumPhase.InPhase, legRotationLimit, legspeed);
ModuleLeg rightLegModule =
new ModuleLeg(RightLeg, EnumLeg.FrontRight, EnumPhase.InPhase, legRotationLimit, legspeed);
skeleton =
new SkeletonBiped(
Body, headModule, leftArmModule, rightArmModule, leftLegModule, rightLegModule);
}
public ModelZubat() {
textureWidth = 64;
textureHeight = 32;
Body = new PixelmonModelRenderer(this, "Body");
Body.setRotationPoint(-0.5F, 3, 3F);
Torso = new PixelmonModelRenderer(this, 22, 24);
Torso.addBox(-1.5F, -1.5F, -1.5F, 3, 3, 5);
Torso.setTextureSize(64, 32);
Torso.mirror = true;
setRotation(Torso, -0.8551081F, 0F, 0F);
Body.addChild(Torso);
PixelmonModelRenderer Head = new PixelmonModelRenderer(this, "Head");
Head.setRotationPoint(0, 0, 0F);
Face = new PixelmonModelRenderer(this, 0, 5);
Face.addBox(-1.5F, -3F, -3F, 3, 3, 3);
Face.setTextureSize(64, 32);
Face.mirror = true;
setRotation(Face, 0F, 0F, 0F);
Head.addChild(Face);
Left_Ear1 = new PixelmonModelRenderer(this, 45, 9);
Left_Ear1.addBox(0F, 0F, 0F, 2, 3, 1);
Left_Ear1.setRotationPoint(3.5F, -4F, -1F);
Left_Ear1.setTextureSize(64, 32);
Left_Ear1.mirror = true;
setRotation(Left_Ear1, 0F, 3.141593F, -0.6889403F);
Head.addChild(Left_Ear1);
Right_Ear1 = new PixelmonModelRenderer(this, 49, 9);
Right_Ear1.addBox(0F, 0F, 0F, 2, 3, 1);
Right_Ear1.setRotationPoint(-3.5F, -4F, -1F);
Right_Ear1.setTextureSize(64, 32);
Right_Ear1.mirror = true;
setRotation(Right_Ear1, 0F, 0F, -0.6889403F);
Head.addChild(Right_Ear1);
Body.addChild(Head);
PixelmonModelRenderer RightLeg = new PixelmonModelRenderer(this, "Right leg");
RightLeg.setRotationPoint(-0.5F, 2, 1);
Right_Leg = new PixelmonModelRenderer(this, 6, 17);
Right_Leg.addBox(-1F, 0F, 0F, 1, 5, 1);
Right_Leg.setTextureSize(64, 32);
Right_Leg.mirror = true;
setRotation(Right_Leg, 0.5576792F, -0.1487144F, 0F);
RightLeg.addChild(Right_Leg);
Body.addChild(RightLeg);
PixelmonModelRenderer LeftLeg = new PixelmonModelRenderer(this, "Left Leg");
LeftLeg.setRotationPoint(0.5F, 2, 1);
Left_Leg = new PixelmonModelRenderer(this, 8, 16);
Left_Leg.addBox(0F, 0F, 0F, 1, 5, 1);
Left_Leg.setTextureSize(64, 32);
Left_Leg.mirror = true;
setRotation(Left_Leg, 0.5576792F, 0.1464424F, 0F);
LeftLeg.addChild(Left_Leg);
Body.addChild(LeftLeg);
RightWing = new PixelmonModelRenderer(this, "Right Wing");
RightWing.setRotationPoint(-0.5F, 0, 0.5F);
WingR1 = new PixelmonModelRenderer(this, 15, 0);
WingR1.addBox(0F, 0F, -0.5F, 1, 8, 1);
WingR1.setTextureSize(64, 32);
WingR1.mirror = true;
setRotation(WingR1, 0F, 0F, 2.639681F);
RightWing.addChild(WingR1);
WingR2 = new PixelmonModelRenderer(this, 16, 0);
WingR2.addBox(0F, 0F, -0.5F, 1, 3, 1);
WingR2.setRotationPoint(-4F, -7F, 0F);
WingR2.setTextureSize(64, 32);
WingR2.mirror = true;
setRotation(WingR2, 0F, 0F, 1.041001F);
RightWing.addChild(WingR2);
WingR3 = new PixelmonModelRenderer(this, 16, 4);
WingR3.addBox(0F, 0F, -0.5F, 1, 7, 1);
WingR3.setRotationPoint(-6F, -6F, 0F);
WingR3.setTextureSize(64, 32);
WingR3.mirror = true;
setRotation(WingR3, 0F, 0F, 0.7807508F);
RightWing.addChild(WingR3);
WingRMid = new PixelmonModelRenderer(this, 15, 0);
WingRMid.addBox(0F, 0F, -0.5F, 1, 7, 1);
WingRMid.setRotationPoint(-5F, -6F, 0F);
WingRMid.setTextureSize(64, 32);
WingRMid.mirror = true;
setRotation(WingRMid, 0F, 0F, 0.1858931F);
RightWing.addChild(WingRMid);
WebbingR1 = new PixelmonModelRenderer(this, 27, 11);
WebbingR1.addBox(0F, 0F, -0.5F, 5, 5, 0);
WebbingR1.setRotationPoint(-4F, -6F, 0.5F);
WebbingR1.setTextureSize(64, 32);
WebbingR1.mirror = true;
setRotation(WebbingR1, 0F, 0F, 0.9666439F);
RightWing.addChild(WebbingR1);
WebbingR2 = new PixelmonModelRenderer(this, 27, 15);
WebbingR2.addBox(0F, 0F, -0.5F, 4, 3, 0);
WebbingR2.setRotationPoint(-8F, -4F, 0.5F);
WebbingR2.setTextureSize(64, 32);
WebbingR2.mirror = true;
setRotation(WebbingR2, 0F, 0F, 0.5576792F);
RightWing.addChild(WebbingR2);
Body.addChild(RightWing);
LeftWing = new PixelmonModelRenderer(this, "Left Wing");
LeftWing.setRotationPoint(0.5F, 0, 0.5F);
WingL1 = new PixelmonModelRenderer(this, 16, 0);
WingL1.addBox(-1F, 0F, -0.5F, 1, 8, 1);
WingL1.setTextureSize(64, 32);
WingL1.mirror = true;
setRotation(WingL1, 0F, 0F, -2.639681F);
LeftWing.addChild(WingL1);
WingL2 = new PixelmonModelRenderer(this, 21, 0);
WingL2.addBox(-1F, 0F, -1F, 1, 3, 1);
WingL2.setRotationPoint(4F, -7F, 0.5F);
WingL2.setTextureSize(64, 32);
WingL2.mirror = true;
setRotation(WingL2, 0F, 0F, -1.041001F);
LeftWing.addChild(WingL2);
WingL3 = new PixelmonModelRenderer(this, 10, 23);
WingL3.addBox(-1F, 0F, -1F, 1, 7, 1);
WingL3.setRotationPoint(6F, -6F, 0.5F);
WingL3.setTextureSize(64, 32);
WingL3.mirror = true;
setRotation(WingL3, 0F, 0F, -0.7807508F);
LeftWing.addChild(WingL3);
WingLMid = new PixelmonModelRenderer(this, 17, 0);
WingLMid.addBox(-1F, 0F, -1F, 1, 7, 1);
WingLMid.setRotationPoint(5F, -6F, 0.5F);
WingLMid.setTextureSize(64, 32);
WingLMid.mirror = true;
setRotation(WingLMid, 0F, 0, -0.1858931F);
LeftWing.addChild(WingLMid);
WebbingL1 = new PixelmonModelRenderer(this, 28, 15);
WebbingL1.addBox(0F, 0F, 0F, 5, 5, 0);
WebbingL1.setRotationPoint(4F, -6F, 0F);
WebbingL1.setTextureSize(64, 32);
WebbingL1.mirror = true;
setRotation(WebbingL1, 0F, 0F, 0.5576792F);
LeftWing.addChild(WebbingL1);
WebbingL2 = new PixelmonModelRenderer(this, 27, 16);
WebbingL2.addBox(0F, 0F, 0F, 4, 3, 0);
WebbingL2.setRotationPoint(4F, -2F, 0F);
WebbingL2.setTextureSize(64, 32);
WebbingL2.mirror = true;
setRotation(WebbingL2, 0F, 0F, -0.6320364F);
LeftWing.addChild(WebbingL2);
Body.addChild(LeftWing);
ModuleHead headModule = new ModuleHead(Head);
ModuleWing rightWingModule = new ModuleWing(RightWing, EnumWing.Right, 0, 0.25F, 1.3F);
ModuleWing leftWingModule = new ModuleWing(LeftWing, EnumWing.Left, 0, 0.25F, 1.3F);
skeleton =
new SkeletonBird(Body, headModule, leftWingModule, rightWingModule, LeftLeg, RightLeg);
}
public ModelEevee() {
textureWidth = 128;
textureHeight = 64;
Body = new PixelmonModelRenderer(this, "Body");
Body.setRotationPoint(0, 18, 0);
PixelmonModelRenderer body = new PixelmonModelRenderer(this, 0, 55);
body.addBox(-2F, -1F, -1F, 4, 4, 5);
body.setTextureSize(128, 64);
body.mirror = true;
setRotation(body, -0.0698132F, 0F, 0F);
PixelmonModelRenderer neck = new PixelmonModelRenderer(this, 0, 47);
neck.addBox(-1F, -0.8666667F, -2.2F, 2, 3, 3);
neck.setTextureSize(128, 64);
neck.mirror = true;
setRotation(neck, -0.9773844F, 0F, 0F);
PixelmonModelRenderer main_top = new PixelmonModelRenderer(this, 63, 0);
main_top.addBox(-2F, -1.333333F, -1.8F, 4, 4, 1);
main_top.setTextureSize(128, 64);
main_top.mirror = true;
setRotation(main_top, -0.6457718F, 0F, 0F);
PixelmonModelRenderer mane_front = new PixelmonModelRenderer(this, 63, 7);
mane_front.addBox(-2F, 1F, -1.666667F, 4, 3, 2);
mane_front.setTextureSize(128, 64);
mane_front.mirror = true;
setRotation(mane_front, -0.1047198F, 0F, 0F);
PixelmonModelRenderer mane_side_L = new PixelmonModelRenderer(this, 52, 6);
mane_side_L.addBox(1.8F, -2F, -1.133333F, 2, 4, 3);
mane_side_L.setTextureSize(128, 64);
mane_side_L.mirror = true;
setRotation(mane_side_L, -0.4537856F, 0.2094395F, 0.122173F);
PixelmonModelRenderer mane_side_R = new PixelmonModelRenderer(this, 59, 15);
mane_side_R.addBox(-3.8F, -2F, -1.1F, 2, 4, 3);
mane_side_R.setTextureSize(128, 64);
mane_side_R.mirror = true;
setRotation(mane_side_R, -0.4537856F, -0.2094395F, -0.122173F);
PixelmonModelRenderer back_mane = new PixelmonModelRenderer(this, 58, 24);
back_mane.addBox(-2.5F, -2.466667F, -0.9333333F, 5, 2, 2);
back_mane.setTextureSize(128, 64);
back_mane.mirror = true;
setRotation(back_mane, -0.4014257F, 0F, 0F);
PixelmonModelRenderer main_mane = new PixelmonModelRenderer(this, 0, 0);
main_mane.addBox(-3F, -2.133333F, -1.533333F, 6, 5, 3);
main_mane.setTextureSize(128, 64);
main_mane.mirror = true;
setRotation(main_mane, -0.5061455F, 0F, 0F);
Body.addChild(body);
Body.addChild(neck);
Body.addChild(main_top);
Body.addChild(mane_front);
Body.addChild(mane_side_L);
Body.addChild(mane_side_R);
Body.addChild(back_mane);
Body.addChild(main_mane);
PixelmonModelRenderer Head = new PixelmonModelRenderer(this, "Head");
Head.setRotationPoint(0, -1.8F, -2);
PixelmonModelRenderer head = new PixelmonModelRenderer(this, 0, 34);
head.addBox(-2.5F, -3.266667F, -2.2F, 5, 5, 4);
head.setTextureSize(128, 64);
head.mirror = true;
setRotation(head, -0.0349066F, 0F, 0F);
PixelmonModelRenderer snout = new PixelmonModelRenderer(this, 0, 26);
snout.addBox(-1.5F, -1.066667F, -3F, 3, 2, 3);
snout.setTextureSize(128, 64);
snout.mirror = true;
setRotation(snout, 0.4014257F, 0F, 0F);
PixelmonModelRenderer head_fur = new PixelmonModelRenderer(this, 11, 21);
head_fur.addBox(-2F, -4.8F, -0.9333333F, 4, 2, 1);
head_fur.setTextureSize(128, 64);
head_fur.mirror = true;
setRotation(head_fur, -0.122173F, 0F, 0F);
PixelmonModelRenderer ear_L = new PixelmonModelRenderer(this, 23, 27);
ear_L.addBox(0F, -9.266666F, -0.2666667F, 5, 7, 1);
ear_L.setTextureSize(128, 64);
ear_L.mirror = true;
setRotation(ear_L, -0.0349066F, -0.3141593F, 0.1745329F);
PixelmonModelRenderer ear_R = new PixelmonModelRenderer(this, 39, 27);
ear_R.addBox(-5F, -9.266666F, -0.3F, 5, 7, 1);
ear_R.setTextureSize(128, 64);
ear_R.mirror = true;
setRotation(ear_R, -0.0349066F, 0.3141593F, -0.1745329F);
Head.addChild(head);
Head.addChild(snout);
Head.addChild(head_fur);
Head.addChild(ear_L);
Head.addChild(ear_R);
PixelmonModelRenderer FLLeg = new PixelmonModelRenderer(this, "Front Left Leg");
FLLeg.setRotationPoint(2, 2, 0);
PixelmonModelRenderer front_leg_L = new PixelmonModelRenderer(this, 25, 0);
front_leg_L.addBox(-1.266667F, 0F, -1.133333F, 2, 4, 2);
front_leg_L.setTextureSize(128, 64);
front_leg_L.mirror = true;
setRotation(front_leg_L, 0F, 0F, 0F);
FLLeg.addChild(front_leg_L);
PixelmonModelRenderer FRLeg = new PixelmonModelRenderer(this, "Front Right Leg");
FRLeg.setRotationPoint(-2, 2, 0);
PixelmonModelRenderer front_leg_R = new PixelmonModelRenderer(this, 25, 0);
front_leg_R.addBox(-0.7F, 0F, -1.133333F, 2, 4, 2);
front_leg_R.setTextureSize(128, 64);
front_leg_R.mirror = true;
setRotation(front_leg_R, 0F, 0F, 0F);
FRLeg.addChild(front_leg_R);
PixelmonModelRenderer BLLeg = new PixelmonModelRenderer(this, "Back Left Leg");
BLLeg.setRotationPoint(2, 2, 3);
PixelmonModelRenderer L_leg_1 = new PixelmonModelRenderer(this, 35, 0);
L_leg_1.addBox(-1F, -1F, -1.733333F, 2, 3, 3);
L_leg_1.setTextureSize(128, 64);
L_leg_1.mirror = true;
setRotation(L_leg_1, -0.296706F, 0F, 0F);
PixelmonModelRenderer L_leg_2 = new PixelmonModelRenderer(this, 46, 0);
L_leg_2.addBox(-1.6F, 0.8666667F, -0.8F, 2, 3, 2);
L_leg_2.setTextureSize(128, 64);
L_leg_2.mirror = true;
setRotation(L_leg_2, -0.0349066F, 0F, 0F);
BLLeg.addChild(L_leg_1);
BLLeg.addChild(L_leg_2);
PixelmonModelRenderer BRLeg = new PixelmonModelRenderer(this, "Back Right Leg");
BRLeg.setRotationPoint(-2, 2, 3);
PixelmonModelRenderer _R_leg_1 = new PixelmonModelRenderer(this, 35, 0);
_R_leg_1.addBox(-1F, -1F, -1.733333F, 2, 3, 3);
_R_leg_1.setTextureSize(128, 64);
_R_leg_1.mirror = true;
setRotation(_R_leg_1, -0.296706F, 0F, 0F);
PixelmonModelRenderer R_leg_2 = new PixelmonModelRenderer(this, 46, 0);
R_leg_2.addBox(-0.6F, 0.8666667F, -0.8F, 2, 3, 2);
R_leg_2.setTextureSize(128, 64);
R_leg_2.mirror = true;
setRotation(R_leg_2, -0.0349066F, 0F, 0F);
BRLeg.addChild(_R_leg_1);
BRLeg.addChild(R_leg_2);
PixelmonModelRenderer Tail = new PixelmonModelRenderer(this, "Tail");
Tail.setRotationPoint(0, 0, 4);
PixelmonModelRenderer tail_1 = new PixelmonModelRenderer(this, 116, 0);
tail_1.addBox(-1.5F, -2F, -0.8666667F, 3, 4, 3);
tail_1.setTextureSize(128, 64);
tail_1.mirror = true;
setRotation(tail_1, 0.715585F, 0F, 0F);
PixelmonModelRenderer tail_2 = new PixelmonModelRenderer(this, 112, 8);
tail_2.addBox(-2.5F, -2.533333F, -9.992007E-16F, 5, 5, 3);
tail_2.setTextureSize(128, 64);
tail_2.mirror = true;
setRotation(tail_2, 0.6283185F, 0F, 0F);
PixelmonModelRenderer tail_3 = new PixelmonModelRenderer(this, 114, 18);
tail_3.addBox(-2F, -1.333333F, 2F, 4, 4, 3);
tail_3.setTextureSize(128, 64);
tail_3.mirror = true;
setRotation(tail_3, 0.9075712F, 0F, 0F);
PixelmonModelRenderer tail_4 = new PixelmonModelRenderer(this, 116, 27);
tail_4.addBox(-1.533333F, -0.6F, 2.8F, 3, 3, 3);
tail_4.setTextureSize(128, 64);
tail_4.mirror = true;
setRotation(tail_4, 1.029744F, 0F, 0F);
PixelmonModelRenderer tail_5 = new PixelmonModelRenderer(this, 120, 35);
tail_5.addBox(-1F, 0.5333334F, 4.6F, 2, 2, 2);
tail_5.setTextureSize(128, 64);
tail_5.mirror = true;
setRotation(tail_5, 1.22173F, 0F, 0F);
PixelmonModelRenderer tail_tip = new PixelmonModelRenderer(this, 101, 0);
tail_tip.addBox(-1F, 0.5333334F, 4.6F, 1, 4, 4);
tail_tip.setTextureSize(128, 64);
tail_tip.mirror = true;
setRotation(tail_tip, 1.37881F, 0F, 0F);
Tail.addChild(tail_1);
Tail.addChild(tail_2);
Tail.addChild(tail_3);
Tail.addChild(tail_4);
Tail.addChild(tail_5);
Tail.addChild(tail_tip);
Body.addChild(Head);
Body.addChild(FLLeg);
Body.addChild(FRLeg);
Body.addChild(BLLeg);
Body.addChild(BRLeg);
Body.addChild(Tail);
ModuleHead headModule = new ModuleHead(Head);
skeleton =
new SkeletonQuadruped(Body, headModule, FLLeg, FRLeg, BLLeg, BRLeg, 1.1f, 1.1f, 0.8f);
}
public ModelAerodactyl() {
textureWidth = 512;
textureHeight = 64;
Body = new PixelmonModelRenderer(this, "Body");
Body.setRotationPoint(0, 0, 0);
PixelmonModelRenderer Torso = new PixelmonModelRenderer(this, 124, 0);
Torso.addBox(-5F, 0F, 0F, 10, 19, 9);
Torso.setTextureSize(512, 64);
Torso.mirror = true;
setRotation(Torso, 1.22173F, 0F, 0F);
Body.addChild(Torso);
PixelmonModelRenderer Back_Spike = new PixelmonModelRenderer(this, 162, 0);
Back_Spike.addBox(-2F, 4F, 10F, 4, 6, 3);
Back_Spike.setTextureSize(512, 64);
Back_Spike.mirror = true;
setRotation(Back_Spike, 0.9599311F, 0F, 0F);
Body.addChild(Back_Spike);
PixelmonModelRenderer Back_Spike_2 = new PixelmonModelRenderer(this, 165, 9);
Back_Spike_2.addBox(-1F, 1F, 13F, 2, 1, 2);
Back_Spike_2.setTextureSize(512, 64);
Back_Spike_2.mirror = true;
setRotation(Back_Spike_2, 0.7853982F, 0F, 0F);
Body.addChild(Back_Spike_2);
PixelmonModelRenderer Back_Spike_3 = new PixelmonModelRenderer(this, 162, 12);
Back_Spike_3.addBox(-2F, 8F, 3F, 4, 6, 2);
Back_Spike_3.setTextureSize(512, 64);
Back_Spike_3.mirror = true;
setRotation(Back_Spike_3, 1.919862F, 0F, 0F);
Body.addChild(Back_Spike_3);
PixelmonModelRenderer Stomach_Helper_2 = new PixelmonModelRenderer(this, 124, 28);
Stomach_Helper_2.addBox(-4F, 14F, -8F, 8, 2, 1);
Stomach_Helper_2.setTextureSize(512, 64);
Stomach_Helper_2.mirror = true;
setRotation(Stomach_Helper_2, 1.745329F, 0F, 0F);
Body.addChild(Stomach_Helper_2);
PixelmonModelRenderer Stomach_Rounder = new PixelmonModelRenderer(this, 124, 31);
Stomach_Rounder.addBox(-4F, 5F, 0F, 8, 12, 1);
Stomach_Rounder.setTextureSize(512, 64);
Stomach_Rounder.mirror = true;
setRotation(Stomach_Rounder, 1.22173F, 0F, 0F);
Body.addChild(Stomach_Rounder);
PixelmonModelRenderer Stomach_Helper = new PixelmonModelRenderer(this, 124, 44);
Stomach_Helper.addBox(-4F, 3F, 2F, 8, 2, 1);
Stomach_Helper.setTextureSize(512, 64);
Stomach_Helper.mirror = true;
setRotation(Stomach_Helper, 0.8203047F, 0F, 0F);
Body.addChild(Stomach_Helper);
PixelmonModelRenderer Side_Rounder = new PixelmonModelRenderer(this, 142, 28);
Side_Rounder.addBox(-6F, 3F, 4F, 12, 13, 3);
Side_Rounder.setTextureSize(512, 64);
Side_Rounder.mirror = true;
setRotation(Side_Rounder, 1.22173F, 0F, 0F);
Body.addChild(Side_Rounder);
PixelmonModelRenderer Head = new PixelmonModelRenderer(this, "Head");
Head.setRotationPoint(0, -6, 3);
PixelmonModelRenderer Lower_Lip = new PixelmonModelRenderer(this, 50, 61);
Lower_Lip.addBox(-3F, -5F, -16F, 6, 2, 1);
Lower_Lip.setTextureSize(512, 64);
Lower_Lip.mirror = true;
setRotation(Lower_Lip, 0.5235988F, 0F, 0F);
Head.addChild(Lower_Lip);
PixelmonModelRenderer Bottom_Mouth = new PixelmonModelRenderer(this, 40, 48);
Bottom_Mouth.addBox(-3F, -4F, -16F, 6, 2, 11);
Bottom_Mouth.setTextureSize(512, 64);
Bottom_Mouth.mirror = true;
setRotation(Bottom_Mouth, 0.4886922F, 0F, 0F);
Head.addChild(Bottom_Mouth);
PixelmonModelRenderer Chin = new PixelmonModelRenderer(this, 48, 40);
Chin.addBox(-2F, -2F, -11F, 4, 2, 6);
Chin.setTextureSize(512, 64);
Chin.mirror = true;
setRotation(Chin, 0.3316126F, 0F, 0F);
Head.addChild(Chin);
PixelmonModelRenderer Mouth_Back = new PixelmonModelRenderer(this, 52, 34);
Mouth_Back.addBox(-2F, -2F, -9F, 4, 5, 1);
Mouth_Back.setTextureSize(512, 64);
Mouth_Back.mirror = true;
setRotation(Mouth_Back, -0.0872665F, 0F, 0F);
Head.addChild(Mouth_Back);
PixelmonModelRenderer Side_Lip = new PixelmonModelRenderer(this, 24, 40);
Side_Lip.addBox(5F, -3F, 2F, 11, 2, 1);
Side_Lip.setTextureSize(512, 64);
Side_Lip.mirror = true;
setRotation(Side_Lip, 0F, 1.570796F, 0.418879F);
Head.addChild(Side_Lip);
PixelmonModelRenderer Side_Lip_2 = new PixelmonModelRenderer(this, 68, 40);
Side_Lip_2.addBox(5F, -3F, -3F, 11, 2, 1);
Side_Lip_2.setTextureSize(512, 64);
Side_Lip_2.mirror = true;
setRotation(Side_Lip_2, 0F, 1.58825F, 0.4014257F);
Head.addChild(Side_Lip_2);
PixelmonModelRenderer Tongue = new PixelmonModelRenderer(this, 6, 0);
Tongue.addBox(-1F, -4.2F, -14F, 2, 1, 6);
Tongue.setTextureSize(512, 64);
Tongue.mirror = true;
setRotation(Tongue, 0.4886922F, 0F, 0F);
Head.addChild(Tongue);
PixelmonModelRenderer Tongue2 = new PixelmonModelRenderer(this, 6, 0);
Tongue2.addBox(-0.5F, -4.2F, -14.46667F, 1, 1, 2);
Tongue2.setTextureSize(512, 64);
Tongue2.mirror = true;
setRotation(Tongue2, 0.4886922F, 0F, 0F);
Head.addChild(Tongue2);
PixelmonModelRenderer Tooth_L1 = new PixelmonModelRenderer(this, 46, 43);
Tooth_L1.addBox(-2F, 1F, -11F, 0, 1, 1);
Tooth_L1.setTextureSize(512, 64);
Tooth_L1.mirror = true;
setRotation(Tooth_L1, -0.0174533F, 0F, 0F);
Head.addChild(Tooth_L1);
PixelmonModelRenderer Tooth_L2 = new PixelmonModelRenderer(this, 44, 43);
Tooth_L2.addBox(-2F, 2F, -11F, 0, 1, 1);
Tooth_L2.setTextureSize(512, 64);
Tooth_L2.mirror = true;
setRotation(Tooth_L2, -0.0698132F, 0F, 0F);
Head.addChild(Tooth_L2);
PixelmonModelRenderer Tooth_L3 = new PixelmonModelRenderer(this, 42, 43);
Tooth_L3.addBox(-2F, 4F, -12F, 0, 1, 1);
Tooth_L3.setTextureSize(512, 64);
Tooth_L3.mirror = true;
setRotation(Tooth_L3, -0.1919862F, 0F, 0F);
Head.addChild(Tooth_L3);
PixelmonModelRenderer Tooth_L4 = new PixelmonModelRenderer(this, 40, 43);
Tooth_L4.addBox(-2F, 0.5F, -12F, 0, 1, 1);
Tooth_L4.setTextureSize(512, 64);
Tooth_L4.mirror = true;
setRotation(Tooth_L4, 0.0698132F, 0F, 0F);
Head.addChild(Tooth_L4);
PixelmonModelRenderer Tooth_L5 = new PixelmonModelRenderer(this, 38, 43);
Tooth_L5.addBox(-2F, 3.5F, -13F, 0, 1, 1);
Tooth_L5.setTextureSize(512, 64);
Tooth_L5.mirror = true;
setRotation(Tooth_L5, -0.122173F, -0.0174533F, 0F);
Head.addChild(Tooth_L5);
PixelmonModelRenderer Tooth_L6 = new PixelmonModelRenderer(this, 36, 43);
Tooth_L6.addBox(-2F, 5F, -14F, 0, 1, 1);
Tooth_L6.setTextureSize(512, 64);
Tooth_L6.mirror = true;
setRotation(Tooth_L6, -0.1745329F, -0.0174533F, 0F);
Head.addChild(Tooth_L6);
PixelmonModelRenderer Tooth_L7 = new PixelmonModelRenderer(this, 34, 43);
Tooth_L7.addBox(-2F, 4.5F, -15F, 0, 1, 1);
Tooth_L7.setTextureSize(512, 64);
Tooth_L7.mirror = true;
setRotation(Tooth_L7, -0.1047198F, -0.0523599F, 0F);
Head.addChild(Tooth_L7);
PixelmonModelRenderer Tooth_R1 = new PixelmonModelRenderer(this, 68, 43);
Tooth_R1.addBox(2F, 1F, -11F, 0, 1, 1);
Tooth_R1.setTextureSize(512, 64);
Tooth_R1.mirror = true;
setRotation(Tooth_R1, -0.0174533F, 0F, 0F);
Head.addChild(Tooth_R1);
PixelmonModelRenderer Tooth_R4 = new PixelmonModelRenderer(this, 70, 43);
Tooth_R4.addBox(2F, 1F, -13F, 0, 1, 1);
Tooth_R4.setTextureSize(512, 64);
Tooth_R4.mirror = true;
setRotation(Tooth_R4, 0.0698132F, 0F, 0F);
Head.addChild(Tooth_R4);
PixelmonModelRenderer Tooth_R2 = new PixelmonModelRenderer(this, 72, 43);
Tooth_R2.addBox(2F, 2F, -12F, 0, 1, 1);
Tooth_R2.setTextureSize(512, 64);
Tooth_R2.mirror = true;
setRotation(Tooth_R2, -0.0698132F, 0F, 0F);
Head.addChild(Tooth_R2);
PixelmonModelRenderer Tooth_R3 = new PixelmonModelRenderer(this, 74, 43);
Tooth_R3.addBox(2F, 4F, -12F, 0, 1, 1);
Tooth_R3.setTextureSize(512, 64);
Tooth_R3.mirror = true;
setRotation(Tooth_R3, -0.1919862F, 0F, 0F);
Head.addChild(Tooth_R3);
PixelmonModelRenderer Tooth_R5 = new PixelmonModelRenderer(this, 76, 43);
Tooth_R5.addBox(2F, 3.7F, -13.2F, 0, 1, 1);
Tooth_R5.setTextureSize(512, 64);
Tooth_R5.mirror = true;
setRotation(Tooth_R5, -0.122173F, 0.0174533F, 0F);
Head.addChild(Tooth_R5);
PixelmonModelRenderer Tooth_R6 = new PixelmonModelRenderer(this, 78, 43);
Tooth_R6.addBox(2F, 5F, -14F, 0, 1, 1);
Tooth_R6.setTextureSize(512, 64);
Tooth_R6.mirror = true;
setRotation(Tooth_R6, -0.1745329F, 0.0174533F, 0F);
Head.addChild(Tooth_R6);
PixelmonModelRenderer Tooth_R7 = new PixelmonModelRenderer(this, 80, 43);
Tooth_R7.addBox(2F, 4.5F, -15F, 0, 1, 1);
Tooth_R7.setTextureSize(512, 64);
Tooth_R7.mirror = true;
setRotation(Tooth_R7, -0.1047198F, 0.0523599F, 0F);
Head.addChild(Tooth_R7);
PixelmonModelRenderer Horn_1 = new PixelmonModelRenderer(this, 64, 0);
Horn_1.addBox(-5F, -5F, -8F, 1, 6, 1);
Horn_1.setTextureSize(512, 64);
Horn_1.mirror = true;
setRotation(Horn_1, -0.9599311F, -0.4363323F, 0F);
Head.addChild(Horn_1);
PixelmonModelRenderer Horn_2 = new PixelmonModelRenderer(this, 46, 0);
Horn_2.addBox(4F, -5F, -8F, 1, 6, 1);
Horn_2.setTextureSize(512, 64);
Horn_2.mirror = true;
setRotation(Horn_2, -0.9599311F, 0.4363323F, 0F);
Head.addChild(Horn_2);
PixelmonModelRenderer Lower_Skull = new PixelmonModelRenderer(this, 47, 10);
Lower_Skull.addBox(-3F, 3F, -4F, 6, 7, 4);
Lower_Skull.setTextureSize(512, 64);
Lower_Skull.mirror = true;
setRotation(Lower_Skull, -1.832596F, 0F, 0F);
Head.addChild(Lower_Skull);
PixelmonModelRenderer Upper_Skull = new PixelmonModelRenderer(this, 50, 0);
Upper_Skull.addBox(-2F, 3F, -6F, 4, 7, 3);
Upper_Skull.setTextureSize(512, 64);
Upper_Skull.mirror = true;
setRotation(Upper_Skull, -1.53589F, 0F, 0F);
Head.addChild(Upper_Skull);
PixelmonModelRenderer Eyebrow_R = new PixelmonModelRenderer(this, 0, 0);
Eyebrow_R.addBox(-3.1F, -6F, -8F, 1, 1, 2);
Eyebrow_R.setTextureSize(512, 64);
Eyebrow_R.mirror = true;
setRotation(Eyebrow_R, 0.0523599F, 0F, 0F);
Head.addChild(Eyebrow_R);
PixelmonModelRenderer Eyebrow_L = new PixelmonModelRenderer(this, 0, 0);
Eyebrow_L.addBox(2.1F, -6F, -8F, 1, 1, 2);
Eyebrow_L.setTextureSize(512, 64);
Eyebrow_L.mirror = true;
setRotation(Eyebrow_L, 0.0523599F, 0F, 0F);
Head.addChild(Eyebrow_L);
PixelmonModelRenderer Upper_Lip = new PixelmonModelRenderer(this, 42, 21);
Upper_Lip.addBox(-2F, 1F, -17F, 4, 2, 11);
Upper_Lip.setTextureSize(512, 64);
Upper_Lip.mirror = true;
setRotation(Upper_Lip, -0.4014257F, 0F, 0F);
Head.addChild(Upper_Lip);
PixelmonModelRenderer Snout = new PixelmonModelRenderer(this, 30, 30);
Snout.addBox(-2F, 1F, -18F, 4, 2, 2);
Snout.setTextureSize(512, 64);
Snout.mirror = true;
setRotation(Snout, -0.3665191F, 0F, 0F);
Head.addChild(Snout);
PixelmonModelRenderer Nose_Bridge = new PixelmonModelRenderer(this, 72, 22);
Nose_Bridge.addBox(-1F, 0.5F, -17F, 2, 1, 11);
Nose_Bridge.setTextureSize(512, 64);
Nose_Bridge.mirror = true;
setRotation(Nose_Bridge, -0.3839724F, 0F, 0F);
Head.addChild(Nose_Bridge);
PixelmonModelRenderer Lower_Neck = new PixelmonModelRenderer(this, 0, 14);
Lower_Neck.addBox(-2F, 0F, -8F, 4, 3, 10);
Lower_Neck.setTextureSize(512, 64);
Lower_Neck.mirror = true;
setRotation(Lower_Neck, -0.6806784F, 0F, 0F);
Head.addChild(Lower_Neck);
PixelmonModelRenderer Upper_Neck = new PixelmonModelRenderer(this, 0, 27);
Upper_Neck.addBox(-2F, -1F, -8F, 4, 3, 10);
Upper_Neck.setTextureSize(512, 64);
Upper_Neck.mirror = true;
setRotation(Upper_Neck, -0.296706F, 0F, 0F);
Head.addChild(Upper_Neck);
Body.addChild(Head);
LeftWing = new PixelmonModelRenderer(this, "Left Wing");
LeftWing.setRotationPoint(4, -8, 4);
PixelmonModelRenderer First_Left_Wing_Bone = new PixelmonModelRenderer(this, 219, 23);
First_Left_Wing_Bone.addBox(-1F, 0F, 0F, 1, 10, 1);
First_Left_Wing_Bone.setTextureSize(512, 64);
First_Left_Wing_Bone.mirror = true;
setRotation(First_Left_Wing_Bone, 0.0349066F, 0F, -1.570796F);
LeftWing.addChild(First_Left_Wing_Bone);
PixelmonModelRenderer First_Left_Folds = new PixelmonModelRenderer(this, 178, 33);
First_Left_Folds.addBox(-8F, 1F, 1F, 7, 0, 12);
First_Left_Folds.setTextureSize(512, 64);
First_Left_Folds.mirror = true;
setRotation(First_Left_Folds, 0F, 1.570796F, 0F);
LeftWing.addChild(First_Left_Folds);
PixelmonModelRenderer Second_Left_Wing_Bone = new PixelmonModelRenderer(this, 224, 24);
Second_Left_Wing_Bone.addBox(6.5F, 0F, -15.5F, 1, 1, 9);
Second_Left_Wing_Bone.setTextureSize(512, 64);
Second_Left_Wing_Bone.mirror = true;
setRotation(Second_Left_Wing_Bone, 0F, -0.8726646F, 0F);
LeftWing.addChild(Second_Left_Wing_Bone);
PixelmonModelRenderer Second_Left_Folds = new PixelmonModelRenderer(this, 216, 34);
Second_Left_Folds.addBox(7F, 1F, -16F, 7, 0, 11);
Second_Left_Folds.setTextureSize(512, 64);
Second_Left_Folds.mirror = true;
setRotation(Second_Left_Folds, 0F, -0.8726646F, 0F);
LeftWing.addChild(Second_Left_Folds);
PixelmonModelRenderer _Left_Palm = new PixelmonModelRenderer(this, 187, 45);
_Left_Palm.addBox(7F, 0F, -16F, 1, 1, 1);
_Left_Palm.setTextureSize(512, 64);
_Left_Palm.mirror = true;
setRotation(_Left_Palm, 0F, -0.837758F, 0F);
LeftWing.addChild(_Left_Palm);
PixelmonModelRenderer _Left_Finger = new PixelmonModelRenderer(this, 183, 45);
_Left_Finger.addBox(6F, 0F, -16F, 1, 2, 1);
_Left_Finger.setTextureSize(512, 64);
_Left_Finger.mirror = true;
setRotation(_Left_Finger, 0F, -0.8726646F, -0.0349066F);
LeftWing.addChild(_Left_Finger);
PixelmonModelRenderer _Left_Finger_2 = new PixelmonModelRenderer(this, 191, 45);
_Left_Finger_2.addBox(6F, 1F, -17F, 1, 2, 1);
_Left_Finger_2.setTextureSize(512, 64);
_Left_Finger_2.mirror = true;
setRotation(_Left_Finger_2, -0.0174533F, -0.8726646F, -0.1047198F);
LeftWing.addChild(_Left_Finger_2);
PixelmonModelRenderer _Left_Finger_3 = new PixelmonModelRenderer(this, 187, 47);
_Left_Finger_3.addBox(7F, 2F, -17F, 1, 2, 1);
_Left_Finger_3.setTextureSize(512, 64);
_Left_Finger_3.mirror = true;
setRotation(_Left_Finger_3, 0F, -0.8552113F, -0.296706F);
LeftWing.addChild(_Left_Finger_3);
PixelmonModelRenderer Third_Left_Wing_Bone = new PixelmonModelRenderer(this, 243, 23);
Third_Left_Wing_Bone.addBox(8F, 0F, 15F, 1, 1, 10);
Third_Left_Wing_Bone.setTextureSize(512, 64);
Third_Left_Wing_Bone.mirror = true;
setRotation(Third_Left_Wing_Bone, 0F, 1.308997F, 0F);
LeftWing.addChild(Third_Left_Wing_Bone);
PixelmonModelRenderer Third_Left_Folds = new PixelmonModelRenderer(this, 252, 34);
Third_Left_Folds.addBox(3F, 1F, 15F, 6, 0, 11);
Third_Left_Folds.setTextureSize(512, 64);
Third_Left_Folds.mirror = true;
setRotation(Third_Left_Folds, 0F, 1.308997F, 0F);
LeftWing.addChild(Third_Left_Folds);
PixelmonModelRenderer Third_Left_Upper_Folds = new PixelmonModelRenderer(this, 252, 45);
Third_Left_Upper_Folds.addBox(3F, 0.9F, 15F, 6, 0, 11);
Third_Left_Upper_Folds.setTextureSize(512, 64);
Third_Left_Upper_Folds.mirror = true;
setRotation(Third_Left_Upper_Folds, 0F, 1.308997F, 0F);
LeftWing.addChild(Third_Left_Upper_Folds);
Body.addChild(LeftWing);
RightWing = new PixelmonModelRenderer(this, "Right Wing");
RightWing.setRotationPoint(-4, -8, 4);
PixelmonModelRenderer First_Right_Folds = new PixelmonModelRenderer(this, 178, 0);
First_Right_Folds.addBox(1F, 1F, 1F, 7, 0, 12);
First_Right_Folds.setTextureSize(512, 64);
First_Right_Folds.mirror = true;
setRotation(First_Right_Folds, 0F, -1.570796F, 0F);
RightWing.addChild(First_Right_Folds);
PixelmonModelRenderer First_Right_Wing_Bone = new PixelmonModelRenderer(this, 176, 12);
First_Right_Wing_Bone.addBox(0F, 0F, 0F, 1, 10, 1);
First_Right_Wing_Bone.setTextureSize(512, 64);
First_Right_Wing_Bone.mirror = true;
setRotation(First_Right_Wing_Bone, 0.0349066F, 0F, 1.570796F);
RightWing.addChild(First_Right_Wing_Bone);
PixelmonModelRenderer Second_Right_Wing_Bone = new PixelmonModelRenderer(this, 180, 12);
Second_Right_Wing_Bone.addBox(-7.5F, 0F, -15.5F, 1, 1, 9);
Second_Right_Wing_Bone.setTextureSize(512, 64);
Second_Right_Wing_Bone.mirror = true;
setRotation(Second_Right_Wing_Bone, 0F, 0.8726646F, 0F);
RightWing.addChild(Second_Right_Wing_Bone);
PixelmonModelRenderer Second_Right_Folds = new PixelmonModelRenderer(this, 216, 0);
Second_Right_Folds.addBox(-13.5F, 1F, -15.5F, 7, 0, 11);
Second_Right_Folds.setTextureSize(512, 64);
Second_Right_Folds.mirror = true;
setRotation(Second_Right_Folds, 0F, 0.8726646F, 0F);
RightWing.addChild(Second_Right_Folds);
PixelmonModelRenderer Right_Palm = new PixelmonModelRenderer(this, 188, 22);
Right_Palm.addBox(-8F, 0F, -16F, 1, 1, 1);
Right_Palm.setTextureSize(512, 64);
Right_Palm.mirror = true;
setRotation(Right_Palm, 0F, 0.837758F, 0F);
RightWing.addChild(Right_Palm);
PixelmonModelRenderer Right_Finger = new PixelmonModelRenderer(this, 184, 22);
Right_Finger.addBox(-7F, 0.5F, -16F, 1, 2, 1);
Right_Finger.setTextureSize(512, 64);
Right_Finger.mirror = true;
setRotation(Right_Finger, 0F, 0.8726646F, 0.0349066F);
RightWing.addChild(Right_Finger);
PixelmonModelRenderer Right_Finger_2 = new PixelmonModelRenderer(this, 188, 24);
Right_Finger_2.addBox(-7F, 1.5F, -17F, 1, 2, 1);
Right_Finger_2.setTextureSize(512, 64);
Right_Finger_2.mirror = true;
setRotation(Right_Finger_2, 0F, 0.8726646F, 0.1570796F);
RightWing.addChild(Right_Finger_2);
PixelmonModelRenderer Right_Finger_3 = new PixelmonModelRenderer(this, 192, 22);
Right_Finger_3.addBox(-7.5F, 2F, -17F, 1, 2, 1);
Right_Finger_3.setTextureSize(512, 64);
Right_Finger_3.mirror = true;
setRotation(Right_Finger_3, 0F, 0.8726646F, 0.296706F);
RightWing.addChild(Right_Finger_3);
PixelmonModelRenderer Third_Right_Wing_Bone = new PixelmonModelRenderer(this, 200, 12);
Third_Right_Wing_Bone.addBox(-9F, 0F, 14F, 1, 1, 10);
Third_Right_Wing_Bone.setTextureSize(512, 64);
Third_Right_Wing_Bone.mirror = true;
setRotation(Third_Right_Wing_Bone, 0F, -1.308997F, 0F);
RightWing.addChild(Third_Right_Wing_Bone);
PixelmonModelRenderer Third_Right_Folds = new PixelmonModelRenderer(this, 252, 34);
Third_Right_Folds.addBox(-9F, 1F, 14F, 6, 0, 11);
Third_Right_Folds.setTextureSize(512, 64);
Third_Right_Folds.mirror = true;
setRotation(Third_Right_Folds, 0F, -1.308997F, 0F);
RightWing.addChild(Third_Right_Folds);
PixelmonModelRenderer Third_Right_Upper_Folds = new PixelmonModelRenderer(this, 252, 45);
Third_Right_Upper_Folds.addBox(-9F, 0.9F, 14F, 6, 0, 11);
Third_Right_Upper_Folds.setTextureSize(512, 64);
Third_Right_Upper_Folds.mirror = true;
setRotation(Third_Right_Upper_Folds, 0F, -1.308997F, 0F);
RightWing.addChild(Third_Right_Upper_Folds);
Body.addChild(RightWing);
PixelmonModelRenderer RightLeg = new PixelmonModelRenderer(this, "Right Leg");
RightLeg.setRotationPoint(-4, 3, 17);
PixelmonModelRenderer Right_Claw_3 = new PixelmonModelRenderer(this, 365, 18);
Right_Claw_3.addBox(-1.5F, 7F, 3F, 1, 3, 1);
Right_Claw_3.setTextureSize(512, 64);
Right_Claw_3.mirror = true;
setRotation(Right_Claw_3, -0.6108652F, 0.0872665F, 0.6632251F);
RightLeg.addChild(Right_Claw_3);
PixelmonModelRenderer Right_Thigh = new PixelmonModelRenderer(this, 353, 0);
Right_Thigh.addBox(-1F, 0F, -2F, 2, 7, 3);
Right_Thigh.setTextureSize(512, 64);
Right_Thigh.mirror = true;
setRotation(Right_Thigh, -0.6108652F, 0F, 0.6981317F);
RightLeg.addChild(Right_Thigh);
PixelmonModelRenderer Right_Lower_Leg = new PixelmonModelRenderer(this, 353, 10);
Right_Lower_Leg.addBox(-1F, 6F, -2F, 2, 2, 6);
Right_Lower_Leg.setTextureSize(512, 64);
Right_Lower_Leg.mirror = true;
setRotation(Right_Lower_Leg, -0.6108652F, 0F, 0.6981317F);
RightLeg.addChild(Right_Lower_Leg);
PixelmonModelRenderer Right_Claw_2 = new PixelmonModelRenderer(this, 359, 18);
Right_Claw_2.addBox(0.5F, 7F, 3F, 1, 3, 1);
Right_Claw_2.setTextureSize(512, 64);
Right_Claw_2.mirror = true;
setRotation(Right_Claw_2, -0.6108652F, 0.0872665F, 0.7330383F);
RightLeg.addChild(Right_Claw_2);
PixelmonModelRenderer Right_Claw_1 = new PixelmonModelRenderer(this, 353, 18);
Right_Claw_1.addBox(-0.5F, 4F, 3F, 1, 3, 1);
Right_Claw_1.setTextureSize(512, 64);
Right_Claw_1.mirror = true;
setRotation(Right_Claw_1, -0.6108652F, 0.0872665F, 0.6981317F);
RightLeg.addChild(Right_Claw_1);
Body.addChild(RightLeg);
PixelmonModelRenderer LeftLeg = new PixelmonModelRenderer(this, "Left Leg");
LeftLeg.setRotationPoint(4, 3, 17);
PixelmonModelRenderer Left_Thigh = new PixelmonModelRenderer(this, 316, 0);
Left_Thigh.addBox(-1F, 0F, -2F, 2, 7, 3);
Left_Thigh.setTextureSize(512, 64);
Left_Thigh.mirror = true;
setRotation(Left_Thigh, -0.6108652F, 0F, -0.6981317F);
LeftLeg.addChild(Left_Thigh);
PixelmonModelRenderer Left_Lower_Leg = new PixelmonModelRenderer(this, 316, 10);
Left_Lower_Leg.addBox(-1F, 6F, -2F, 2, 2, 6);
Left_Lower_Leg.setTextureSize(512, 64);
Left_Lower_Leg.mirror = true;
setRotation(Left_Lower_Leg, -0.6108652F, 0F, -0.6981317F);
LeftLeg.addChild(Left_Lower_Leg);
PixelmonModelRenderer Left_Claw_1 = new PixelmonModelRenderer(this, 316, 18);
Left_Claw_1.addBox(-0.5F, 4F, 3F, 1, 3, 1);
Left_Claw_1.setTextureSize(512, 64);
Left_Claw_1.mirror = true;
setRotation(Left_Claw_1, -0.6108652F, -0.0872665F, -0.6981317F);
LeftLeg.addChild(Left_Claw_1);
PixelmonModelRenderer Left_Claw_2 = new PixelmonModelRenderer(this, 322, 18);
Left_Claw_2.addBox(0.5F, 7F, 3F, 1, 3, 1);
Left_Claw_2.setTextureSize(512, 64);
Left_Claw_2.mirror = true;
setRotation(Left_Claw_2, -0.6108652F, -0.0872665F, -0.6632251F);
LeftLeg.addChild(Left_Claw_2);
PixelmonModelRenderer Left_Claw_3 = new PixelmonModelRenderer(this, 327, 18);
Left_Claw_3.addBox(-1.5F, 7F, 3F, 1, 3, 1);
Left_Claw_3.setTextureSize(512, 64);
Left_Claw_3.mirror = true;
setRotation(Left_Claw_3, -0.6108652F, -0.0872665F, -0.7330383F);
LeftLeg.addChild(Left_Claw_3);
Body.addChild(LeftLeg);
PixelmonModelRenderer Tail = new PixelmonModelRenderer(this, "Tail");
Tail.setRotationPoint(0, 2, 18);
PixelmonModelRenderer Segment_1 = new PixelmonModelRenderer(this, 100, 0);
Segment_1.addBox(-3F, 0F, -3F, 6, 2, 6);
Segment_1.setTextureSize(512, 64);
Segment_1.mirror = true;
setRotation(Segment_1, 1.22173F, 0F, 0F);
Tail.addChild(Segment_1);
PixelmonModelRenderer Segment_2 = new PixelmonModelRenderer(this, 104, 8);
Segment_2.addBox(-2F, -1F, -2F, 4, 5, 4);
Segment_2.setRotationPoint(0F, 2F, 5F);
Segment_2.setTextureSize(512, 64);
Segment_2.mirror = true;
setRotation(Segment_2, 1.169371F, 0F, 0F);
Tail.addChild(Segment_2);
PixelmonModelRenderer Segment_3 = new PixelmonModelRenderer(this, 104, 17);
Segment_3.addBox(-2F, 1F, -2F, 4, 5, 4);
Segment_3.setTextureSize(512, 64);
Segment_3.mirror = true;
setRotation(Segment_3, 1.22173F, 0F, 0F);
Tail.addChild(Segment_3);
PixelmonModelRenderer Segment_4 = new PixelmonModelRenderer(this, 108, 26);
Segment_4.addBox(-1F, 0F, -1F, 2, 6, 2);
Segment_4.setRotationPoint(0F, 3F, 8F);
Segment_4.setTextureSize(512, 64);
Segment_4.mirror = true;
setRotation(Segment_4, 1.22173F, 0F, 0F);
Tail.addChild(Segment_4);
PixelmonModelRenderer Segment_5 = new PixelmonModelRenderer(this, 108, 34);
Segment_5.addBox(-1F, -1F, -1F, 2, 6, 2);
Segment_5.setRotationPoint(0F, 5F, 14F);
Segment_5.setTextureSize(512, 64);
Segment_5.mirror = true;
setRotation(Segment_5, 1.396263F, 0F, 0F);
Tail.addChild(Segment_5);
PixelmonModelRenderer Segment_6 = new PixelmonModelRenderer(this, 109, 42);
Segment_6.addBox(-1F, -1F, -1F, 2, 9, 1);
Segment_6.setRotationPoint(0F, 6F, 19F);
Segment_6.setTextureSize(512, 64);
Segment_6.mirror = true;
setRotation(Segment_6, 1.396263F, 0F, 0F);
Tail.addChild(Segment_6);
PixelmonModelRenderer Segment_7 = new PixelmonModelRenderer(this, 106, 52);
Segment_7.addBox(-3F, 6F, -1F, 6, 6, 0);
Segment_7.setRotationPoint(0F, 6F, 19F);
Segment_7.setTextureSize(512, 64);
Segment_7.mirror = true;
setRotation(Segment_7, 1.396263F, 0F, 0F);
Tail.addChild(Segment_7);
Body.addChild(Tail);
ModuleHead headModule = new ModuleHead(Head);
skeleton = new SkeletonBird(Body, headModule, LeftWing, RightWing, LeftLeg, RightLeg);
}
