示例#1
0
  public void defineMario() {
    BodyDef bDef = new BodyDef();
    bDef.position.set(32 / MarioBros.PPM, 32 / MarioBros.PPM);
    bDef.type = BodyDef.BodyType.DynamicBody;
    b2body = world.createBody(bDef);

    FixtureDef fdef = new FixtureDef();
    CircleShape shape = new CircleShape();
    shape.setRadius(6 / MarioBros.PPM);
    fdef.filter.categoryBits = MarioBros.MARIO_BIT;
    fdef.filter.maskBits =
        MarioBros.GROUND_BIT
            | MarioBros.COIN_BIT
            | MarioBros.BRICK_BIT
            | MarioBros.ENEMY_BIT
            | MarioBros.OBJECT_BIT
            | MarioBros.ENEMY_HEAD_BIT
            | MarioBros.ITEM_BIT;

    fdef.shape = shape;
    b2body.createFixture(fdef);

    EdgeShape head = new EdgeShape();
    head.set(
        new Vector2(-2 / MarioBros.PPM, 6 / MarioBros.PPM),
        new Vector2(2 / MarioBros.PPM, 6 / MarioBros.PPM));
    fdef.filter.categoryBits = MarioBros.MARIO_HEAD_BIT;
    fdef.filter.maskBits = MarioBros.BRICK_BIT | MarioBros.COIN_BIT;
    fdef.shape = head;
    fdef.isSensor = true;

    b2body.createFixture(fdef).setUserData(this);
  }
示例#2
0
  private Fixture createPhysicsObject(Rectangle bounds, ModelType type, Integer id) {

    UserData userData = new UserData(numEnterPoints, type, null);
    CircleShape objectPoly = new CircleShape();
    objectPoly.setRadius(bounds.width / 2);

    BodyDef enemyBodyDef = new BodyDef();
    enemyBodyDef.type = BodyType.DynamicBody;
    enemyBodyDef.position.x = bounds.x;
    enemyBodyDef.position.y = bounds.y;
    Body objectBody = world.createBody(enemyBodyDef);
    FixtureDef objectFixtureDef = new FixtureDef();
    objectFixtureDef.shape = objectPoly;

    //	objectBody.setUserData(userData);
    objectFixtureDef.restitution = .025f;
    Fixture fixture = objectBody.createFixture(objectFixtureDef);
    fixture.setUserData(userData);
    objectBody.setLinearDamping(2f);
    objectBody.setGravityScale(.4f);
    objectBody.setFixedRotation(true);
    objectPoly.dispose();
    numEnterPoints++;

    // add a sensor on the bottom to check if touching ground (for jumping)
    PolygonShape polygonShape = new PolygonShape();
    polygonShape.setAsBox(
        bounds.width / 3, bounds.height / 8, new Vector2(0, -bounds.height / 2), 0);
    objectFixtureDef = new FixtureDef();
    objectFixtureDef.shape = polygonShape;
    objectFixtureDef.isSensor = true;
    Fixture footSensorFixture = objectBody.createFixture(objectFixtureDef);
    footSensorFixture.setUserData(new UserData(numEnterPoints, ModelType.FOOT_SENSOR, id));

    // add a sensor on left side to check if touching wall (for grappling)
    PolygonShape polygonShape2 = new PolygonShape();
    polygonShape2.setAsBox(
        bounds.width / 8, bounds.height / 3, new Vector2(-bounds.width / 2, 0), 0);
    objectFixtureDef = new FixtureDef();
    objectFixtureDef.shape = polygonShape2;
    objectFixtureDef.isSensor = true;
    Fixture leftSideSensorFixture = objectBody.createFixture(objectFixtureDef);
    leftSideSensorFixture.setUserData(new UserData(numEnterPoints, ModelType.LEFT_SIDE_SENSOR, id));

    // add a sensor on right side to check if touching wall (for grappling)
    polygonShape2.setAsBox(
        bounds.width / 8, bounds.height / 3, new Vector2(bounds.width / 2, 0), 0);
    objectFixtureDef = new FixtureDef();
    objectFixtureDef.shape = polygonShape2;
    objectFixtureDef.isSensor = true;
    Fixture rightSideSensorFixture = objectBody.createFixture(objectFixtureDef);
    rightSideSensorFixture.setUserData(
        new UserData(numEnterPoints, ModelType.RIGHT_SIDE_SENSOR, id));

    return fixture;
  }
  /*Boundaries game screen*/
  private void createLayout() {
    // down bound
    BodyDef bdef = new BodyDef();
    bdef.position.set(0 / GameScreenManager.PPM_W, referansDown / GameScreenManager.PPM_H);
    bdef.type = BodyDef.BodyType.StaticBody;
    Body body = world.createBody(bdef);

    PolygonShape shape = new PolygonShape();
    shape.setAsBox(GameScreenManager.WIDTH, 1);
    FixtureDef fdef = new FixtureDef();
    fdef.shape = shape;
    fdef.filter.categoryBits = CollisionVar.BIT_SCREEN;
    fdef.filter.maskBits =
        CollisionVar.BIT_SCREEN | CollisionVar.BIT_BALL | CollisionVar.BIT_PLAYER;

    body.createFixture(fdef).setUserData("down");
    // top bound
    bdef.position.set(0 / GameScreenManager.PPM_W, referansTop / GameScreenManager.PPM_H);
    bdef.type = BodyDef.BodyType.StaticBody;
    body = world.createBody(bdef);

    shape.setAsBox(GameScreenManager.WIDTH, 1);
    fdef.shape = shape;
    fdef.filter.categoryBits = CollisionVar.BIT_SCREEN;
    fdef.filter.maskBits =
        CollisionVar.BIT_SCREEN | CollisionVar.BIT_BALL | CollisionVar.BIT_PLAYER;

    body.createFixture(fdef).setUserData("top");

    // left bound
    bdef.position.set(0 / GameScreenManager.PPM_W, 80 / GameScreenManager.PPM_H);
    bdef.type = BodyDef.BodyType.StaticBody;
    body = world.createBody(bdef);

    shape.setAsBox(0, GameScreenManager.HEIGHT);
    fdef.shape = shape;
    fdef.filter.categoryBits = CollisionVar.BIT_SCREEN;
    fdef.filter.maskBits =
        CollisionVar.BIT_SCREEN | CollisionVar.BIT_BALL | CollisionVar.BIT_PLAYER;
    body.createFixture(fdef).setUserData("left");

    // right bound
    bdef.position.set(GameScreenManager.WIDTH + 1, 0 / GameScreenManager.PPM_H);
    bdef.type = BodyDef.BodyType.StaticBody;
    body = world.createBody(bdef);
    fdef.filter.categoryBits = CollisionVar.BIT_SCREEN;
    fdef.filter.maskBits =
        CollisionVar.BIT_SCREEN | CollisionVar.BIT_BALL | CollisionVar.BIT_PLAYER;

    shape.setAsBox(0, GameScreenManager.HEIGHT);
    fdef.shape = shape;
    body.createFixture(fdef).setUserData("right");
  }
示例#4
0
  public void createIceBall() {
    // gear base
    BodyDef bodyDef = new BodyDef();
    bodyDef.type = BodyType.StaticBody;
    bodyDef.position.x = x;
    bodyDef.position.y = y;
    CircleShape circleShape = new CircleShape();
    circleShape.setRadius(1);
    FixtureDef fixtureDef = new FixtureDef();
    fixtureDef.isSensor = true;
    fixtureDef.shape = circleShape;
    gearBody = world.createBody(bodyDef);
    gearBody.createFixture(fixtureDef);

    circleShape = new CircleShape();
    circleShape.setRadius(size);

    BodyDef boxBodyDef = new BodyDef();
    boxBodyDef.type = BodyType.DynamicBody;
    boxBodyDef.position.x = x;
    boxBodyDef.position.y = y;

    fixtureDef = new FixtureDef();
    fixtureDef.shape = circleShape;
    fixtureDef.friction = 0f;
    fixtureDef.density = 4.10f;
    fixtureDef.restitution = 1.5f;
    fixtureDef.isSensor = true;
    fixtureDef.filter.groupIndex = -1;
    gearBase = world.createBody(boxBodyDef);
    SpriteInfo spriteTemp = new SpriteInfo(assets.getSprite("star"));
    spriteTemp.setName("star");
    gearBase.setUserData(spriteTemp);
    gearBase.createFixture(fixtureDef);
    // iceBody.createFixture(circleShape, .1f);

    RevoluteJointDef wheeljointDef = new RevoluteJointDef();
    wheeljointDef.bodyA = gearBase;
    wheeljointDef.bodyB = gearBody;
    wheeljointDef.localAnchorA.y = 0;
    wheeljointDef.localAnchorB.y = 0;
    wheeljointDef.motorSpeed = .5f;
    wheeljointDef.enableMotor = true;
    wheeljointDef.maxMotorTorque = 100000f;
    // Joint joint =
    // wheeljointDef.bodyA.getWorld().createJoint(wheeljointDef);
    world.createJoint(wheeljointDef);

    circleShape.dispose();
  }
示例#5
0
 public void createCheckpointSensor(float x, float y, Vector2 heading) {
   // First we create a body definition
   BodyDef bodyDef = new BodyDef();
   // We set our body to dynamic, for something like ground which doesn't move we would set it to
   // StaticBody
   bodyDef.type = BodyDef.BodyType.StaticBody;
   // Set our body's starting position in the world
   bodyDef.position.set(x, y);
   // 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
   CircleShape circle = new CircleShape();
   circle.setRadius(0.25f);
   // Create a fixture definition to apply our shape to
   FixtureDef fixtureDef = new FixtureDef();
   fixtureDef.shape = circle;
   fixtureDef.isSensor = true;
   fixtureDef.filter.maskBits = ENTITY_ENEMY;
   fixtureDef.filter.categoryBits = SENSOR_NAVIGATION;
   // Create our fixture and attach it to the body
   Fixture fix = body.createFixture(fixtureDef);
   fix.setUserData(heading);
   // Remember to dispose of any shapes after you're done with them!
   // BodyDef and FixtureDef don't need disposing, but shapes do.
   circle.dispose();
 }
示例#6
0
  private void createCoins() {
    coins = new Array<Coin>();

    MapLayer layer = tileMap.getLayers().get("Coins");
    BodyDef bdef = new BodyDef();
    FixtureDef fdef = new FixtureDef();
    for (MapObject mo : layer.getObjects()) {
      bdef.type = BodyType.StaticBody;
      float x = mo.getProperties().get("x", Float.class) / PPM;
      float y = mo.getProperties().get("y", Float.class) / PPM;

      bdef.position.set(x, y);
      CircleShape cShape = new CircleShape();
      cShape.setRadius(8 / PPM);
      fdef.shape = cShape;
      fdef.isSensor = true;
      fdef.filter.categoryBits = B2DVars.BIT_COINS;
      fdef.filter.maskBits = B2DVars.BIT_PLAYER;
      Body body = world.createBody(bdef);
      body.createFixture(fdef).setUserData("coin");
      Coin c = new Coin(body);
      coins.add(c);

      body.setUserData(c);
    }
  }
示例#7
0
  public void setUp() {

    BodyDef bodyDef = new BodyDef();
    bodyDef.position.set(x + width / 2, y + height / 2);
    bodyDef.type = BodyDef.BodyType.KinematicBody;

    PolygonShape shape = new PolygonShape();
    shape.setAsBox(width / 2, height / 2);

    FixtureDef fixtureDef = new FixtureDef();
    fixtureDef.shape = shape;

    body = world.createBody(bodyDef);
    body.createFixture(fixtureDef);
    body.setUserData(Constants.robotNinjaID);

    body.setLinearVelocity(Constants.standardVelocity);

    sprite = new Sprite(texture);
    sprite.setSize(width, height);
    sprite.setOrigin(width / 2, height / 2);
    sprite.flip(false, flipy);
    sprite.setPosition(x, y);

    dead = false;
  }
示例#8
0
  /**
   * * Filtered version of createRectangularBody Category is who I am, Group filters GameObjects of
   * the same class as mine so we dont collide, Mask is who is allowed to collide With Me Default
   * filter values: categoryBits = 0x0001, maskBits = -1, groupIndex = 0 Leaving them at default
   * would be the same as not passing such argument (use if that is the intended result) **
   */
  public static Body createRectangularBody(
      float x,
      float y,
      float halfWidth,
      float halfHeight,
      short category,
      short mask,
      short group,
      GameEntity myGameObjectIndentifier) {
    bodyDef.type = BodyType.DynamicBody;
    // The body is originally instantiated at the Bottom-Left position
    bodyDef.position.set((x + halfWidth) / PPM, (y + halfHeight) / PPM);

    PolygonShape shape = new PolygonShape();
    shape.setAsBox(halfWidth / PPM, halfHeight / PPM);

    fixtureDef.shape = shape;
    fixtureDef.filter.categoryBits = category;
    fixtureDef.filter.maskBits = mask;
    fixtureDef.filter.groupIndex = group;

    Body body = WORLD.createBody(bodyDef);
    body.createFixture(fixtureDef).setUserData(myGameObjectIndentifier);
    body.setLinearDamping(1);

    shape.dispose();

    return body;
  }
示例#9
0
  private void createBoxes() {
    // next we create 50 boxes at random locations above the ground
    // body. First we create a nice polygon representing a box 2 meters
    // wide and high.
    PolygonShape boxPoly = new PolygonShape();
    boxPoly.setAsBox(1, 1);

    // next we create the 50 box bodies using the PolygonShape we just
    // defined. This process is similar to the one we used for the ground
    // body. Note that we reuse the polygon for each body fixture.
    for (int i = 0; i < 20; i++) {
      // Create the BodyDef, set a random position above the
      // ground and create a new body
      BodyDef boxBodyDef = new BodyDef();
      boxBodyDef.type = BodyType.DynamicBody;
      boxBodyDef.position.x = -24 + (float) (Math.random() * 48);
      boxBodyDef.position.y = 10 + (float) (Math.random() * 100);
      Body boxBody = world.createBody(boxBodyDef);

      boxBody.createFixture(boxPoly, 1);

      // add the box to our list of boxes
      boxes.add(boxBody);
    }

    // we are done, all that's left is disposing the boxPoly
    boxPoly.dispose();
  }
  public void defineMario() {
    BodyDef bdef = new BodyDef();
    bdef.position.set(1, 1);
    bdef.type = BodyDef.BodyType.DynamicBody;
    b2body = world.createBody(bdef);

    FixtureDef fdef = new FixtureDef();
    PolygonShape cuerpito = new PolygonShape();

    Vector2[] cuerpo = new Vector2[4];
    cuerpo[0] = new Vector2(-10, 20).scl(1 / MegaCatastrofeNuclear.PPM);
    cuerpo[1] = new Vector2(5, 20).scl(1 / MegaCatastrofeNuclear.PPM);
    cuerpo[2] = new Vector2(-10, -25).scl(1 / MegaCatastrofeNuclear.PPM);
    cuerpo[3] = new Vector2(5, -25).scl(1 / MegaCatastrofeNuclear.PPM);

    cuerpito.set(cuerpo);

    fdef.filter.categoryBits = MegaCatastrofeNuclear.PLAYER_BIT;
    fdef.filter.maskBits =
        MegaCatastrofeNuclear.GROUND_BIT
            | MegaCatastrofeNuclear.COIN_BIT
            | MegaCatastrofeNuclear.BRICK_BIT
            | MegaCatastrofeNuclear.ENEMY_BIT
            | MegaCatastrofeNuclear.OBJECT_BIT
            | MegaCatastrofeNuclear.ENEMYY_BIT
            | MegaCatastrofeNuclear.ITEM_BIT;

    fdef.shape = cuerpito;
    b2body.createFixture(fdef);
  }
  public void createFixtures(Body body) {
    PolygonShape boxPoly = new PolygonShape();
    boxPoly.setAsBox(dimension.x / 2, dimension.y / 2);

    body.createFixture(boxPoly, 1);

    boxPoly.dispose();
  }
示例#12
0
  @Override
  public List<Body> createFixtures(World world, Physics physics, Entity e) {
    List<Body> bodies = super.createFixtures(world, physics, e);
    Body torso = bodies.get(0);

    PolygonShape torsoShape = new PolygonShape();
    float widthHalf = Math.max(0.0001f, Math.abs(vec1.x - vec2.x));
    float heightHalf = Math.max(0.0001f, Math.abs(vec1.y - vec2.y));
    torsoShape.setAsBox(widthHalf, heightHalf);

    torso.createFixture(torsoShape, 5.0f);

    Vector2 relHipAnchor = new Vector2(0, -heightHalf * 0.95f);
    Vector2 hipAnchor = torso.getWorldPoint(relHipAnchor);

    System.out.println(relHipAnchor);

    CircleShape hipCircle = new CircleShape();
    hipCircle.setRadius(widthHalf);
    hipCircle.setPosition(hipAnchor);

    FixtureDef fd = new FixtureDef();
    fd.density = 1.0f;
    fd.shape = hipCircle;
    fd.filter.groupIndex = -1;
    BodyDef bd = new BodyDef();
    bd.type = BodyType.DynamicBody;
    bd.position.set(relHipAnchor);
    Body hip = torso.getWorld().createBody(bd);
    hip.createFixture(fd);

    JointDef jDef = new JointDef();
    jDef.type = JointType.WheelJoint;
    RevoluteJointDef jd = new RevoluteJointDef();
    WheelJointDef wd = new WheelJointDef();
    wd.initialize(torso, hip, hipAnchor, new Vector2(0.0f, 1.0f));
    wd.collideConnected = false;
    wd.maxMotorTorque = 400.0f;
    wd.enableMotor = true;
    wd.motorSpeed = 1.0f;
    //		Joint motorJoint = (RevoluteJoint) torso.getWorld().createJoint(jd);

    bodies.add(torso);
    // TODO add all bodies
    return bodies;
  }
示例#13
0
  private void createBoxAtPos(Body body) {
    FixtureDef fixtureDef = new FixtureDef();
    PolygonShape shape = new PolygonShape();
    shape.setAsBox(1f, 1f);
    fixtureDef.shape = shape;
    fixtureDef.density = 10f;
    fixtureDef.restitution = 0.2f;

    Gdx.app.log(TAG, "creating body with pos: " + body.getPosition());
    body.createFixture(fixtureDef);
  }
示例#14
0
  public void defineBigMario() {
    Vector2 marioPosition = b2body.getPosition();
    world.destroyBody(b2body);

    BodyDef bDef = new BodyDef();
    bDef.position.set(marioPosition.add(0 / MarioBros.PPM, 10 / MarioBros.PPM));
    bDef.type = BodyDef.BodyType.DynamicBody;
    b2body = world.createBody(bDef);

    FixtureDef fdef = new FixtureDef();
    CircleShape shape = new CircleShape();
    shape.setRadius(6 / MarioBros.PPM);
    fdef.filter.categoryBits = MarioBros.MARIO_BIT;
    fdef.filter.maskBits =
        MarioBros.GROUND_BIT
            | MarioBros.COIN_BIT
            | MarioBros.BRICK_BIT
            | MarioBros.ENEMY_BIT
            | MarioBros.OBJECT_BIT
            | MarioBros.ENEMY_HEAD_BIT
            | MarioBros.ITEM_BIT;

    fdef.shape = shape;
    b2body.createFixture(fdef);
    shape.setPosition(new Vector2(0, -14 / MarioBros.PPM));
    fdef.shape = shape;
    b2body.createFixture(fdef).setUserData(this);

    EdgeShape head = new EdgeShape();
    head.set(
        new Vector2(-2 / MarioBros.PPM, 6 / MarioBros.PPM),
        new Vector2(2 / MarioBros.PPM, 6 / MarioBros.PPM));
    fdef.filter.categoryBits = MarioBros.MARIO_HEAD_BIT;
    fdef.filter.maskBits = MarioBros.BRICK_BIT | MarioBros.COIN_BIT;
    fdef.shape = head;
    fdef.isSensor = true;

    b2body.createFixture(fdef).setUserData(this);

    timeToDefineBigMario = false;
  }
示例#15
0
  public static Body createWall(World world, float x, float y, float width, float height) {

    BodyDef bodyDef = new BodyDef();
    bodyDef.position.set(new Vector2(x, y));
    Body body = world.createBody(bodyDef);
    PolygonShape shape = new PolygonShape();
    shape.setAsBox(width / 2, height / 2);
    Fixture fixture = body.createFixture(shape, Constants.WALL_DENSITY);
    body.setUserData(new WallUserData());
    shape.dispose();
    return body;
  }
示例#16
0
  public void createBody() {
    BodyDef bdef = getBodyDef();
    FixtureDef fdef = getFixtureDef();

    if (mBody != null) {
      mWorld.removeBodySafely(mBody);
    }
    mBody = mWorld.addBody(bdef);
    Fixture fix = mBody.createFixture(fdef);

    bodyCreated(mBody, fix);
  }
示例#17
0
 private void createPlayer() {
   BodyDef bdef = new BodyDef();
   PolygonShape shape = new PolygonShape();
   FixtureDef fdef = new FixtureDef();
   fdef.shape = shape;
   bdef.position.set(160 / PPM, 200 / PPM);
   bdef.type = BodyType.DynamicBody;
   Body body = world.createBody(bdef);
   shape.setAsBox(13 / PPM, 13 / PPM);
   fdef.filter.categoryBits = (B2DVars.BIT_PLAYER);
   fdef.filter.maskBits = B2DVars.BIT_BLOCKS;
   body.createFixture(fdef).setUserData("player");
   shape.setAsBox(13 / PPM, 13 / PPM, new Vector2(0, -13 / PPM), 0);
   fdef.shape = shape;
   fdef.filter.categoryBits = (B2DVars.BIT_PLAYER);
   fdef.filter.maskBits = B2DVars.BIT_BLOCKS | B2DVars.BIT_COINS;
   fdef.isSensor = true;
   body.createFixture(fdef).setUserData("foot");
   player = new Player(body);
   body.setUserData(player);
 }
示例#18
0
  private void createCircleAtPos(Body body) {

    FixtureDef fixtureDef = new FixtureDef();
    CircleShape shape = new CircleShape();
    shape.setRadius(1f);
    fixtureDef.shape = shape;
    fixtureDef.density = 5f;
    fixtureDef.restitution = 0.8f;

    Gdx.app.log(TAG, "creating body with pos: " + body.getPosition());
    body.createFixture(fixtureDef);
  }
示例#19
0
  private void defineMario() {
    BodyDef bdef = new BodyDef();
    bdef.position.set(32 / MarioBros.PPM, 32 / MarioBros.PPM);
    bdef.type = BodyDef.BodyType.DynamicBody;
    b2body = world.createBody(bdef);

    FixtureDef fdef = new FixtureDef();
    CircleShape shape = new CircleShape();
    shape.setRadius(6 / MarioBros.PPM);

    fdef.shape = shape;
    b2body.createFixture(fdef);
  }
示例#20
0
  private void definePlayer() {
    BodyDef bodyDef = new BodyDef();
    bodyDef.position.set(32 / Gyaya.PPM, 32 / Gyaya.PPM);
    bodyDef.type = BodyDef.BodyType.DynamicBody;
    b2body = world.createBody(bodyDef);

    FixtureDef fixtureDef = new FixtureDef();
    CircleShape shape = new CircleShape();
    shape.setRadius(8f / Gyaya.PPM);
    fixtureDef.filter.categoryBits = Gyaya.PLAYER_BIT;
    fixtureDef.filter.maskBits =
        Gyaya.GROUND_BIT
            | Gyaya.BRICK_BIT
            | Gyaya.COIN_BIT
            | Gyaya.OBJECT_BIT
            | Gyaya.ENEMY_BIT
            | Gyaya.ENEMY_HEAD_BIT;

    fixtureDef.shape = shape;

    b2body.createFixture(fixtureDef);
    shape.setPosition(new Vector2(0, 4 / Gyaya.PPM));
    shape.setRadius(6f / Gyaya.PPM);
    b2body.createFixture(fixtureDef);

    EdgeShape head = new EdgeShape();
    head.set(
        new Vector2(-3 / Gyaya.PPM, 10f / Gyaya.PPM), new Vector2(3 / Gyaya.PPM, 10f / Gyaya.PPM));
    fixtureDef.shape = head;
    fixtureDef.isSensor = true;
    b2body.createFixture(fixtureDef).setUserData("head");

    EdgeShape feet = new EdgeShape();
    feet.set(
        new Vector2(-6 / Gyaya.PPM, -9f / Gyaya.PPM), new Vector2(6 / Gyaya.PPM, -9f / Gyaya.PPM));
    fixtureDef.shape = feet;
    fixtureDef.isSensor = true;
    b2body.createFixture(fixtureDef).setUserData("feet");
  }
示例#21
0
 /*
  * (non-Javadoc)
  *
  * @see
  * com.rougeprogrammers.shootthecat.objects.models.Model#createBody(float,
  * float)
  */
 @Override
 protected Body createBody(float x, float y) {
   BodyDef bodyDef = new BodyDef();
   bodyDef.type = BodyType.KinematicBody;
   bodyDef.position.set(x * Constants.WORLD_TO_BOX, y * Constants.WORLD_TO_BOX);
   Body body = gameStage.getWorld().createBody(bodyDef);
   PolygonShape shape = new PolygonShape();
   shape.setAsBox(
       getWidth() / 2 * Constants.WORLD_TO_BOX, getHeight() / 2 * Constants.WORLD_TO_BOX);
   body.createFixture(shape, Obstacle.DENSITY);
   shape.dispose();
   body.setUserData(new ObjectType(Type.THORN, index));
   return body;
 }
示例#22
0
  @Override
  public void create() { // creates everything you need LOL
    batch = new SpriteBatch();
    img = new Texture("Alien.png");
    sprite = new Sprite(img);

    // sets the sprite in the middle of the screen
    sprite.setPosition(
        Gdx.graphics.getWidth() / 2 - sprite.getWidth() / 2, Gdx.graphics.getHeight() / 2);

    // This is were the magic happens, this is the "physics world" created where the gravity is set
    // to 98
    // The 'f' makes 98 a float, the true means that it is active, vector 2d just means it takes x y
    // coor
    world = new World(new Vector2(0, -98f), true);

    // The body is the "object" set in the world, BodyDef makes the world aware of the object
    // basically so world Senpai notices
    BodyDef bodyDef = new BodyDef();
    bodyDef.type = BodyDef.BodyType.DynamicBody;

    // using 1 to 1 dimensions, meaning 1 in physics engine is 1px
    // set the body to the same position as the sprite
    bodyDef.position.set(sprite.getX(), sprite.getY());

    // now create the body in the world!
    body = world.createBody(bodyDef);

    // now make the "shape" of the body that you just created
    shape = new PolygonShape();

    // in this example I made a box (you can make circles too and stuff) that surrounds the sprite
    // aka the hit-box
    // so make the shape the same dimensions as the sprite image we are using
    shape.setAsBox(sprite.getWidth() / 2, sprite.getHeight() / 2);

    // FixtureDef is used to add physical properties to the shape
    // Ex. density, mass, area etc.
    fixtureDef = new FixtureDef();

    // now assign the FixtureDef to the new shape that we just made
    fixtureDef.shape = shape;

    // Adding density using FixtureDef & adding it to the body so again world senpai notices
    fixtureDef.density = 1f;
    fixture = body.createFixture(fixtureDef);

    // the shape can be disposed to reduce clutter that will slow down the game
    shape.dispose();
  }
  /**
   * 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 def The fixture parameters to apply to the created body fixture.
   * @param scale The desired scale of the body. The default width is 1.
   */
  public void attachFixture(Body body, String name, FixtureDef def, float scale) {
    RigidBodyModel rbModel = this.MODEL.RIGIDBODIES.get(name);
    if (rbModel == null) throw new RuntimeException("Name '" + name + "' was not found.");

    Vector2 origin = this.VEC.set(rbModel.ORIGIN).scl(scale);

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

      for (int j = 0, n2 = vertices.length; j < n2; j++) {
        vertices[j] = newVec().set(polygon.VERTICES.get(j)).scl(scale);
        vertices[j].sub(origin);
      }

      this.POLYGONSHAPE.set(vertices);
      def.shape = this.POLYGONSHAPE;
      body.createFixture(def);

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

    for (int i = 0, n = rbModel.CIRCLES.size(); i < n; i++) {
      CircleModel circle = rbModel.CIRCLES.get(i);
      Vector2 center = newVec().set(circle.CENTER).scl(scale);
      float radius = circle.radius * scale;

      this.CIRCLESHAPE.setPosition(center);
      this.CIRCLESHAPE.setRadius(radius);
      def.shape = this.CIRCLESHAPE;
      body.createFixture(def);

      free(center);
    }
  }
示例#24
0
  /**
   * 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.
   */
  public void attachFixture(Body body, String name, FixtureDef fd, float scale) {
    RigidBodyModel rbModel = model.rigidBodies.get(name);
    if (rbModel == null) throw new RuntimeException("Name '" + name + "' was not found.");

    Vector2 origin = vec.set(rbModel.origin).scl(scale);

    for (int i = 0, n = rbModel.polygons.size(); i < n; i++) {
      PolygonModel polygon = 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)).scl(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++) {
      CircleModel circle = rbModel.circles.get(i);
      Vector2 center = newVec().set(circle.center).scl(scale);
      float radius = circle.radius * scale;

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

      free(center);
    }
  }
示例#25
0
  private static void addShape(
      PhysixSystem physixSystem, Rectangle rect, int tileWidth, int tileHeight) {
    float width = rect.width * tileWidth;
    float height = rect.height * tileHeight;
    float x = rect.x * tileWidth + width / 2;
    float y = rect.y * tileHeight + height / 2;

    PhysixBodyDef bodyDef =
        new PhysixBodyDef(BodyDef.BodyType.StaticBody, physixSystem)
            .position(x, y)
            .fixedRotation(false);
    Body body = physixSystem.getWorld().createBody(bodyDef);
    body.createFixture(
        new PhysixFixtureDef(physixSystem).density(1).friction(0.5f).shapeBox(width, height));
  }
示例#26
0
  public static Body resizeSquareBody(Body body, float newWidth, float newHeight) {
    PolygonShape shape = new PolygonShape();
    shape.setAsBox(newWidth / PPM, newHeight / PPM);

    fixtureDef.shape = shape;

    // Delete the previous fixture
    body.destroyFixture(body.getFixtureList().get(0));
    // Add the new fixture
    body.createFixture(fixtureDef);

    shape.dispose();

    return body;
  }
示例#27
0
  public static Body createMovingPlatform(
      World world, float x, float y, float width, float height, float restituition) {

    BodyDef bodyDef = new BodyDef();
    bodyDef.type = BodyDef.BodyType.KinematicBody;
    bodyDef.position.set(new Vector2(x, y));
    Body body = world.createBody(bodyDef);
    PolygonShape shape = new PolygonShape();
    shape.setAsBox(width / 2, height / 2);
    Fixture fixture = body.createFixture(shape, Constants.GROUND_DENSITY);
    fixture.setRestitution(restituition);
    body.setUserData(new GroundUserData());
    shape.dispose();
    return body;
  }
  public static void createBody(World world, SceneElement e, ValueMap valueMap) {
    float x = valueMap.getValue(e, SceneElement.VAR_X, 0f) / WORLD_SCALE;
    float y = valueMap.getValue(e, SceneElement.VAR_Y, 0f) / WORLD_SCALE;
    float width = valueMap.getValue(e, SceneElement.VAR_WIDTH, 1) / WORLD_SCALE;
    float height = valueMap.getValue(e, SceneElement.VAR_HEIGHT, 1) / WORLD_SCALE;

    // TODO what if corner is not center?
    PhType phType = valueMap.getValue(e, PhysicsEf.VAR_PH_TYPE, PhType.DYNAMIC);
    PhShape phShape = valueMap.getValue(e, PhysicsEf.VAR_PH_SHAPE, PhShape.RECTANGULAR);

    Shape s = null;
    switch (phShape) {
      case CIRCULAR:
        s = new CircleShape();
        s.setRadius(width / 2);
        break;
      default:
        s = new PolygonShape();
        ((PolygonShape) s).setAsBox(width / 2, height / 2);
    }

    BodyDef bd = new BodyDef();

    switch (phType) {
      case STATIC:
        bd.type = BodyType.StaticBody;
        break;
      case DYNAMIC:
        bd.type = BodyType.DynamicBody;
        break;
    }

    bd.position.set(x, y);
    bd.angle = valueMap.getValue(e, SceneElement.VAR_ROTATION, 0);

    FixtureDef fixture = new FixtureDef();
    fixture.shape = s;
    fixture.density = valueMap.getValue(e, PhysicsEf.VAR_PH_DENSITY, 1f);
    fixture.friction = valueMap.getValue(e, PhysicsEf.VAR_PH_FRICTION, 1f);
    fixture.restitution = valueMap.getValue(e, PhysicsEf.VAR_PH_RESTITUTION, 1f);

    Body body = world.createBody(bd);
    body.createFixture(fixture);

    body.resetMassData();

    valueMap.setValue(e.getId(), VAR_PH_BODY, body);
  }
示例#29
0
  private Body addFinish(World world, Vector2 position) {
    final BodyDef bodyDef = new BodyDef();
    bodyDef.type = BodyDef.BodyType.StaticBody;
    final Body body = world.createBody(bodyDef);
    body.setTransform(position.x + offset.x, position.y + offset.y, 0);

    final PolygonShape shape = new PolygonShape();
    shape.setAsBox(0.1f, 0.1f);
    final FixtureDef fixtureDef = new FixtureDef();
    fixtureDef.shape = shape;
    fixtureDef.isSensor = true;
    final Fixture fixture = body.createFixture(fixtureDef);
    fixture.setUserData("finish");
    shape.dispose();
    return body;
  }
示例#30
0
  private void addBody(World world, float x, float y, boolean dirt) {
    final BodyDef bodyDef = new BodyDef();
    bodyDef.type = BodyDef.BodyType.StaticBody;
    final Body body = world.createBody(bodyDef);
    body.setTransform(x + 0.5f, y + 0.5f, 0);

    final CircleShape shape = new CircleShape();
    shape.setRadius(0.1f);
    final FixtureDef fixtureDef = new FixtureDef();
    fixtureDef.shape = shape;
    final Fixture fixture = body.createFixture(fixtureDef);
    shape.dispose();
    if (dirt) {
      dirts.add(fixture);
    }
  }