Esempio n. 1
0
  /**
   * makes space for a card (adds an invisible card)
   *
   * @param index index to make space for a card at
   */
  private void makeSpace(int index) {
    if (cards.getChildren().size > 0) {
      stopMakingSpace();
      invisibleCard = new Group();
      invisibleCard.setBounds(
          0, 0, cards.getChildren().get(0).getWidth(), cards.getChildren().get(0).getHeight());

      // save the old positions of the cards
      List<Vector2> oldPositions = getPositions(cards.getChildren());
      oldPositions.add(index, new Vector2(invisibleCard.getX(), invisibleCard.getY()));

      // Determine what the new positions would be
      // by adding them to a horizontal group and checking their positions
      HorizontalGroup newGroup =
          new HorizontalGroup()
              .space(calculateSpacing(cards.getChildren().size + 1, invisibleCard.getWidth()));
      newGroup.align(Align.bottom);

      cards.addActorAt(index, invisibleCard);

      while (cards.getChildren().size > 0) {
        newGroup.addActor(cards.getChildren().get(0));
      }
      newGroup.layout();

      List<Vector2> newPositions = getPositions(newGroup.getChildren());
      // calculate what is needed to center the cards
      float centerOffset = UIConstants.WORLD_WIDTH / 2 - newGroup.getPrefWidth() / 2;
      // remove them from the horizontal group and add them back to the normal group so it doesn't
      // try to move them around
      while (newGroup.getChildren().size > 0) {
        cards.addActor(newGroup.getChildren().get(0));
      }

      // interpolate all but the invisible card
      cards
          .getChildren()
          .get(index)
          .setPosition(newPositions.get(index).x, newPositions.get(index).y);
      cards.removeActor(invisibleCard);
      oldPositions.remove(index);
      newPositions.remove(index);

      interpolateActorPositions(
          cards.getChildren(),
          oldPositions,
          newPositions,
          centerOffset,
          Interpolation.linear,
          0.2f);
      cards.addActor(invisibleCard);
    }
  }
Esempio n. 2
0
  @Override
  public void act(float delta) {

    // coordinate fix
    // TODO to STAGE COORDS for relativ coords

    float relativeX = getX();
    float relativeY = getY();
    float relativeRotation = 0;

    Group currParent = this.getParent();
    while (currParent != null) {
      relativeX += currParent.getX();
      relativeY += currParent.getY();
      relativeRotation += currParent.getRotation();
      currParent = currParent.getParent();
    }

    if (lightObject != null) {

      float yy = 0;
      float xx = 0;

      if (relativeRotation != 0) {
        xx =
            getX() * MathUtils.cosDeg(relativeRotation)
                - getY() * MathUtils.sinDeg(relativeRotation);
        yy =
            getY() * MathUtils.cosDeg(relativeRotation)
                + getX() * MathUtils.sinDeg(relativeRotation);
        yy = getY() - yy;
        xx = getX() - xx;
      }
      lightObject.setPosition(relativeX - xx, relativeY - yy);
    }
    if (dataVO.type == LightType.CONE) {
      lightObject.setDirection(direction + relativeRotation);
    }
    // debugImg.setX(relativeX);
    // debugImg.setY(relativeY);
    super.act(delta);
  }
Esempio n. 3
0
  /** Adjusts the position and size of the given group to its children */
  public static void adjustGroup(Actor root) {
    if (!(root instanceof Group)) {
      return;
    }

    Group group = (Group) root;
    if (group.getChildren().size == 0) {
      return;
    }

    Vector2 origin = Pools.obtain(Vector2.class);
    Vector2 size = Pools.obtain(Vector2.class);
    Vector2 tmp3 = Pools.obtain(Vector2.class);
    Vector2 tmp4 = Pools.obtain(Vector2.class);

    calculateBounds(group.getChildren(), origin, size);

    /*
     * minX and minY are the new origin (new 0, 0), so everything inside the
     * group must be translated that much.
     */
    for (Actor actor : group.getChildren()) {
      actor.setPosition(actor.getX() - origin.x, actor.getY() - origin.y);
    }

    /*
     * Now, we calculate the current origin (0, 0) and the new origin (minX,
     * minY), and group is translated by that difference.
     */
    group.localToParentCoordinates(tmp3.set(0, 0));
    group.localToParentCoordinates(tmp4.set(origin.x, origin.y));
    tmp4.sub(tmp3);
    group.setBounds(group.getX() + tmp4.x, group.getY() + tmp4.y, size.x, size.y);
    group.setOrigin(size.x / 2.0f, size.y / 2.0f);

    Pools.free(origin);
    Pools.free(size);
    Pools.free(tmp3);
    Pools.free(tmp4);
  }
Esempio n. 4
0
  @Override
  public void render() {
    Gdx.gl.glViewport(0, 0, Gdx.graphics.getWidth(), Gdx.graphics.getHeight());
    Gdx.gl.glClearColor(0.2f, 0.2f, 0.2f, 1);
    Gdx.gl.glClear(GL20.GL_COLOR_BUFFER_BIT);

    if (Gdx.input.isTouched()) {
      stage.screenToStageCoordinates(stageCoords.set(Gdx.input.getX(), Gdx.input.getY()));
      Actor actor = stage.hit(stageCoords.x, stageCoords.y, true);
      if (actor instanceof Image)
        ((Image) actor)
            .setColor(
                (float) Math.random(),
                (float) Math.random(),
                (float) Math.random(),
                0.5f + 0.5f * (float) Math.random());
    }

    Array<Actor> actors = stage.getActors();
    int len = actors.size;
    if (rotateSprites) {
      for (int i = 0; i < len; i++) actors.get(i).rotateBy(Gdx.graphics.getDeltaTime() * 10);
    }

    scale += vScale * Gdx.graphics.getDeltaTime();
    if (scale > 1) {
      scale = 1;
      vScale = -vScale;
    }
    if (scale < 0.5f) {
      scale = 0.5f;
      vScale = -vScale;
    }

    len = images.size();
    for (int i = 0; i < len; i++) {
      Image img = images.get(i);
      if (rotateSprites) img.rotateBy(-40 * Gdx.graphics.getDeltaTime());
      else img.setRotation(0);

      if (scaleSprites) {
        img.setScale(scale);
      } else {
        img.setScale(1);
      }
      img.invalidate();
    }

    stage.draw();

    renderer.begin(ShapeType.Point);
    renderer.setColor(1, 0, 0, 1);
    len = actors.size;
    for (int i = 0; i < len; i++) {
      Group group = (Group) actors.get(i);
      renderer.point(group.getX() + group.getOriginX(), group.getY() + group.getOriginY(), 0);
    }
    renderer.end();

    fps.setText(
        "fps: "
            + Gdx.graphics.getFramesPerSecond()
            + ", actors "
            + images.size()
            + ", groups "
            + actors.size);
    ui.draw();
  }