Java PolygonShape類代碼示例

import com.badlogic.gdx.physics.box2d.PolygonShape; //導入依賴的package包/類
/**
 * Creates a wall by constructing a rectangle whose corners are (xmin,ymin) and (xmax,ymax),
 * and rotating the box counterclockwise through the given angle, with specified restitution.
 */
public static Body createWall(World world, float xmin, float ymin, float xmax, float ymax,
        float angle, float restitution) {
    float cx = (xmin + xmax) / 2;
    float cy = (ymin + ymax) / 2;
    float hx = Math.abs((xmax - xmin) / 2);
    float hy = Math.abs((ymax - ymin) / 2);
    PolygonShape wallshape = new PolygonShape();
    // Don't set the angle here; instead call setTransform on the body below. This allows future
    // calls to setTransform to adjust the rotation as expected.
    wallshape.setAsBox(hx, hy, new Vector2(0f, 0f), 0f);

    FixtureDef fdef = new FixtureDef();
    fdef.shape = wallshape;
    fdef.density = 1.0f;
    if (restitution>0) fdef.restitution = restitution;

    BodyDef bd = new BodyDef();
    bd.position.set(cx, cy);
    Body wall = world.createBody(bd);
    wall.createFixture(fdef);
    wall.setType(BodyDef.BodyType.StaticBody);
    wall.setTransform(cx, cy, angle);
    return wall;
}
 

import com.badlogic.gdx.physics.box2d.PolygonShape; //導入依賴的package包/類
/**
 * Creates polygon ground from the given object, at the given world.
 *
 * @param world  The world were the ground will be.
 * @param object The object used to initialize the ground.
 * @return The body of the created ground.
 */
static Body makePolygonGround(World world, PolygonMapObject object) {
    Polygon polygon = object.getPolygon();

    // Body and Fixture variables
    BodyDef bdef = new BodyDef();
    FixtureDef fdef = new FixtureDef();
    PolygonShape shape = new PolygonShape();

    bdef.type = BodyDef.BodyType.StaticBody;
    bdef.position.set(PIXEL_TO_METER * polygon.getX(), PIXEL_TO_METER * polygon.getY());

    Body body = world.createBody(bdef);

    float[] new_vertices = polygon.getVertices().clone();
    for (int i = 0; i < new_vertices.length; i++)
        new_vertices[i] *= PIXEL_TO_METER;

    shape.set(new_vertices);
    fdef.shape = shape;
    fdef.filter.categoryBits = GROUND_BIT;
    body.createFixture(fdef);

    return body;
}
 

import com.badlogic.gdx.physics.box2d.PolygonShape; //導入依賴的package包/類
/**
 * Creates rectangular ground from the given object, at the given world.
 *
 * @param world  The world were the ground will be.
 * @param object The object used to initialize the ground.
 * @return The body of the created ground.
 */
static Body makeRectGround(World world, RectangleMapObject object) {
    Rectangle rect = object.getRectangle();

    // Body and Fixture variables
    BodyDef bdef = new BodyDef();
    FixtureDef fdef = new FixtureDef();
    PolygonShape shape = new PolygonShape();

    bdef.type = BodyDef.BodyType.StaticBody;
    bdef.position.set(PIXEL_TO_METER * (rect.getX() + rect.getWidth() / 2), PIXEL_TO_METER * (rect.getY() + rect.getHeight() / 2));

    Body body = world.createBody(bdef);

    shape.setAsBox((rect.getWidth() / 2) * PIXEL_TO_METER, (rect.getHeight() / 2) * PIXEL_TO_METER);
    fdef.shape = shape;
    fdef.filter.categoryBits = GROUND_BIT;
    body.createFixture(fdef);

    return body;
}
 

import com.badlogic.gdx.physics.box2d.PolygonShape; //導入依賴的package包/類
/**
 * Water Model's constructor.
 * Creates a water model from the given object, into the given world.
 *
 * @param world The world the water model will be in.
 * @param rect  The rectangle to create the water model with.
 */
public WaterModel(World world, Rectangle rect) {
    // Body and Fixture variables
    BodyDef bdef = new BodyDef();
    FixtureDef fdef = new FixtureDef();
    PolygonShape shape = new PolygonShape();

    bdef.type = BodyDef.BodyType.StaticBody;
    bdef.position.set(PIXEL_TO_METER * (rect.getX() + rect.getWidth() / 2), PIXEL_TO_METER * (rect.getY() + rect.getHeight() / 2));

    this.body = world.createBody(bdef);

    shape.setAsBox((rect.getWidth() / 2) * PIXEL_TO_METER, (rect.getHeight() / 2) * PIXEL_TO_METER);
    fdef.shape = shape;
    fdef.filter.categoryBits = FLUID_BIT;
    fdef.isSensor = true;
    fdef.density = 1f;
    fdef.friction = 0.1f;
    fdef.restitution = 0f;
    body.createFixture(fdef);

    body.setUserData(new BuoyancyController(world, body.getFixtureList().first()));

}
 

import com.badlogic.gdx.physics.box2d.PolygonShape; //導入依賴的package包/類
/**
 * Creates a polygon shape from a pixel based list of vertices
 *
 * @param vertices Vertices defining an image in pixels
 * @param size     Width/Height of the bitmap the vertices were extracted from
 * @return A PolygonShape with the correct vertices
 */
static PolygonShape createPolygonShape(float[] vertices, Vector2 size) {
    // Transform pixels into meters, center and invert the y-coordinate
    for (int i = 0; i < vertices.length; i++) {
        if (i % 2 == 0) vertices[i] -= size.x / 2;   // center the vertex x-coordinate
        if (i % 2 != 0) vertices[i] -= size.y / 2;  // center the vertex y-coordinate

        if (i % 2 != 0) vertices[i] *= -1;          // invert the y-coordinate

        vertices[i] *= PIXEL_TO_METER;              // scale from pixel to meter
    }

    PolygonShape polygon = new PolygonShape();
    polygon.set(vertices);

    return polygon;
}
 

import com.badlogic.gdx.physics.box2d.PolygonShape; //導入依賴的package包/類
/**
    * Create static body from a TiledObject Refer the box2d manual to
    * understand the static body
    * 
    * @param o
    *            TiledObject
    */
   public Body createStaticBoxBody(float x, float y, float width, float height) {
BodyDef groundBodyDef = new BodyDef();
groundBodyDef.type = BodyType.StaticBody;

// transform into box2d
x = x * WORLD_TO_BOX;

// get position-y from map
y = Gdx.graphics.getHeight() - y;
// transform into box2d
y = y * WORLD_TO_BOX;

groundBodyDef.position.set(x, y);
Body groundBody = world.createBody(groundBodyDef);
PolygonShape polygon = new PolygonShape();
((PolygonShape) polygon).setAsBox(width * WORLD_TO_BOX / 2, height
	* WORLD_TO_BOX / 2);
groundBody.createFixture(polygon, 0.0f);
groundBody.setUserData("static");
return groundBody;
   }
 

import com.badlogic.gdx.physics.box2d.PolygonShape; //導入依賴的package包/類
/**
 * Create static body from a TiledObject Refer the box2d manual to
 * understand the static body
 * 
 * @param o
 *            TiledObject
 */
public Body createStaticBoxBody(float x, float y, float width, float height) {
	BodyDef groundBodyDef = new BodyDef();
	groundBodyDef.type = BodyType.StaticBody;

	// transform into box2d
	x = x * WORLD_TO_BOX;

	// get position-y from map
	y = tileMapRenderer.getMapHeightUnits() - y;
	// transform into box2d
	y = y * WORLD_TO_BOX;

	groundBodyDef.position.set(x, y);
	Body groundBody = world.createBody(groundBodyDef);
	PolygonShape polygon = new PolygonShape();
	((PolygonShape) polygon).setAsBox(width * WORLD_TO_BOX / 2, height
			* WORLD_TO_BOX / 2);
	groundBody.createFixture(polygon, 0.0f);
	groundBody.setUserData("static");
	return groundBody;
}
 

import com.badlogic.gdx.physics.box2d.PolygonShape; //導入依賴的package包/類
/**
 * Because the algorithm is based on vertices, and the circles do not have vertices, we create a square around it.
 * @param fixture Circle fixture
 * @return A square instead of the circle
 */
private static PolygonShape circleToSquare(Fixture fixture) {
	Vector2 position = fixture.getBody().getLocalCenter();
	float x = position.x;
	float y = position .y;
	float radius = fixture.getShape().getRadius();
	
	PolygonShape octagon = new PolygonShape();
	Vector2[] vertices = new Vector2[4];
	vertices[0] = new Vector2(x-radius, y+radius);
	vertices[1]= new Vector2(x+radius, y+radius);
	vertices[2]= new Vector2(x-radius, y-radius);
	vertices[3]= new Vector2(x+radius, y-radius);
	octagon.set((Vector2[]) vertices);

	return octagon;
}
 

import com.badlogic.gdx.physics.box2d.PolygonShape; //導入依賴的package包/類
private void createBody() {
	BodyDef bodyDef = new BodyDef();
	bodyDef.type = BodyType.DynamicBody;
	
	// Set our body's starting position in the world
	bodyDef.position.set(Gdx.input.getX() / 100f, camera.viewportHeight - Gdx.input.getY() / 100f);
	
	// Create our body in the world using our body definition
	Body body = world.createBody(bodyDef);

	// Create a circle shape and set its radius to 6
	PolygonShape square = new PolygonShape();
	square.setAsBox(0.3f, 0.3f);

	// Create a fixture definition to apply our shape to
	FixtureDef fixtureDef = new FixtureDef();
	fixtureDef.shape = square;
	fixtureDef.density = 0.5f;
	fixtureDef.friction = 0.5f;
	fixtureDef.restitution = 0.5f;

	// Create our fixture and attach it to the body
	body.createFixture(fixtureDef);

	square.dispose();
}
 

import com.badlogic.gdx.physics.box2d.PolygonShape; //導入依賴的package包/類
public InteractiveTileObject(World world, TiledMap map, Rectangle bounds){
    this.world = world;
    this.map = map;
    this.bounds = bounds;

    BodyDef bdef = new BodyDef();
    FixtureDef fdef = new FixtureDef();
    PolygonShape shape = new PolygonShape();

    bdef.type = BodyDef.BodyType.StaticBody;
    bdef.position.set((bounds.getX() + bounds.getWidth() / 2) / NoObjectionGame.PPM, (bounds.getY() + bounds.getHeight() / 2 )/ NoObjectionGame.PPM);

    body = world.createBody(bdef);
    shape.setAsBox(bounds.getWidth() / 2 / NoObjectionGame.PPM, bounds.getHeight() / 2 / NoObjectionGame.PPM);
    fdef.shape = shape;
    fixture = body.createFixture(fdef);
}
 

import com.badlogic.gdx.physics.box2d.PolygonShape; //導入依賴的package包/類
public static Array<Body> createTopTube(World world, float posX) {

        float posY = generateTubePosition();

        BodyDef bodyDef = new BodyDef();
        bodyDef.type = BodyDef.BodyType.KinematicBody;
        bodyDef.position.set(posX, posY);
        PolygonShape shape = new PolygonShape();
        shape.setAsBox(Constants.TUBE_WIDTH / 2, Constants.TUBE_HEIGHT / 2);
        Body bodyTop = world.createBody(bodyDef);
        bodyTop.createFixture(shape, 0f);
        bodyTop.resetMassData();
        shape.dispose();
        bodyTop.setLinearVelocity(Constants.TUBE_SPEED, 0.0f);
        Array<Body> bodies = new Array<Body>();
        bodies.add(bodyTop);
        bodies.add(createBottomTube(world, posX, posY));
        return bodies;
    }
 

import com.badlogic.gdx.physics.box2d.PolygonShape; //導入依賴的package包/類
/**
 * Erzeugt aus einem PolygonMapObject ein PolygonShape.
 *
 * @param polyObject das MapObject
 * @return die entsprechende Form
 */
public static PolygonShape createPolygon(PolygonMapObject polyObject)
{
    PolygonShape polygon = new PolygonShape();

    float[] vertices = polyObject.getPolygon().getTransformedVertices();
    Vector2[] worldVertices = new Vector2[vertices.length / 2];

    if (worldVertices.length > 8)
    {
        Gdx.app.error("ERROR", "Too many polygon vertices. A polygon may have up to 8 vertices but no more.");
        return null;
    }

    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;
    }

    polygon.set(worldVertices);
    return polygon;
}
 

import com.badlogic.gdx.physics.box2d.PolygonShape; //導入依賴的package包/類
private void init() {
	mRegion = MyGdxGame.assetManager.getTextureAtlas(Constant.PLAY_BLOOD).findRegion("hp");

	mBodyDef = new BodyDef();
	mFixtureDef = new FixtureDef();
	PolygonShape shape = new PolygonShape();

	//初始化剛體形狀
	mBodyDef.type = BodyDef.BodyType.StaticBody;
	mBodyDef.position.set(x, y);

	shape.setAsBox(30 / Constant.RATE, 30 / Constant.RATE);
	mFixtureDef.shape = shape;
	mFixtureDef.isSensor = true;
	mFixtureDef.filter.categoryBits = Constant.TAO;
	mFixtureDef.filter.maskBits = Constant.PLAYER;

	mBody = mWorld.createBody(mBodyDef);
	mBody.createFixture(mFixtureDef).setUserData("tao");
}
 

import com.badlogic.gdx.physics.box2d.PolygonShape; //導入依賴的package包/類
/**
 * 創建攻擊夾具
 */
public void createStick() {
	if (mAttackFixture != null) {
		return;
	}
	//創建攻擊傳感器 stick
	PolygonShape shape = new PolygonShape();
	if (STATE == State.STATE_RIGHT_ATTACK) {
		shape.setAsBox(45 / Constant.RATE, 5 / Constant.RATE
				, new Vector2(60 / Constant.RATE, 0), 0);
	} else {
		shape.setAsBox(45 / Constant.RATE, 5 / Constant.RATE
				, new Vector2(-60 / Constant.RATE, 0), 0);
	}
	FixtureDef attackFixDef = new FixtureDef();
	attackFixDef.shape = shape;
	attackFixDef.filter.categoryBits = Constant.PLAYER;
	attackFixDef.filter.maskBits = Constant.ENEMY_DAO | Constant.BOSS;
	attackFixDef.isSensor = true;
	mAttackFixture = mBody.createFixture(attackFixDef);
	mAttackFixture.setUserData("stick");
}
 

import com.badlogic.gdx.physics.box2d.PolygonShape; //導入依賴的package包/類
/**
 * 創建升龍斬攻擊夾具
 */
public void createJumpStick() {
	if (mJumpAtkFix != null) {
		return;
	}
	//創建攻擊傳感器 stick
	PolygonShape shape = new PolygonShape();
	if (STATE == State.STATE_RIGHT_JUMP_ATTACK) {
		shape.setAsBox(10 / Constant.RATE, 40 / Constant.RATE
				, new Vector2(100 / Constant.RATE, 20 / Constant.RATE), 0);
	} else {
		shape.setAsBox(10 / Constant.RATE, 45 / Constant.RATE
				, new Vector2(-100 / Constant.RATE, 20 / Constant.RATE), 0);
	}
	FixtureDef attackFixDef = new FixtureDef();
	attackFixDef.shape = shape;
	attackFixDef.filter.categoryBits = Constant.PLAYER;
	attackFixDef.filter.maskBits = Constant.ENEMY_DAO | Constant.BOSS;
	attackFixDef.isSensor = true;
	mJumpAtkFix = mBody.createFixture(attackFixDef);
	mJumpAtkFix.setUserData("ball");
}