import com.badlogic.gdx.physics.box2d.Shape; //导入依赖的package包/类
/**
 * Box's Constructor.
 * Creates a Box in the given with world, from the given object.
 *
 * @param world  Physics world where the box will be in.
 * @param object Object used to create the box.
 */
public BoxModel(World world, RectangleMapObject object) {
    super(world, object.getRectangle().getCenter(new Vector2()).scl(PIXEL_TO_METER), ModelType.BOX, ANGULAR_DAMP, LINEAR_DAMP);

    // Fetch density from properties
    Float property = object.getProperties().get("density", float.class);
    if (property != null)
        density = property;

    // Create Fixture's Shape
    Shape shape = createPolygonShape(new float[]{
            0, 0, 64, 0, 64, 64, 0, 64
    }, new Vector2(64, 64));

    createFixture(new FixtureProperties(shape, density, FRICTION, RESTITUTION, GROUND_BIT, (short) (BALL_BIT | GROUND_BIT | FLUID_BIT)));
}
 

import com.badlogic.gdx.physics.box2d.Shape; //导入依赖的package包/类
public Body createTempBody(float x, float y, FixtureDef fixtureDef) {
// Dynamic Body
BodyDef bodyDef = new BodyDef();
if (box2dDebug)
    bodyDef.type = BodyType.StaticBody;
else
    bodyDef.type = BodyType.DynamicBody;

// transform into box2d
x = x * WORLD_TO_BOX;
y = y * WORLD_TO_BOX;

bodyDef.position.set(x, y);

Body body = world.createBody(bodyDef);

Shape shape = new CircleShape();
((CircleShape) shape).setRadius(1 * WORLD_TO_BOX);

if (fixtureDef == null)
    throw new GdxRuntimeException("fixtureDef cannot be null!");
fixtureDef.shape = shape;
body.createFixture(fixtureDef);
return body;
   }
 

import com.badlogic.gdx.physics.box2d.Shape; //导入依赖的package包/类
public Body createTempBody(float x, float y, FixtureDef fixtureDef) {
	// Dynamic Body
	BodyDef bodyDef = new BodyDef();
	if (box2dDebug)
		bodyDef.type = BodyType.StaticBody;
	else
		bodyDef.type = BodyType.DynamicBody;

	// transform into box2d
	x = x * WORLD_TO_BOX;
	y = y * WORLD_TO_BOX;

	bodyDef.position.set(x, y);

	Body body = world.createBody(bodyDef);

	Shape shape = new CircleShape();
	((CircleShape) shape).setRadius(1 * WORLD_TO_BOX);

	if (fixtureDef == null)
		throw new GdxRuntimeException("fixtureDef cannot be null!");
	fixtureDef.shape = shape;
	body.createFixture(fixtureDef);
	return body;
}
 

import com.badlogic.gdx.physics.box2d.Shape; //导入依赖的package包/类
/**
 * Erlaubt es den Unterklassen möglichst einfach einen beliebigen Box2D Körper zu erstellen.
 *
 * @param position die Startposition des Body
 * @param shape die Form, die für dne Body verwendet werden soll
 * @param type der Typ des Körpers
 * @return ein Box2D Körper
 */
protected Body createEntityBody(Vector2 position, Shape shape, BodyDef.BodyType type)
{
    position.scl(Physics.MPP);

    BodyDef bodyDef = new BodyDef();
    bodyDef.type = type;
    bodyDef.position.set(position);
    bodyDef.fixedRotation = true;

    Body body = worldObjectManager.getPhysicalWorld().createBody(bodyDef);
    body.setUserData(this);

    FixtureDef fixture = new FixtureDef();
    fixture.shape = shape;
    fixture.filter.categoryBits = Physics.CATEGORY_ENTITIES;
    fixture.filter.maskBits = Physics.MASK_ENTITIES;

    body.createFixture(fixture).setUserData(this);

    shape.dispose();

    return body;
}
 

import com.badlogic.gdx.physics.box2d.Shape; //导入依赖的package包/类
/**
 * Erzeugt automatisch aus einem MapObject einen statischen Trigger.
 *
 * @see InteractionHandler#createInteractionFixture(Body, Shape)
 *
 * @param mapObject das MapObject
 */
public void createStaticInteractionBody(MapObject mapObject)
{
    Shape shape = PhysicsTileMapBuilder.createShape(mapObject, PhysicsTileMapBuilder.TYPE_TRIGGER);

    if (shape == null)
    {
        Gdx.app.log("WARNING", "Unkown trigger type! The interaction object " + mapObject.getName() + " will be ignored!");
        return;
    }

    BodyDef triggerDef = new BodyDef();
    triggerDef.type = BodyDef.BodyType.StaticBody;

    Body trigger = manager.getPhysicalWorld().createBody(triggerDef);

    createInteractionFixture(trigger, shape);

    shape.dispose();
}
 

import com.badlogic.gdx.physics.box2d.Shape; //导入依赖的package包/类
/**
 * Erzeugt automatisch aus einem MapObject einen statischen Trigger.
 *
 * @see AttackHandler#createAttackFixture(Body, Shape)
 *
 * @param mapObject das MapObject
 */
public void createStaticAttackBody(MapObject mapObject)
{
    Shape shape = PhysicsTileMapBuilder.createShape(mapObject, PhysicsTileMapBuilder.TYPE_TRIGGER);

    if (shape == null)
    {
        Gdx.app.log("WARNING", "Unkown trigger type! The attack object " + mapObject.getName() + " will be ignored!");
        return;
    }

    BodyDef triggerDef = new BodyDef();
    triggerDef.type = BodyDef.BodyType.StaticBody;

    Body trigger = manager.getPhysicalWorld().createBody(triggerDef);

    createAttackFixture(trigger, shape);

    shape.dispose();
}
 

import com.badlogic.gdx.physics.box2d.Shape; //导入依赖的package包/类
/**
 * Erzeugt eine Form aus einem MapObject.
 *
 * @param mapObject das MapObject
 * @param mask Bitmaske, um Shape Typen auszuschließen
 * @return die entsprechende Form
 */
public static Shape createShape(MapObject mapObject, short mask)
{
    Shape shape = null;

    if (mapObject instanceof RectangleMapObject && (mask & TYPE_RECTANGLE) != 0)
    {
        shape = PhysicsTileMapBuilder.createRectangle((RectangleMapObject) mapObject);
    }
    else if (mapObject instanceof PolygonMapObject && (mask & TYPE_POLYGON) != 0)
    {
        shape = PhysicsTileMapBuilder.createPolygon((PolygonMapObject) mapObject);
    }
    else if (mapObject instanceof EllipseMapObject && (mask & TYPE_CIRCLE) != 0)
    {
        shape = PhysicsTileMapBuilder.createCircle((EllipseMapObject) mapObject);
    }
    else if (mapObject instanceof PolylineMapObject && (mask & TYPE_POLYLINE) != 0)
    {
        shape = createPolyline((PolylineMapObject) mapObject);
    }

    return shape;
}
 

import com.badlogic.gdx.physics.box2d.Shape; //导入依赖的package包/类
public static FixtureDef getFixtureDefFromBodySkeleton(MapObject object) {
    FixtureDef fixtureDef = new FixtureDef();
    fixtureDef.density = 1;
    fixtureDef.friction = 0;
    fixtureDef.restitution = 0;

    Shape shape = null;
    if (object instanceof TextureMapObject) {
        shape = getTextureMapShape(object);
    } else if (object instanceof RectangleMapObject) {
        shape = getRectangleShape(object);
    } else if (object instanceof CircleMapObject) {
        shape = getCircleShape(object);
    } else if (object instanceof EllipseMapObject) {
        shape = getEllipseShape(object);
    } else if (object instanceof PolygonMapObject) {
        shape = getPolygonShape(object);
    } else if (object instanceof PolylineMapObject) {
        shape = getPolylineShape(object);
    }

    fixtureDef.shape = shape;

    return fixtureDef;
}
 

import com.badlogic.gdx.physics.box2d.Shape; //导入依赖的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.Shape; //导入依赖的package包/类
@Override
public boolean touchUp(int screenX, int screenY, int pointer, int button) {

	/* Checks whether the max amount of balls were spawned */
	if (spawnedBalls < MAX_SPAWNED_BALLS) {
		spawnedBalls++;

		/* Translate camera point to world point */
		Vector3 unprojectedVector = new Vector3();
		camera.unproject(unprojectedVector.set(screenX, screenY, 0));

		/* Create a new ball */
		Shape shape = Box2DFactory.createCircleShape(1);
		FixtureDef fixtureDef = Box2DFactory.createFixture(shape, 2.5f,
				0.25f, 0.75f, false);
		Box2DFactory.createBody(world, BodyType.DynamicBody, fixtureDef,
				new Vector2(unprojectedVector.x, unprojectedVector.y));
	}

	return true;
}
 

import com.badlogic.gdx.physics.box2d.Shape; //导入依赖的package包/类
public static Body createWalls(World world, float viewportWidth,
		float viewportHeight, float offset) {
	float halfWidth = viewportWidth / 2 - offset;
	float halfHeight = viewportHeight / 2 - offset;

	Vector2[] vertices = new Vector2[] {
			new Vector2(-halfWidth, -halfHeight),
			new Vector2(halfWidth, -halfHeight),
			new Vector2(halfWidth, halfHeight),
			new Vector2(-halfWidth, halfHeight),
			new Vector2(-halfWidth, -halfHeight) };

	Shape shape = createChainShape(vertices);
	FixtureDef fixtureDef = createFixture(shape, 1, 0.5f, 0, false);

	return createBody(world, BodyType.StaticBody, fixtureDef, new Vector2(
			0, 0));
}
 

import com.badlogic.gdx.physics.box2d.Shape; //导入依赖的package包/类
/**
 * @param shape the {@link Shape} which position should be returned
 * @param rotation the rotation of the {@link Body Body's} {@link Transform} this shape is attached to
 * @return the position of the given {@link Shape} relative to its {@link Body}
 */
public static Vector2 getPositionRelative(Shape shape, float rotation) {
	Vector2 position = new Vector2();

	// get the position without rotation
	Vector2[] shapeVertices = getVertices(shape);
	position.set(GeometryUtils.getMaxX(shapeVertices) - GeometryUtils.getWidth(shapeVertices) / 2, GeometryUtils.getMaxY(shapeVertices) - GeometryUtils.getHeight(shapeVertices) / 2);

	// transform position according to rotation
	// http://stackoverflow.com/questions/1469149/calculating-vertices-of-a-rotated-rectangle
	float xx = position.x, xy = position.y, yx = position.x, yy = position.y;

	xx = xx * (float) Math.cos(rotation) - xy * (float) Math.sin(rotation);
	yy = yx * (float) Math.sin(rotation) + yy * (float) Math.cos(rotation);

	position.set(xx, yy);

	return position;
}
 

import com.badlogic.gdx.physics.box2d.Shape; //导入依赖的package包/类
public Body createDynamicBody(float posX, float posY, Shape shape,
		float density, float friction, float restitution) {
	BodyDef bodyDef = new BodyDef();
	bodyDef.type = BodyType.DynamicBody;
	bodyDef.position.set(posX, posY);

	Body body = world.createBody(bodyDef);
	FixtureDef fixtureDef = new FixtureDef();
	fixtureDef.shape = shape;
	fixtureDef.friction = friction;
	fixtureDef.density = density;
	fixtureDef.restitution = restitution;

	Fixture fixture = body.createFixture(fixtureDef);

	shape.dispose();

	return body;
}
 

import com.badlogic.gdx.physics.box2d.Shape; //导入依赖的package包/类
/**
 * Constructs a Body without using BodyDef or FixtureDef.
 * 
 * @param world
 *            The EntityWorld.
 * @param e
 *            The entity that contains this Body.
 * @param bodyType
 *            The type of this Body.
 * @param shape
 *            The body's shape.
 * @param position
 *            The body's initial position.
 */
public Body(EntityWorld world, Entity e, BodyType bodyType, Shape shape,
		Vector2 position) {
	entityWorld = world;

	BodyDef bodyDef = new BodyDef();
	bodyDef.type = bodyType;
	bodyDef.position.set(position);

	body = world.getBox2DWorld().createBody(bodyDef);
	body.setUserData(e);
	
	LogManager.debug("Physics", "Body Created");

	FixtureDef fixtureDef = new FixtureDef();
	fixtureDef.shape = shape;
	
	body.createFixture(fixtureDef);
}
 

import com.badlogic.gdx.physics.box2d.Shape; //导入依赖的package包/类
public static GameObject createGameObjectWithBox2DBody(Vector2 gameObjectPos, Texture texture, Vector3 densityFrictionRestitution,
                                   BodyDef.BodyType bodyType, Shape.Type shapeType,
                                   World world) {
    GameObject gameObject = new GameObject();
    gameObject.setPosition(gameObjectPos.x, gameObjectPos.y);
    gameObject.setTexture(texture);
    gameObject.setSprite(new Sprite(texture));
    gameObject.getSprite().setOriginCenter();
    gameObject.setWorld(world);
    BodyCreator bodyCreator = new BodyCreator();
    gameObject.setBody(bodyCreator.createBody(new Vector2(gameObject.getX(), gameObject.getY()), texture, bodyType, world, shapeType, densityFrictionRestitution));
    bodyCreator = null;
    return gameObject;
}
 

import com.badlogic.gdx.physics.box2d.Shape; //导入依赖的package包/类
public Body createBody(Vector2 position, Texture texture, BodyDef.BodyType bodyType, World world, Shape.Type shape, Vector3 densityRestitutionFriction) {
    this.texture = texture;
    bodyDef = createBodyDef(bodyType, position);
    body = world.createBody(bodyDef);
    FixtureCreator.createFixture(body, createShape(shape), densityRestitutionFriction);
    return body;
}
 

import com.badlogic.gdx.physics.box2d.Shape; //导入依赖的package包/类
private static FixtureDef createFixtureDef(Shape shape, float density, float restitution, float friction) {
    FixtureDef fixtureDef = new FixtureDef();
    fixtureDef.shape = shape;
    fixtureDef.density = density;
    fixtureDef.restitution = restitution;
    fixtureDef.friction = friction;
    return fixtureDef;
}
 

import com.badlogic.gdx.physics.box2d.Shape; //导入依赖的package包/类
/**
 * Ball Model's Constructor.
 * Creates a ball in a given starting position, in a given world.
 *
 * @param world Physics world where the ball will be used in.
 * @param pos   Ball's initial Position.
 */
public BallModel(World world, Vector2 pos) {
    super(world, pos, ModelType.BALL, ANGULAR_DAMP, LINEAR_DAMP);

    // Create Fixture's Shape
    Shape circle = new CircleShape();
    circle.setRadius(RADIUS);

    createFixture(new FixtureProperties(circle, density, friction, restitution, BALL_BIT,
            (short) (BALL_BIT | GROUND_BIT | FLUID_BIT | HITTABLE_BIT)));
}
 

import com.badlogic.gdx.physics.box2d.Shape; //导入依赖的package包/类
/**
 * Generic Power Up's constructor.
 * Creates a power up from the given object, with the given type, into the given world.
 *
 * @param world  The world the power up will be in.
 * @param object The object to create the power up with.
 * @param type   Type of Power Up.
 */
public PowerUp(World world, RectangleMapObject object, ModelType type) {
    super(world, object.getRectangle().getCenter(new Vector2()).scl(PIXEL_TO_METER), type);

    getBody().setType(BodyDef.BodyType.StaticBody);

    Shape shape = createPolygonShape(new float[]{
            14f, 1f, 18f, 1f, 25f, 7f, 25f, 23f, 18f, 31f, 14f, 31f, 7f, 23f, 7f, 7f
    }, new Vector2(32, 32));

    FixtureProperties fixtureProperties = new FixtureProperties(shape, HITTABLE_BIT, BALL_BIT);
    fixtureProperties.setSensor();
    createFixture(fixtureProperties);
}
 

import com.badlogic.gdx.physics.box2d.Shape; //导入依赖的package包/类
/**
    * Create a fixture, based float density, float friction,float restitution,
    * shape
    * 
    * @return
    */
   public FixtureDef createFixtureDef(float density, float friction,
    float restitution, Shape shape) {
FixtureDef output = new FixtureDef();
output.density = density;
output.friction = friction;
output.restitution = restitution;
output.shape = shape;
return output;
   }