Ejemplo n.º 1
0
    /**
     * Attempts to add an image to this {@link GLTexture}
     *
     * @param image The {@link Image} to add
     * @return The resulting {@link Texture}, or <code>null</code> if it didn't fit
     */
    public Texture addImage(Image image) {
      assert image.format == format;

      RectanglePacker.Rectangle rpr = packer.insert(image.getWidth(), image.getHeight(), image);

      if (rpr != null) {
        assert rpr.width == image.getWidth();
        assert rpr.height == image.getHeight();

        writeToTexture(rpr, image.getData());

        Vector2f bottomleft = new Vector2f(rpr.x, rpr.y);
        Vector2f topRight = new Vector2f(rpr.x + rpr.width, rpr.y + rpr.height);

        bottomleft.x /= size.getWidth();
        bottomleft.y /= size.getHeight();
        topRight.x /= size.getWidth();
        topRight.y /= size.getHeight();

        Texture t = new Texture(this, bottomleft, topRight, image);
        residentTextures.add(t);

        return t;
      } else {
        return null;
      }
    }
Ejemplo n.º 2
0
  private Vector2f converttoimagesizes(
      Vector2f oldvec, Vector2f offset, BufferedImage oldimage, BufferedImage newimage) {
    Vector2f vec = new Vector2f();

    vec.x = oldvec.x * oldimage.getWidth();
    vec.x += offset.x;
    vec.x /= newimage.getWidth();

    vec.y = oldvec.y * oldimage.getHeight();
    vec.y += offset.y;
    vec.y /= newimage.getHeight();

    return vec;
  }
Ejemplo n.º 3
0
 // Depending on the degrees at which this projectile was fired, the X and Y speeds can
 // be calculated using math...
 private void calculateSpeed(float degrees) {
   // Using simple trigonometry we can calculate the sides of a triangle by given (shooting) angel
   // and
   // the length of the hypotenuse, which we will keep as 1 for simplicity's sake
   // sin(a) = opposite / hypotenuse
   // cos(a) = adjacent / hypotenuse
   // -> lengths of the opposites and adjacent sides can be calculated by using the following
   // formula
   // (Hypotenuse is 1, so we can disregard it completely)
   // opposite = sin(a) / 1
   // adjacent = cos(a) / 1
   speed.x = (float) Math.cos(Math.toRadians(degrees)) * 20;
   speed.y = (float) Math.sin(Math.toRadians(degrees)) * 20;
 }
Ejemplo n.º 4
0
  private void calculateOrigin(int x, int y, float degrees) {
    // this is the middle point of the tank (and turret) from where the projectile was shot
    // since the projectile has to originate from the end of the turret and not the middle
    // point, we can calculate its actual starting position by knowing the angle (degrees)
    // and the size of the tank (radius of drawing circle) which is 150

    // Note: The hypotenuse is equal to the radius of the drawing circle, which is 150
    // -> Delta Y is then defined by sin(degrees) = opposite / 150
    // -> opposite = sin(degrees)*150 (and we need to add 150 because the drawing circle
    // originates from the screen's 0/0 and not the middle of the circle)

    // Delta X is the same as above, but with using cos(degrees) instead
    // we use 175 here to account for drawing over the turret, which we dont want to do
    position.x = x + (float) Math.cos(Math.toRadians(degrees)) * 175 + 150;
    position.y = y + (float) Math.sin(Math.toRadians(degrees)) * 175 + 150;
  }
  public void move(float scale) {
    Vector2f oldPosition = new Vector2f(position);

    // make our move
    position.y += velocity.y * scale;

    // figure our new bounds
    BoundingBox box = getBoundingBox();

    // check for floor collision
    int y = (int) Math.floor(box.bottomY);
    for (int x = (int) Math.floor(box.leftX); x < Math.ceil(box.rightX); x++) {
      TileMapTile tile = null;
      try {
        tile = map.getMap()[x][y];
      } catch (Exception e) {
      }

      if (tile != null && velocity.y <= 0) {

        WalkingEntity walker = this instanceof WalkingEntity ? (WalkingEntity) this : null;
        if (walker != null && !walker.dead && tile.isDangerous()) {
          ((WalkingEntity) this).damage(5);
          position.y = (int) oldPosition.y;
          velocity.y = 15f;
          velocity.x = -0.5f * velocity.x;
          break;
        }

        if (tile.isSolid() || tile.isPlatform()) {
          if (velocity.y < -1) {
            floorCollision();
            System.out.println(this.getClass().getSimpleName() + ": " + box + " " + this.position);
          }

          position.y = (int) oldPosition.y;
          velocity.y = 0f;

          // apply friction
          if (Math.abs(velocity.x) > 0) {
            float sign = Math.abs(velocity.x) / velocity.x;
            velocity.x -= sign * 9.8 * scale;

            // if we managed to reverse the direction of the horiz velocity, just stop
            if (velocity.x != 0 && sign != Math.abs(velocity.x) / velocity.x) {
              velocity.x = 0;
            }
          }
          break;
        }
      }
    }

    position.x += velocity.x * scale;

    // figure our new bounds
    box = getBoundingBox();

    // check for wall collision
    for (int x = (int) box.leftX; x <= box.rightX; x++) {
      for (y = (int) box.bottomY; y < box.topY; y++) {
        TileMapTile tile = null;
        try {
          tile = map.getMap()[x][y];
        } catch (Exception e) {
        }

        if (tile != null && tile.isSolid()) {
          wallCollision();

          // System.out.print(" WALL [" + x + ", " + y + "]");

          if (velocity.x > 0) position.x = (int) Math.ceil(oldPosition.x);
          else position.x = (int) Math.floor(oldPosition.x);

          velocity.x = 0f;

          break;
        }
      }
    }
  }
Ejemplo n.º 6
0
  @Override
  public void update(BaseObject parent) {
    Vector2f acceleration = ((GameObject) parent).getAcceleration();
    acceleration.set(0, 0);

    if (sys.keyboard.isKeyPressed(ButtonActions.MOVE_UP)) {
      acceleration.y = ACCELERATION;
    }
    if (sys.keyboard.isKeyPressed(ButtonActions.MOVE_DOWN)) {
      acceleration.y = -ACCELERATION;
    }
    if (sys.keyboard.isKeyPressed(ButtonActions.MOVE_LEFT)) {
      acceleration.x = -ACCELERATION;
    }
    if (sys.keyboard.isKeyPressed(ButtonActions.MOVE_RIGHT)) {
      acceleration.x = ACCELERATION;
    }

    if (sys.currentTime - lastTime < fireRate) {
      return;
    }

    // FIXME I really shouldn't be using hardcoded values to figure out where to
    // shoot the bullets from.
    // FIXME I also REALLY REALLY need to get my vectors sorted out so that I don't have to
    // resort to this ugliness.
    bulletVelocity.set(
        ((GameObject) parent).getVelocity().x, ((GameObject) parent).getVelocity().x);
    bulletPosition.set(16f, 0f);

    if (sys.keyboard.isKeyPressed(ButtonActions.FIRE_LEFT)) {
      bulletVelocity.x -= BULLET_VELOCITY;
      bulletPosition.y = 16f;
      bulletPosition.x = 0f;
    }

    if (sys.keyboard.isKeyPressed(ButtonActions.FIRE_RIGHT)) {
      bulletVelocity.x += BULLET_VELOCITY;
      bulletPosition.y = 16f;
      bulletPosition.x = 32f;
    }

    if (sys.keyboard.isKeyPressed(ButtonActions.FIRE_UP)) {
      bulletVelocity.y += BULLET_VELOCITY;
      bulletPosition.y = 32f;
    }

    if (sys.keyboard.isKeyPressed(ButtonActions.FIRE_DOWN)) {
      bulletVelocity.y -= BULLET_VELOCITY;
      bulletPosition.y = 0f;
    }

    if (bulletVelocity.x != 0f || bulletVelocity.y != 0f) {
      Vector2f position = ((GameObject) parent).getPosition();
      bulletPosition.x += position.x;
      bulletPosition.y += position.y;

      GameObject bullet = bulletPool.obtain();

      if (bullet != null) {
        bullet.setPosition(bulletPosition.x, bulletPosition.y);

        bulletVelocity.rotate(bulletCounter * spreadDegree);

        bullet.setVelocity(bulletVelocity.x, bulletVelocity.y);

        sys.manager.add(bullet);

        if (bulletCounter == spreadCount / 2) {
          bulletCounter = -bulletCounter;
        } else {
          bulletCounter++;
        }
      }
    }
    lastTime = sys.currentTime;
  }
Ejemplo n.º 7
0
 public void update() {
   position.x += speed.x;
   position.y += speed.y;
 }
Ejemplo n.º 8
0
 public void setUV(float[] uv) {
   unwrap.x = uv[0];
   unwrap.y = uv[1];
 }