Ejemplo n.º 1
0
  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);
  }
Ejemplo n.º 2
0
  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);
  }
Ejemplo n.º 3
0
  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);
  }
Ejemplo n.º 4
0
  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);
  }
Ejemplo n.º 5
0
  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);
  }
Ejemplo n.º 6
0
  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);
  }