Java ChainShape.createChain方法代码示例

import com.badlogic.gdx.physics.box2d.ChainShape; //导入方法依赖的package包/类
/**
 * Erzeugt aus einem PolylineMapObject ein ChainShape.
 *
 * @param polyObject das MapObject
 * @return die entsprechende Form
 */
public static ChainShape createPolyline(PolylineMapObject polyObject)
{
    float[] vertices = polyObject.getPolyline().getTransformedVertices();
    Vector2[] worldVertices = new Vector2[vertices.length / 2];

    for (int i = 0; i < vertices.length / 2; i++)
    {
        worldVertices[i] = new Vector2();
        worldVertices[i].x = vertices[i * 2] * Physics.MPP;
        worldVertices[i].y = vertices[i * 2 + 1] * Physics.MPP;
    }

    ChainShape chain = new ChainShape();
    chain.createChain(worldVertices);

    return chain;
}
 

import com.badlogic.gdx.physics.box2d.ChainShape; //导入方法依赖的package包/类
private static Shape getPolyline(PolylineMapObject object) {
	float[] vertices = object.getPolyline().getTransformedVertices();
	Vector2[] worldVertices = new Vector2[vertices.length / 2];
	
	for(int i = 0; i < vertices.length / 2; ++i){
		Vector2 vector = new Vector2();
		vector.x = vertices[i * 2];
		vector.y = vertices[i * 2 + 1];
		
		worldVertices[i] = Pixels.toMeters(new Vector2(vector));
	}
	
	ChainShape shape = new ChainShape();
	shape.createChain(worldVertices);
	return shape;
}
 

import com.badlogic.gdx.physics.box2d.ChainShape; //导入方法依赖的package包/类
public void create(){
	init = true;
	bdef.type = BodyType.StaticBody;
	bdef.position.set(x, y);
	
	ChainShape cs = new ChainShape();
	Vector2[] v = new Vector2[5];
	
	v[0] = new Vector2(-TILE_SIZE / 2 / PPM, -TILE_SIZE / 2 / PPM);
	v[1] = new Vector2(-TILE_SIZE / 2 / PPM, TILE_SIZE / 2 / PPM);
	v[2] = new Vector2(TILE_SIZE / 2 / PPM, TILE_SIZE / 2 / PPM);
	v[3] = new Vector2(TILE_SIZE / 2 / PPM, -TILE_SIZE / 2 / PPM);
	v[4] = new Vector2(-Vars.TILE_SIZE / 2 / Vars.PPM, -Vars.TILE_SIZE / 2 / Vars.PPM);
	cs.createChain(v);
	
	fdef.friction = .25f;
	fdef.shape = cs;
	fdef.filter.categoryBits = Vars.BIT_GROUND;
	fdef.filter.maskBits = Vars.BIT_LAYER1 | Vars.BIT_PLAYER_LAYER | Vars.BIT_LAYER3 | Vars.BIT_BATTLE;
	fdef.isSensor = false;
	body = world.createBody(bdef);
	body.createFixture(fdef).setUserData("ground");
	body.setUserData(this);
}
 

import com.badlogic.gdx.physics.box2d.ChainShape; //导入方法依赖的package包/类
private static Shape getPolylineShape(MapObject object) {
    Polyline polyline = ((PolylineMapObject)object).getPolyline();
    float[] vertices = polyline.getTransformedVertices();
    for (int i = 0; i < vertices.length; i++) {
        vertices[i] *= MainCamera.getInstance().getTileMapScale();
    }

    ChainShape shape = new ChainShape();
    shape.createChain(vertices);

    return shape;
}
 

import com.badlogic.gdx.physics.box2d.ChainShape; //导入方法依赖的package包/类
/**
 * Creates box2d bodies for all non-null tiles
 * in the specified layer and assigns the specified
 * category bits.
 *
 * @param layer the layer being read
 * @param bits  category bits assigned to fixtures
 */
private void createBlocks(TiledMapTileLayer layer, short bits) {

    // tile size
    float ts = layer.getTileWidth();

    // go through all cells in layer
    for (int row = 0; row < layer.getHeight(); row++) {
        for (int col = 0; col < layer.getWidth(); col++) {

            // get cell
            Cell cell = layer.getCell(col, row);

            // check that there is a cell
            if (cell == null) continue;
            if (cell.getTile() == null) continue;

            // create body from cell
            BodyDef bdef = new BodyDef();
            bdef.type = BodyType.StaticBody;
            bdef.position.set((col + 0.5f) * ts / PPM, (row + 0.5f) * ts / PPM);
            ChainShape cs = new ChainShape();
            Vector2[] v = new Vector2[3];
            v[0] = new Vector2(-ts / 2 / PPM, -ts / 2 / PPM);
            v[1] = new Vector2(-ts / 2 / PPM, ts / 2 / PPM);
            v[2] = new Vector2(ts / 2 / PPM, ts / 2 / PPM);
            cs.createChain(v);
            FixtureDef fd = new FixtureDef();
            fd.friction = 0;
            fd.shape = cs;
            fd.filter.categoryBits = bits;
            fd.filter.maskBits = B2DVars.BIT_PLAYER;
            world.createBody(bdef).createFixture(fd);
            cs.dispose();

        }
    }

}
 

import com.badlogic.gdx.physics.box2d.ChainShape; //导入方法依赖的package包/类
public Bounds(World world) {
	
	BodyDef bodyDef = new BodyDef();
	FixtureDef fixtureDef = new FixtureDef();
	float groundPos = -2.5f;
	float topPos = 7.5f;
	
	// body definition
	bodyDef.type = BodyType.StaticBody;
	bodyDef.position.set(0, groundPos);

	// ground shape
	ChainShape groundShapeBottom = new ChainShape();
	ChainShape groundShapeTop = new ChainShape();
	
	/*
	groundShape.createChain(new Vector2[] {new Vector2(-10, groundPos), new Vector2(10,groundPos),
			new Vector2(10, 8.35f), new Vector2(-10,8.35f), new Vector2(-10,groundPos)});
	*/
	
	groundShapeBottom.createChain(new Vector2[] {new Vector2(-10, groundPos), new Vector2(10,groundPos)});
	groundShapeTop.createChain(new Vector2[] {new Vector2(-10, topPos), new Vector2(10,topPos)});

	// fixture definition
	fixtureDef.shape = groundShapeBottom;

	body = world.createBody(bodyDef);
	fixture = body.createFixture(fixtureDef);
	
	// fixture definition
	fixtureDef.shape = groundShapeTop;

	body = world.createBody(bodyDef);
	fixture = body.createFixture(fixtureDef);
	
	groundShapeTop.dispose();
	groundShapeBottom.dispose();
}
 

import com.badlogic.gdx.physics.box2d.ChainShape; //导入方法依赖的package包/类
/**
 * 
 * @param world
 * @param polylineObject
 * @param density
 * @param friction
 * @param restitution
 */
private void createPolyline(World world, PolylineMapObject polylineObject, float density, float friction, float restitution){
	Polyline polyline = polylineObject.getPolyline();
	ChainShape shape = new ChainShape();
	float[] vertices = polyline.getTransformedVertices();
	float[] worldVertices = new float[vertices.length];
	
	for(int i = 0; i < vertices.length; i++){
		worldVertices[i] = vertices[i] / SupaBox.PPM;
	}
	
	shape.createChain(worldVertices);
	
	BodyDef bodyDef = new BodyDef();
	bodyDef.type = BodyType.StaticBody;
	
	Body body = world.createBody(bodyDef);
	
	FixtureDef fixtureDef = new FixtureDef();
	fixtureDef.shape = shape;
	fixtureDef.density = density;
	fixtureDef.friction = friction;
	fixtureDef.restitution = restitution;
	
	body.createFixture(fixtureDef);
	
	shape.dispose();
}
 

import com.badlogic.gdx.physics.box2d.ChainShape; //导入方法依赖的package包/类
private Shape getPolyline(PolylineMapObject polylineObject) {
	float[] vertices = polylineObject.getPolyline().getTransformedVertices();
	Vector2[] worldVertices = new Vector2[vertices.length / 2];
	
	for (int i = 0; i < vertices.length / 2; ++i) {
	    worldVertices[i] = new Vector2();
	    worldVertices[i].x = vertices[i * 2] / GameWorld.units;
	    worldVertices[i].y = vertices[i * 2 + 1] / GameWorld.units;
	}
	
	ChainShape chain = new ChainShape(); 
	chain.createChain(worldVertices);
	return chain;
}
 

import com.badlogic.gdx.physics.box2d.ChainShape; //导入方法依赖的package包/类
private Shape getPolyline(PolylineMapObject polylineObject) {
	float[] vertices = polylineObject.getPolyline().getTransformedVertices();
	Vector2[] worldVertices = new Vector2[vertices.length / 2];
	
	for (int i = 0; i < vertices.length / 2; ++i) {
	    worldVertices[i] = new Vector2();
	    worldVertices[i].x = vertices[i * 2] / units;
	    worldVertices[i].y = vertices[i * 2 + 1] / units;
	}
	
	ChainShape chain = new ChainShape(); 
	chain.createChain(worldVertices);
	return chain;
}
 

import com.badlogic.gdx.physics.box2d.ChainShape; //导入方法依赖的package包/类
private Shape getPolyline(PolylineMapObject polylineObject) {
	float[] vertices = polylineObject.getPolyline().getVertices(); // Changed
	Vector2[] worldVertices = new Vector2[vertices.length / 2];

	for (int i = 0; i < vertices.length / 2; ++i) {
		worldVertices[i] = new Vector2();
		worldVertices[i].x = vertices[i * 2] * m_units;
		worldVertices[i].y = vertices[i * 2 + 1] * m_units;
	}

	ChainShape chain = new ChainShape();
	chain.createChain(worldVertices);
	return chain;
}
 

import com.badlogic.gdx.physics.box2d.ChainShape; //导入方法依赖的package包/类
public PhysixFixtureDef shapePolyline(List<Point> points) {
    ChainShape chainShape = new ChainShape();
    chainShape.createChain(system.toBox2D(points));
    this.shape = chainShape;
    return this;
}
 

import com.badlogic.gdx.physics.box2d.ChainShape; //导入方法依赖的package包/类
public static Shape createChainShape(Vector2[] vertices) {
	ChainShape chainShape = new ChainShape();
	chainShape.createChain(vertices);

	return chainShape;
}