Bodyeditorloader - Nosuchmethod

So, I started using Physics Body Editor as an extension to libgdx. I also use Android Studio to compile my code, so I can run an app on a real device. But, unfortunately, as I crea

Solution 1:

look this maybe this can help with anything :

https://code.google.com/p/box2d-editor/issues/detail?id=25

https://gist.github.com/zudov/5566204

package aurelienribon.bodyeditor;

import com.badlogic.gdx.files.FileHandle;
import com.badlogic.gdx.math.Vector2;
import com.badlogic.gdx.physics.box2d.Body;
import com.badlogic.gdx.physics.box2d.CircleShape;
import com.badlogic.gdx.physics.box2d.FixtureDef;
import com.badlogic.gdx.physics.box2d.PolygonShape;
import com.badlogic.gdx.utils.Array;
import com.badlogic.gdx.utils.JsonReader;
import com.badlogic.gdx.utils.JsonValue;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * Loads the collision fixtures defined with the Physics Body Editor
 * application. You only need to give it a body and the corresponding fixture
 * name, and it will attach these fixtures to your body.
 *
 * @author Aurelien Ribon | http://www.aurelienribon.com
 */publicclassBodyEditorLoader {

    // Modelprivatefinal Model model;

    // Reusable stuffprivatefinal List<Vector2> vectorPool = newArrayList<Vector2>();
    privatefinalPolygonShapepolygonShape=newPolygonShape();
    privatefinalCircleShapecircleShape=newCircleShape();
    privatefinalVector2vec=newVector2();

    // -------------------------------------------------------------------------// Ctors// -------------------------------------------------------------------------publicBodyEditorLoader(FileHandle file) {
        if (file == null) thrownewNullPointerException("file is null");
        model = readJson(file.readString());
    }

    publicBodyEditorLoader(String str) {
        if (str == null) thrownewNullPointerException("str is null");
        model = readJson(str);
    }

    // -------------------------------------------------------------------------// Public API// -------------------------------------------------------------------------/**
     * Creates and applies the fixtures defined in the editor. The name
     * parameter is used to retrieve the right fixture from the loaded file.
     * <br/><br/>
     *
     * The body reference point (the red cross in the tool) is by default
     * located at the bottom left corner of the image. This reference point
     * will be put right over the BodyDef position point. Therefore, you should
     * place this reference point carefully to let you place your body in your
     * world easily with its BodyDef.position point. Note that to draw an image
     * at the position of your body, you will need to know this reference point
     * (see {@link #getOrigin(java.lang.String, float)}.
     * <br/><br/>
     *
     * Also, saved shapes are normalized. As shown in the tool, the width of
     * the image is considered to be always 1 meter. Thus, you need to provide
     * a scale factor so the polygons get resized according to your needs (not
     * every body is 1 meter large in your game, I guess).
     *
     * @param body The Box2d body you want to attach the fixture to.
     * @param name The name of the fixture you want to load.
     * @param fd The fixture parameters to apply to the created body fixture.
     * @param scale The desired scale of the body. The default width is 1.
     */publicvoidattachFixture(Body body, String name, FixtureDef fd, float scale) {
        RigidBodyModelrbModel= model.rigidBodies.get(name);
        if (rbModel == null) thrownewRuntimeException("Name '" + name + "' was not found.");

        Vector2origin= vec.set(rbModel.origin).mul(scale);

        for (int i=0, n=rbModel.polygons.size(); i<n; i++) {
            PolygonModelpolygon= rbModel.polygons.get(i);
            Vector2[] vertices = polygon.buffer;

            for (int ii=0, nn=vertices.length; ii<nn; ii++) {
                vertices[ii] = newVec().set(polygon.vertices.get(ii)).mul(scale);
                vertices[ii].sub(origin);
            }

            polygonShape.set(vertices);
            fd.shape = polygonShape;
            body.createFixture(fd);

            for (int ii=0, nn=vertices.length; ii<nn; ii++) {
                free(vertices[ii]);
            }
        }

        for (int i=0, n=rbModel.circles.size(); i<n; i++) {
            CircleModelcircle= rbModel.circles.get(i);
            Vector2center= newVec().set(circle.center).mul(scale);
            floatradius= circle.radius * scale;

            circleShape.setPosition(center);
            circleShape.setRadius(radius);
            fd.shape = circleShape;
            body.createFixture(fd);

            free(center);
        }
    }

    /**
     * Gets the image path attached to the given name.
     */public String getImagePath(String name) {
        RigidBodyModelrbModel= model.rigidBodies.get(name);
        if (rbModel == null) thrownewRuntimeException("Name '" + name + "' was not found.");

        return rbModel.imagePath;
    }

    /**
     * Gets the origin point attached to the given name. Since the point is
     * normalized in [0,1] coordinates, it needs to be scaled to your body
     * size. Warning: this method returns the same Vector2 object each time, so
     * copy it if you need it for later use.
     */public Vector2 getOrigin(String name, float scale) {
    RigidBodyModelrbModel= model.rigidBodies.get(name);
    if (rbModel == null)
        thrownewRuntimeException("Name '" + name + "' was not found.");

    return vec.set(rbModel.origin).scl(scale);
}

    /**
     * <b>For advanced users only.</b> Lets you access the internal model of
     * this loader and modify it. Be aware that any modification is permanent
     * and that you should really know what you are doing.
     */public Model getInternalModel() {
        return model;
    }

    // -------------------------------------------------------------------------// Json Models// -------------------------------------------------------------------------publicstaticclassModel {
        publicfinal Map<String, RigidBodyModel> rigidBodies = newHashMap<String, RigidBodyModel>();
    }

    publicstaticclassRigidBodyModel {
        public String name;
        public String imagePath;
        publicfinalVector2origin=newVector2();
        publicfinal List<PolygonModel> polygons = newArrayList<PolygonModel>();
        publicfinal List<CircleModel> circles = newArrayList<CircleModel>();
    }

    publicstaticclassPolygonModel {
        publicfinal List<Vector2> vertices = newArrayList<Vector2>();
        private Vector2[] buffer; // used to avoid allocation in attachFixture()
    }

    publicstaticclassCircleModel {
        publicfinalVector2center=newVector2();
        publicfloat radius;
    }

    // -------------------------------------------------------------------------// Json reading process// -------------------------------------------------------------------------private Model readJson(String str) {
        Modelm=newModel();

        JsonValuemap=newJsonReader().parse(str);

        JsonValuebodyElem= map.getChild("rigidBodies");
        for (; bodyElem != null; bodyElem = bodyElem.next()) {
            RigidBodyModelrbModel= readRigidBody(bodyElem);
            m.rigidBodies.put(rbModel.name, rbModel);
        }

        return m;
    }

    private RigidBodyModel readRigidBody(JsonValue bodyElem) {
        RigidBodyModelrbModel=newRigidBodyModel();
        rbModel.name = bodyElem.getString("name");
        rbModel.imagePath = bodyElem.getString("imagePath");

        JsonValueoriginElem= bodyElem.get("origin");
        rbModel.origin.x = originElem.getFloat("x");
        rbModel.origin.y = originElem.getFloat("y");

        // polygonsJsonValuepolygonsElem= bodyElem.getChild("polygons"); 
        for (; polygonsElem != null ;polygonsElem = polygonsElem.next()){

            PolygonModelpolygon=newPolygonModel();
            rbModel.polygons.add(polygon);

            JsonValuevertexElem= polygonsElem.child();
            for (; vertexElem != null; vertexElem = vertexElem.next()) {
                floatx= vertexElem.getFloat("x");
                floaty= vertexElem.getFloat("y");
                polygon.vertices.add(newVector2(x, y));
            }

            polygon.buffer = newVector2[polygon.vertices.size()];

        }

        // circlesJsonValuecircleElem= bodyElem.getChild("circles");

        for (; circleElem != null; circleElem = circleElem.next()) {
            CircleModelcircle=newCircleModel();
            rbModel.circles.add(circle);

            circle.center.x = circleElem.getFloat("cx");
            circle.center.y = circleElem.getFloat("cy");
            circle.radius = circleElem.getFloat("r");
        }

        return rbModel;
    }

    // -------------------------------------------------------------------------// Helpers// -------------------------------------------------------------------------private Vector2 newVec() {
        return vectorPool.isEmpty() ? newVector2() : vectorPool.remove(0);
    }

    privatevoidfree(Vector2 v) {
        vectorPool.add(v);
    }
}

This code is on GitHub, but it was once the reporsitorio deleted because the user account change, I'll post it here so they do not depend account Git.(also with some changes to the code).