コード例 #1
0
  private void tryMove() {
    bounds.x += vel.x;
    fetchCollidableRects();
    for (int i = 0; i < r.length; i++) {
      Rectangle rect = r[i];
      if (bounds.overlaps(rect)) {
        if (vel.x < 0) bounds.x = rect.x + rect.width + 0.01f;
        else bounds.x = rect.x - bounds.width - 0.01f;
        vel.x = 0;
      }
    }

    bounds.y += vel.y;
    fetchCollidableRects();
    for (int i = 0; i < r.length; i++) {
      Rectangle rect = r[i];
      if (bounds.overlaps(rect)) {
        if (vel.y < 0) {
          bounds.y = rect.y + rect.height + 0.01f;
        } else bounds.y = rect.y - bounds.height - 0.01f;
        vel.y = 0;
      }
    }

    pos.x = bounds.x - 0.2f;
    pos.y = bounds.y - 0.2f;
  }
コード例 #2
0
ファイル: Player.java プロジェクト: rlfriedm/Keres
  public void update(float delta, Array<Block> collisions) {
    // NOTE: figure out why legs go into block, could be order of checking for collisions/updating
    // position
    // position += velocity above collisions before changing the velocity
    acceleration.y = gravity;

    if (velocity.y < 0) onGround = false;

    if (delta
        > .1f) { // make sure time passed isn't great enough to cause clipping issues when window
                 // moved
      delta = .02f;
    }

    acceleration.scl(delta);
    velocity.add(acceleration);

    processCollisions(collisions);

    if (Math.abs(velocity.x) < .05) velocity.x = 0;
    else {
      velocity.x *= friction;
    }

    if (velocity.x > maxVel) velocity.x = maxVel;
    if (velocity.x < -maxVel) velocity.x = -maxVel;

    position.add(velocity.cpy().scl(delta));
    bounds.x = position.x;
    bounds.y = position.y;
    stateTime += delta;

    setPosition(getPosition());
  }
コード例 #3
0
  public GameScreen(final Drop gam) {
    this.game = gam;

    // load the images for the droplet and the bucket, 64x64 pixels each
    dropImage = new Texture(Gdx.files.internal("droplet.png"));
    bucketImage = new Texture(Gdx.files.internal("bucket.png"));

    // load the drop sound effect and the rain background "music"
    dropSound = Gdx.audio.newSound(Gdx.files.internal("drop.wav"));
    rainMusic = Gdx.audio.newMusic(Gdx.files.internal("rain.mp3"));
    rainMusic.setLooping(true);

    // create the camera and the SpriteBatch
    camera = new OrthographicCamera();
    camera.setToOrtho(false, 800, 480);

    // create a Rectangle to logically represent the bucket
    bucket = new Rectangle();
    bucket.x = 800 / 2 - 64 / 2; // center the bucket horizontally
    bucket.y = 20; // bottom left corner of the bucket is 20 pixels above
    // the bottom screen edge
    bucket.width = 64;
    bucket.height = 64;

    // create the raindrops array and spawn the first raindrop
    raindrops = new Array<Rectangle>();
    spawnRaindrop();
  }
コード例 #4
0
  @Override
  public void create() {
    // load the images for the droplet and the bucket, 64x64 pixels each
    dropImage = new Texture(Gdx.files.internal("bottle.png"));
    bucketImage = new Texture(Gdx.files.internal("bucket_black.png"));
    brokenBucketImage = new Texture(Gdx.files.internal("bottle_broken.png"));

    // load the drop sound effect and the rain background "music"
    //        dropSound = Gdx.audio.newSound(Gdx.files.internal("drop.wav"));
    //        rainMusic = Gdx.audio.newMusic(Gdx.files.internal("rain.mp3"));

    // start the playback of the background music immediately
    //        rainMusic.setLooping(true);
    //        rainMusic.play();

    // create the camera and the SpriteBatch
    camera = new OrthographicCamera();
    camera.setToOrtho(false, 800, 480);
    batch = new SpriteBatch();

    // create a Rectangle to logically represent the bucket
    bucket = new Rectangle();
    bucket.x = 800 / 2 - 64 / 2; // center the bucket horizontally
    bucket.y = 20; // bottom left corner of the bucket is 20 pixels above the bottom screen edge
    bucket.width = 64;
    bucket.height = 80;

    // create the raindrops array and spawn the first raindrop
    raindrops = new Array<Rectangle>();
    brokenBottles = new Array<Rectangle>();
    spawnRaindrop();
  }
コード例 #5
0
ファイル: Drop.java プロジェクト: hecao/testgithub
  @Override
  public void render() {
    // clear the screen with a dark blue color. The
    // arguments to glClearColor are the red, green
    // blue and alpha component in the range [0,1]
    // of the color to be used to clear the screen.
    Gdx.gl.glClearColor(0, 0, 0.2f, 1);
    Gdx.gl.glClear(GL10.GL_COLOR_BUFFER_BIT);

    // tell the camera to update its matrices.
    camera.update();

    // tell the SpriteBatch to render in the
    // coordinate system specified by the camera.
    batch.setProjectionMatrix(camera.combined);

    // begin a new batch and draw the bucket and
    // all drops
    batch.begin();
    batch.draw(bucketImage, bucket.x, bucket.y);
    for (Rectangle raindrop : raindrops) {
      batch.draw(dropImage, raindrop.x, raindrop.y);
    }
    batch.end();
    //

    // process user input
    if (Gdx.input.isTouched()) {
      Vector3 touchPos = new Vector3();
      touchPos.set(Gdx.input.getX(), Gdx.input.getY(), 0);
      camera.unproject(touchPos);
      bucket.x = touchPos.x - 48 / 2;
    }
    if (Gdx.input.isKeyPressed(Keys.LEFT)) bucket.x -= 200 * Gdx.graphics.getDeltaTime();
    if (Gdx.input.isKeyPressed(Keys.RIGHT)) bucket.x += 200 * Gdx.graphics.getDeltaTime();

    // make sure the bucket stays within the screen bounds
    if (bucket.x < 0) bucket.x = 0;
    if (bucket.x > 800 - 48) bucket.x = 800 - 48;

    // commit

    // check if we need to create a new raindrop
    if (TimeUtils.nanoTime() - lastDropTime > 1000000000) spawnRaindrop();

    // move the raindrops, remove any that are beneath the bottom edge of
    // the screen or that hit the bucket. In the later case we play back
    // a sound effect as well.
    Iterator<Rectangle> iter = raindrops.iterator();
    while (iter.hasNext()) {
      Rectangle raindrop = iter.next();
      raindrop.y -= 200 * Gdx.graphics.getDeltaTime();
      if (raindrop.y + 48 < 0) iter.remove();
      if (raindrop.overlaps(bucket)) {
        dropSound.play();
        iter.remove();
      }
    }
  }
コード例 #6
0
ファイル: Car.java プロジェクト: javakaian/Oyun
  public void update(float delta) {

    collisionRect.x = position.x;
    collisionRect.y = position.y;
    collisionRect.width = size.x;
    collisionRect.height = size.y;

    position.add(speed.cpy().scl(delta));
  }
コード例 #7
0
 private void spawnRaindrop() {
   Rectangle raindrop = new Rectangle();
   raindrop.x = MathUtils.random(0, 800 - 64);
   raindrop.y = 480;
   raindrop.width = 32;
   raindrop.height = 128;
   raindrops.add(raindrop);
   lastDropTime = TimeUtils.nanoTime();
 }
コード例 #8
0
  public ShopTable(float x, float y, float velX, float velY, int width, int height) {
    super(x, y, velX, velY, width, height);

    rect.x = x;
    rect.y = y;
    rect.width = width;
    rect.height = height;

    item1 = new ShopPickup(x + 20, y + 32, 0, 0, 32, 32);
    item2 = new ShopPickup(x + 52, y + 32, 0, 0, 32, 32);
    item3 = new ShopPickup(x + 84, y + 32, 0, 0, 32, 32);
  }
コード例 #9
0
ファイル: Functions.java プロジェクト: sparky8251/libgdxtut
  public static long spawnRaindrop(Array<Rectangle> raindrops) {

    // create a raindrop and randomly place it at the top of the screen
    Rectangle raindrop = new Rectangle();
    raindrop.x = MathUtils.random(0, 800 - 64);
    raindrop.y = 480;
    raindrop.width = 64;
    raindrop.height = 64;
    raindrops.add(raindrop);

    return TimeUtils.nanoTime();
  }
コード例 #10
0
ファイル: Player.java プロジェクト: ochi12/Not-There-Yet
  public boolean collide(Rectangle body) {
    boolean collide = false;
    if (body.overlaps(AABB)) {
      collide = true;

      float bodyMidX = body.x + (body.width / 2);
      float bodyMidY = body.y + (body.height / 2);

      float AABBMidX = AABB.x + (AABB.width / 2);
      float AABBMidY = AABB.y + (AABB.height / 2);

      AABB.x -= deltaPos.x;
      AABB.y -= deltaPos.y;

      AABB.x += deltaPos.x;
      if (AABB.overlaps(body)) {
        if (AABBMidX - deltaPos.x > bodyMidX) {
          AABB.x = (int) body.x + (int) body.width;
        } else {
          AABB.x = body.x - AABB.width;
        }
      }

      AABB.y += deltaPos.y;
      if (AABB.overlaps(body)) {
        if (AABBMidY - deltaPos.y > bodyMidY) {
          AABB.y = body.y + body.height;
        } else {
          AABB.y = body.y - AABB.height;
        }
      }

      position.x = AABB.x - 14;
      position.y = AABB.y - 14;
    }
    return collide;
  }
コード例 #11
0
ファイル: Drop.java プロジェクト: jmmrcp/Libgdx
  @Override
  public void render() {

    Gdx.gl.glClearColor(0, 0, 0.2f, 1);

    Gdx.gl.glClear(GL20.GL_COLOR_BUFFER_BIT);

    camera.update();

    batch.setProjectionMatrix(camera.combined);

    batch.begin();
    batch.draw(bucketImage, bucket.x, bucket.y);

    for (Rectangle raindrop : raindrops) {
      batch.draw(dropImage, raindrop.x, raindrop.y);
    }

    batch.end();

    if (Gdx.input.isTouched()) {
      Vector3 touchPos = new Vector3();
      touchPos.set(Gdx.input.getX(), Gdx.input.getY(), 0);
      camera.unproject(touchPos);
      bucket.x = touchPos.x - 64 / 2;
    }
    if (Gdx.input.isKeyPressed(Input.Keys.LEFT)) bucket.x -= 200 * Gdx.graphics.getDeltaTime();
    if (Gdx.input.isKeyPressed(Input.Keys.RIGHT)) bucket.x += 200 * Gdx.graphics.getDeltaTime();

    // make sure the bucket stays within the screen bounds
    if (bucket.x < 0) bucket.x = 0;
    if (bucket.x > 800 - 64) bucket.x = 800 - 64;

    if (TimeUtils.nanoTime() - lastDropTime > 1000000000) {
      spawnRaindrop();
    }

    Iterator<Rectangle> iter = raindrops.iterator();
    while (iter.hasNext()) {
      Rectangle raindrop = iter.next();
      raindrop.y -= 200 * Gdx.graphics.getDeltaTime();
      if (raindrop.y + 64 < 0) iter.remove();
      if (raindrop.overlaps(bucket)) {
        dropSound.play();
        iter.remove();
      }
    }
  }
コード例 #12
0
  public void getPlatformCollisions(float xx, float yy) {
    m_collisionPlatform = null;
    m_boundingBox.x = this.getBoundingRectangle().getX() + m_boundOffX;
    m_boundingBox.y = this.getBoundingRectangle().getY();

    for (m_iter = 0; m_iter < m_platforms.size(); m_iter++) {
      PlatformSprite p = m_platforms.get(m_iter);
      if (p.isCollidable()) {
        if (Intersector.overlaps(p.getBoundingRectangle(), m_boundingBox)) {
          // hit a platform
          m_collisionPlatform = p;
          break;
        }
      }
    }
  }
コード例 #13
0
ファイル: Game.java プロジェクト: saitestop/myfiyGame
 @Override
 public void create() {
   dropImage = new Texture(Gdx.files.internal("data/generic_water.png"));
   bucketImage = new Texture(Gdx.files.internal("data/bucket.png"));
   camera = new OrthographicCamera();
   camera.setToOrtho(false, 800, 480);
   batch = new SpriteBatch();
   bucket = new Rectangle();
   bucket.x = 800 / 2 - 48 / 2; // center the bucket horizontally
   bucket.y = 20; // bottom left corner of the bucket is 20 pixels above
   // the bottom screen edge
   bucket.width = 48;
   bucket.height = 48;
   raindrops = new Array<Rectangle>();
   spawnRaindrop();
   System.out.println(dropImage.getWidth() + "  " + dropImage.getHeight());
 }
コード例 #14
0
ファイル: Drop.java プロジェクト: ryanmaund-dev/Libgdx-Drop
  /*
   *  The create() method initializes our all of our resources and loads them into memory before the rest of the game is run
   *  This method is the first called after the entry point(based on platform) and is only called once.
   *  This is also a convenient place to put boiler plate code for the rest of the game that we only want ran once on startup.
   *
   *  NOTE: Gdx.files.internal() defaults to the assets put into the Android project folder and takes String "filename.filetype" as a parameter.
   */
  @Override
  public void create() {
    dropImage = new Texture(Gdx.files.internal("droplet.png"));
    bucketImage = new Texture(Gdx.files.internal("bucket.png"));

    dropSound = Gdx.audio.newSound(Gdx.files.internal("droplet.mp3"));
    rainMusic = Gdx.audio.newMusic(Gdx.files.internal("rain.mp3"));

    rainMusic.setLooping(true); // set rainMusic (rain.mp3) to play over and over again
    rainMusic.play(); // starts the rainMusic audio

    camera = new OrthographicCamera(); // initialize camera, part of opengl/opengl-es.

    /*
     * sets the camera to 2 dimensional plane. Seems redundant since we are using OrthographicCamera() object.
     * Note: investigate camera settings
     */
    camera.setToOrtho(false, 800, 400);

    batch = new SpriteBatch(); // new sprite batch used in render() ie.Draws images.

    /*
     * set bucket properties. Use Rectangle object to represent bucket, track position and set size
     * used for collision detection with raindrop objects
     *
     */
    bucket = new Rectangle();
    bucket.x = 800 / 2 - 64 / 2;
    bucket.y = 20;
    bucket.width = 64;
    bucket.height = 64;

    /*
     * initializes Libgdx Array.
     * Note: Investigate how  Libgdx Array is different than regular Java Array.
     */
    raindrops = new Array<Rectangle>();

    /*
     * creates new raindrops to be drawn for our game. This method is called here to
     * start the first raindrop.
     */
    spawnRaindrop();
  }
コード例 #15
0
  // This gets called once (Constructor)
  public GameScreen(Skyfall gameRef) {
    Gdx.app.log("MY TAG", "in gamescreen constructor");

    this.game = gameRef;

    // These variables will adjust as gameTime passes
    dropSpeed = 200;
    pastGameTime = 0;
    respawnTime = 1000000000;

    // create a Rectangle to represent the paddle
    paddle = new Rectangle();
    paddle.x = GameUtilities.CENTER_X - 70; // center the paddle horizontally
    paddle.y = 50; // bottom left corner of the paddle is 20px above the bottom of the screen edge
    paddle.width = 140;
    paddle.height = 160;

    // create the circles array and spawn the first circle
    circles = new ArrayList<Circle>();
    spawnCircle();
  }
コード例 #16
0
  /**
   * Obtains the actor at (x,y) with TOLERANCE.
   *
   * <p>Creates a square with size = TOLERANCE and checks:
   *
   * <p>1. if some vertex from the TOLERANCE square is inside an actor bbox 2. if some actor bbox
   * vertex is inside the TOLERANCE square
   */
  public InteractiveActor getInteractiveActorAtWithTolerance(float x, float y, float tolerance) {

    List<SceneLayer> layers = getLayers();

    tmpToleranceRect.x = x - tolerance / 2;
    tmpToleranceRect.y = y - tolerance / 2;
    tmpToleranceRect.width = tolerance;
    tmpToleranceRect.height = tolerance;

    for (SceneLayer layer : layers) {

      if (!layer.isVisible()) continue;

      // Obtain actors in reverse (close to camera)
      for (int l = layer.getActors().size() - 1; l >= 0; l--) {
        BaseActor a = layer.getActors().get(l);

        if (a instanceof InteractiveActor && ((InteractiveActor) a).hasInteraction()) {

          if (a.hit(x, y)
              || a.hit(tmpToleranceRect.x, tmpToleranceRect.y)
              || a.hit(tmpToleranceRect.x + tmpToleranceRect.width, tmpToleranceRect.y)
              || a.hit(tmpToleranceRect.x, tmpToleranceRect.y + tmpToleranceRect.height)
              || a.hit(
                  tmpToleranceRect.x + tmpToleranceRect.width,
                  tmpToleranceRect.y + tmpToleranceRect.height)) return (InteractiveActor) a;

          float[] verts = a.getBBox().getTransformedVertices();
          for (int i = 0; i < verts.length; i += 2) {
            float vx = verts[i];
            float vy = verts[i + 1];

            if (tmpToleranceRect.contains(vx, vy)) return (InteractiveActor) a;
          }
        }
      }
    }

    return null;
  }
コード例 #17
0
ファイル: Drop.java プロジェクト: jmmrcp/Libgdx
  @Override
  public void create() {
    batch = new SpriteBatch();
    camera = new OrthographicCamera();
    camera.setToOrtho(false, 800, 480);
    // img = new Texture("badlogic.jpg");
    dropImage = new Texture(Gdx.files.internal("droplet.png"));
    bucketImage = new Texture(Gdx.files.internal("bucket.png"));

    bucket = new Rectangle();
    bucket.x = 800 / 2 - 64 / 2;
    bucket.y = 20;
    bucket.width = 64;
    bucket.width = 64;

    raindrops = new Array<Rectangle>();
    spawnRaindrop();

    dropSound = Gdx.audio.newSound(Gdx.files.internal("drop.wav"));
    rainMusic = Gdx.audio.newMusic(Gdx.files.internal("rain.mp3"));

    rainMusic.setLooping(true);
    rainMusic.play();
  }
コード例 #18
0
ファイル: GameObject.java プロジェクト: TisKarl/ProgGame
 private void handleCollision(Rectangle col) {
   float temp = position.x;
   collisionArea.x = oldPosition.x;
   // just x
   if (collisionArea.overlaps(col) == false) {
     position.x = oldPosition.x;
     return;
   }
   collisionArea.x = temp;
   temp = position.y;
   collisionArea.y = oldPosition.y;
   // just y
   if (collisionArea.overlaps(col) == false) {
     position.y = oldPosition.y;
     return;
   }
   // both x and y
   collisionArea.x = oldPosition.y;
   position.x = oldPosition.x;
   position.y = oldPosition.y;
   if (collisionArea.overlaps(col)) {
     System.out.println("ERROR! collision");
   }
 }
コード例 #19
0
ファイル: GameObject.java プロジェクト: TisKarl/ProgGame
 public Rectangle getCollisionArea() {
   collisionArea.x = position.x;
   collisionArea.y = position.y;
   return collisionArea;
 }
コード例 #20
0
ファイル: whiteBall.java プロジェクト: pajdak3/DefendTheGoal
 public void setY(float y) {
   loc.y = y;
 }
コード例 #21
0
 public void update(float delta) {
   position.add(speed * delta, 0);
   hitbox.x = position.x;
   hitbox.y = position.y;
 }
コード例 #22
0
ファイル: Ball.java プロジェクト: matheusbodo/TDC2012
 public void updateStartPosition(Platform platform) {
   Rectangle platformArea = platform.getArea();
   area.x = platformArea.x + (platformArea.width - area.width) / 2;
   area.y = platformArea.y + platformArea.height;
 }
コード例 #23
0
ファイル: Ball.java プロジェクト: matheusbodo/TDC2012
 public void hitTopWall() {
   area.y -= (area.y + area.height) - GameBoard.HEIGHT;
   hitObjectUp();
 }
コード例 #24
0
ファイル: Player.java プロジェクト: ochi12/Not-There-Yet
 private void updateAABB() {
   AABB.x = position.x + 14;
   AABB.y = position.y + 14;
 }
コード例 #25
0
ファイル: Ball.java プロジェクト: matheusbodo/TDC2012
 public void update(float deltaTime) {
   area.x = area.x + deltaTime * HORIZONTAL_SPEED * horizontalDirection.getMultiplier();
   area.y = area.y + deltaTime * VERTICAL_SPEED * verticalDirection.getMultiplier();
 }
コード例 #26
0
 public void updateBounds() {
   recBounds.x = fX - fWidth / 2;
   recBounds.y = fY - fHeight / 2;
   recBounds.width = fWidth;
   recBounds.height = fHeight;
 }
コード例 #27
0
ファイル: ScrollPane.java プロジェクト: xYaW/libgdx
  @Override
  public void draw(SpriteBatch batch, float parentAlpha) {
    if (widget == null) return;

    validate();

    // Setup transform for this group.
    applyTransform(batch, computeTransform());

    if (scrollX)
      hKnobBounds.x =
          hScrollBounds.x + (int) ((hScrollBounds.width - hKnobBounds.width) * getScrollPercentX());
    if (scrollY)
      vKnobBounds.y =
          vScrollBounds.y
              + (int) ((vScrollBounds.height - vKnobBounds.height) * (1 - getScrollPercentY()));

    // Calculate the widget's position depending on the scroll state and available widget area.
    float y = widgetAreaBounds.y;
    if (!scrollY) y -= (int) maxY;
    else y -= (int) (maxY - visualAmountY);

    if (!fadeScrollBars && scrollbarsOnTop && scrollX) {
      float scrollbarHeight = 0;
      if (style.hScrollKnob != null) scrollbarHeight = style.hScrollKnob.getMinHeight();
      if (style.hScroll != null)
        scrollbarHeight = Math.max(scrollbarHeight, style.hScroll.getMinHeight());
      y += scrollbarHeight;
    }

    float x = widgetAreaBounds.x;
    if (scrollX) x -= (int) visualAmountX;
    widget.setPosition(x, y);

    if (widget instanceof Cullable) {
      widgetCullingArea.x = -widget.getX() + widgetAreaBounds.x;
      widgetCullingArea.y = -widget.getY() + widgetAreaBounds.y;
      widgetCullingArea.width = widgetAreaBounds.width;
      widgetCullingArea.height = widgetAreaBounds.height;
      ((Cullable) widget).setCullingArea(widgetCullingArea);
    }

    // Caculate the scissor bounds based on the batch transform, the available widget area and the
    // camera transform. We need to
    // project those to screen coordinates for OpenGL ES to consume.
    getStage().calculateScissors(widgetAreaBounds, scissorBounds);

    // Draw the background ninepatch.
    Color color = getColor();
    batch.setColor(color.r, color.g, color.b, color.a * parentAlpha);
    if (style.background != null) style.background.draw(batch, 0, 0, getWidth(), getHeight());
    batch.flush();

    // Enable scissors for widget area and draw the widget.
    if (ScissorStack.pushScissors(scissorBounds)) {
      drawChildren(batch, parentAlpha);
      ScissorStack.popScissors();
    }

    // Render scrollbars and knobs on top.
    batch.setColor(
        color.r,
        color.g,
        color.b,
        color.a * parentAlpha * Interpolation.fade.apply(fadeAlpha / fadeAlphaSeconds));
    if (scrollX && scrollY) {
      if (style.corner != null) {
        style.corner.draw(
            batch,
            hScrollBounds.x + hScrollBounds.width,
            hScrollBounds.y,
            vScrollBounds.width,
            vScrollBounds.y);
      }
    }
    if (scrollX) {
      if (style.hScroll != null)
        style.hScroll.draw(
            batch, hScrollBounds.x, hScrollBounds.y, hScrollBounds.width, hScrollBounds.height);
      if (style.hScrollKnob != null)
        style.hScrollKnob.draw(
            batch, hKnobBounds.x, hKnobBounds.y, hKnobBounds.width, hKnobBounds.height);
    }
    if (scrollY) {
      if (style.vScroll != null)
        style.vScroll.draw(
            batch, vScrollBounds.x, vScrollBounds.y, vScrollBounds.width, vScrollBounds.height);
      if (style.vScrollKnob != null)
        style.vScrollKnob.draw(
            batch, vKnobBounds.x, vKnobBounds.y, vKnobBounds.width, vKnobBounds.height);
    }

    resetTransform(batch);
  }
コード例 #28
0
ファイル: ScrollPane.java プロジェクト: xYaW/libgdx
  public void layout() {
    final Drawable bg = style.background;
    final Drawable hScrollKnob = style.hScrollKnob;
    final Drawable vScrollKnob = style.vScrollKnob;

    float bgLeftWidth = 0, bgRightWidth = 0, bgTopHeight = 0, bgBottomHeight = 0;
    if (bg != null) {
      bgLeftWidth = bg.getLeftWidth();
      bgRightWidth = bg.getRightWidth();
      bgTopHeight = bg.getTopHeight();
      bgBottomHeight = bg.getBottomHeight();
    }

    float width = getWidth();
    float height = getHeight();

    float scrollbarHeight = 0;
    if (hScrollKnob != null) scrollbarHeight = hScrollKnob.getMinHeight();
    if (style.hScroll != null)
      scrollbarHeight = Math.max(scrollbarHeight, style.hScroll.getMinHeight());
    float scrollbarWidth = 0;
    if (vScrollKnob != null) scrollbarWidth = vScrollKnob.getMinWidth();
    if (style.vScroll != null)
      scrollbarWidth = Math.max(scrollbarWidth, style.vScroll.getMinWidth());

    // Get available space size by subtracting background's padded area.
    areaWidth = width - bgLeftWidth - bgRightWidth;
    areaHeight = height - bgTopHeight - bgBottomHeight;

    if (widget == null) return;

    // Get widget's desired width.
    float widgetWidth, widgetHeight;
    if (widget instanceof Layout) {
      Layout layout = (Layout) widget;
      widgetWidth = layout.getPrefWidth();
      widgetHeight = layout.getPrefHeight();
    } else {
      widgetWidth = widget.getWidth();
      widgetHeight = widget.getHeight();
    }

    // Determine if horizontal/vertical scrollbars are needed.
    scrollX = forceScrollX || (widgetWidth > areaWidth && !disableX);
    scrollY = forceScrollY || (widgetHeight > areaHeight && !disableY);

    boolean fade = fadeScrollBars;
    if (!fade) {
      // Check again, now taking into account the area that's taken up by any enabled scrollbars.
      if (scrollY) {
        areaWidth -= scrollbarWidth;
        if (!scrollX && widgetWidth > areaWidth && !disableX) {
          scrollX = true;
        }
      }
      if (scrollX) {
        areaHeight -= scrollbarHeight;
        if (!scrollY && widgetHeight > areaHeight && !disableY) {
          scrollY = true;
          areaWidth -= scrollbarWidth;
        }
      }
    }

    // Set the widget area bounds.
    widgetAreaBounds.set(bgLeftWidth, bgBottomHeight, areaWidth, areaHeight);

    if (fade) {
      // Make sure widget is drawn under fading scrollbars.
      if (scrollX) areaHeight -= scrollbarHeight;
      if (scrollY) areaWidth -= scrollbarWidth;
    } else {
      if (scrollbarsOnTop) {
        // Make sure widget is drawn under non-fading scrollbars.
        if (scrollX) widgetAreaBounds.height += scrollbarHeight;
        if (scrollY) widgetAreaBounds.width += scrollbarWidth;
      } else {
        // Offset widget area y for horizontal scrollbar.
        if (scrollX) {
          if (hScrollOnBottom) {
            widgetAreaBounds.y += scrollbarHeight;
          } else {
            widgetAreaBounds.y = 0;
          }
        }
        // Offset widget area x for vertical scrollbar.
        if (scrollY) {
          if (vScrollOnRight) {
            widgetAreaBounds.x = 0;
          } else {
            widgetAreaBounds.x += scrollbarWidth;
          }
        }
      }
    }

    // If the widget is smaller than the available space, make it take up the available space.
    widgetWidth = disableX ? width : Math.max(areaWidth, widgetWidth);
    widgetHeight = disableY ? height : Math.max(areaHeight, widgetHeight);

    maxX = widgetWidth - areaWidth;
    maxY = widgetHeight - areaHeight;
    if (fade) {
      // Make sure widget is drawn under fading scrollbars.
      if (scrollX) maxY -= scrollbarHeight;
      if (scrollY) maxX -= scrollbarWidth;
    }
    scrollX(MathUtils.clamp(amountX, 0, maxX));
    scrollY(MathUtils.clamp(amountY, 0, maxY));

    // Set the bounds and scroll knob sizes if scrollbars are needed.
    if (scrollX) {
      if (hScrollKnob != null) {
        float hScrollHeight =
            style.hScroll != null ? style.hScroll.getMinHeight() : hScrollKnob.getMinHeight();
        // the small gap where the two scroll bars intersect might have to flip from right to left
        float boundsX, boundsY;
        if (vScrollOnRight) {
          boundsX = bgLeftWidth;
        } else {
          boundsX = bgLeftWidth + scrollbarWidth;
        }
        // bar on the top or bottom
        if (hScrollOnBottom) {
          boundsY = bgBottomHeight;
        } else {
          boundsY = height - bgTopHeight - hScrollHeight;
        }
        hScrollBounds.set(boundsX, boundsY, areaWidth, hScrollHeight);
        hKnobBounds.width =
            Math.max(
                hScrollKnob.getMinWidth(), (int) (hScrollBounds.width * areaWidth / widgetWidth));
        hKnobBounds.height = hScrollKnob.getMinHeight();
        hKnobBounds.x =
            hScrollBounds.x
                + (int) ((hScrollBounds.width - hKnobBounds.width) * getScrollPercentX());
        hKnobBounds.y = hScrollBounds.y;
      } else {
        hScrollBounds.set(0, 0, 0, 0);
        hKnobBounds.set(0, 0, 0, 0);
      }
    }
    if (scrollY) {
      if (vScrollKnob != null) {
        float vScrollWidth =
            style.vScroll != null ? style.vScroll.getMinWidth() : vScrollKnob.getMinWidth();
        // the small gap where the two scroll bars intersect might have to flip from bottom to top
        float boundsX, boundsY;
        if (hScrollOnBottom) {
          boundsY = height - bgTopHeight - areaHeight;
        } else {
          boundsY = bgBottomHeight;
        }
        // bar on the left or right
        if (vScrollOnRight) {
          boundsX = width - bgRightWidth - vScrollWidth;
        } else {
          boundsX = bgLeftWidth;
        }
        vScrollBounds.set(boundsX, boundsY, vScrollWidth, areaHeight);
        vKnobBounds.width = vScrollKnob.getMinWidth();
        vKnobBounds.height =
            Math.max(
                vScrollKnob.getMinHeight(),
                (int) (vScrollBounds.height * areaHeight / widgetHeight));
        if (vScrollOnRight) {
          vKnobBounds.x = width - bgRightWidth - vScrollKnob.getMinWidth();
        } else {
          vKnobBounds.x = bgLeftWidth;
        }
        vKnobBounds.y =
            vScrollBounds.y
                + (int) ((vScrollBounds.height - vKnobBounds.height) * (1 - getScrollPercentY()));
      } else {
        vScrollBounds.set(0, 0, 0, 0);
        vKnobBounds.set(0, 0, 0, 0);
      }
    }

    widget.setSize(widgetWidth, widgetHeight);
    if (widget instanceof Layout) ((Layout) widget).validate();
  }
コード例 #29
0
ファイル: Player.java プロジェクト: rlfriedm/Keres
 public void setPosition(Vector2 position) {
   this.position = position;
   bounds.x = position.x;
   bounds.y = position.y;
 }
コード例 #30
0
  @Override
  public void render(float delta) {
    // clear the screen with a dark blue color. The
    // arguments to glClearColor are the red, green
    // blue and alpha component in the range [0,1]
    // of the color to be used to clear the screen.
    Gdx.gl.glClearColor(0, 0, 0.2f, 1);
    Gdx.gl.glClear(GL20.GL_COLOR_BUFFER_BIT);

    // tell the camera to update its matrices.
    camera.update();

    // tell the SpriteBatch to render in the
    // coordinate system specified by the camera.
    game.batch.setProjectionMatrix(camera.combined);

    // Implement pause/resume
    if (Gdx.input.isKeyJustPressed(Keys.ESCAPE)) {
      if (state == State.RUN) {
        setGameState(State.PAUSE);
      } else {
        setGameState(State.RUN);
      }
    }

    // begin a new batch and draw the bucket and
    // all drops
    game.batch.begin();
    game.font.draw(game.batch, "Drops Collected: " + dropsGathered, 0, 480);
    game.batch.draw(bucketImage, bucket.x, bucket.y);
    for (Rectangle raindrop : raindrops) {
      game.batch.draw(dropImage, raindrop.x, raindrop.y);
    }
    game.batch.end();

    // Implement pause/resume
    switch (state) {
      case RUN:
        // process user input
        if (Gdx.input.isTouched()) {
          Vector3 touchPos = new Vector3();
          touchPos.set(Gdx.input.getX(), Gdx.input.getY(), 0);
          camera.unproject(touchPos);
          bucket.x = touchPos.x - 64 / 2;
        }
        if (Gdx.input.isKeyPressed(Keys.LEFT)) bucket.x -= 200 * Gdx.graphics.getDeltaTime();
        if (Gdx.input.isKeyPressed(Keys.RIGHT)) bucket.x += 200 * Gdx.graphics.getDeltaTime();

        // make sure the bucket stays within the screen bounds
        if (bucket.x < 0) bucket.x = 0;
        if (bucket.x > 800 - 64) bucket.x = 800 - 64;

        // check if we need to create a new raindrop
        if (TimeUtils.nanoTime() - lastDropTime > 1000000000) spawnRaindrop();

        // move the raindrops, remove any that are beneath the bottom edge of
        // the screen or that hit the bucket. In the later case we increase the
        // value our drops counter and add a sound effect.
        Iterator<Rectangle> iter = raindrops.iterator();
        while (iter.hasNext()) {
          Rectangle raindrop = iter.next();
          raindrop.y -= 200 * Gdx.graphics.getDeltaTime();
          if (raindrop.y + 64 < 0) iter.remove();
          if (raindrop.overlaps(bucket)) {
            dropsGathered++;
            dropSound.play();
            iter.remove();
          }
        }
        break;

      case PAUSE:
        break;
    } // end switch
  }