/**
  * Create a new BackgroundPainter. The tiles used for painting will be cut non-uniformly, so that
  * the grid will be placed according to the given dimensions.
  *
  * @param image image name
  * @param leftWidth width of the left tile row
  * @param centerWidth width of the center tile row
  * @param topHeight height of the top tile row
  * @param centerHeight height of the center tile row
  */
 public BackgroundPainter(
     String image, int leftWidth, int centerWidth, int topHeight, int centerHeight) {
   tileWidth = 0;
   tileHeight = 0;
   SpriteStore store = SpriteStore.get();
   Sprite mother = store.getSprite(image);
   images = new Sprite[9];
   int[] widths = new int[3];
   widths[0] = leftWidth;
   widths[1] = centerWidth;
   widths[2] = mother.getWidth() - leftWidth - centerWidth;
   int[] heights = new int[3];
   heights[0] = topHeight;
   heights[1] = centerHeight;
   heights[2] = mother.getHeight() - topHeight - centerHeight;
   int x = 0;
   int y = 0;
   int i = 0;
   for (int yInd = 0; yInd < 3; yInd++) {
     for (int xInd = 0; xInd < 3; xInd++) {
       images[i] = store.getTile(mother, x, y, widths[xInd], heights[yInd]);
       x += widths[xInd];
       i++;
     }
     x = 0;
     y += heights[yInd];
   }
 }
  /**
   * Populate named state sprites.
   *
   * @param map The map to populate.
   */
  @Override
  protected void buildSprites(Door entity, final Map<Object, Sprite> map) {
    final String name = entity.getEntityClass();

    final SpriteStore store = SpriteStore.get();

    if (name == null) {
      width = IGameScreen.SIZE_UNIT_PIXELS;
      height = IGameScreen.SIZE_UNIT_PIXELS;

      final Sprite emptySprite = store.getEmptySprite(width, height);

      map.put(STATE_OPEN, emptySprite);
      map.put(STATE_CLOSED, emptySprite);
    } else {
      ZoneInfo info = ZoneInfo.get();
      final Sprite tiles =
          store.getModifiedSprite(translate(name), info.getZoneColor(), info.getColorMethod());

      width = tiles.getWidth();
      height = tiles.getHeight() / 2;

      map.put(STATE_OPEN, store.getTile(tiles, 0, 0, width, height));
      map.put(STATE_CLOSED, store.getTile(tiles, 0, height, width, height));
    }

    calculateOffset(entity, width, height);
  }
 /**
  * Create a new BackgroundPainter.
  *
  * @param image image name. The image dimensions should be multiples of 3. The tiles used for
  *     painting will be the image divided uniformly to three in both vertical and horizontal
  *     directions
  */
 public BackgroundPainter(String image) {
   SpriteStore store = SpriteStore.get();
   Sprite mother = store.getSprite(image);
   this.tileWidth = mother.getWidth() / 3;
   this.tileHeight = mother.getHeight() / 3;
   images = new Sprite[9];
   int i = 0;
   for (int y = 0; y < 3 * tileHeight; y += tileHeight) {
     for (int x = 0; x < 3 * tileWidth; x += tileWidth) {
       images[i] = store.getTile(mother, x, y, tileWidth, tileHeight);
       i++;
     }
   }
 }
Exemple #4
0
 /**
  * Create a new ImageEffect.
  *
  * @param view the view where the effect binds itself to
  * @param image name of the image that is used for the the animation
  */
 public ImageEffect(Entity2DView view, String image) {
   this.view = view;
   SpriteStore store = SpriteStore.get();
   /*
    * TODO: get the frame delays from a configuration file. Also the file
    * should specify whether the effect must obey zone coloring.
    */
   Sprite base = store.getSprite(IMAGE_LOCATION + image + ".png");
   int width = base.getWidth();
   int height = base.getHeight();
   int count = width / height;
   Sprite[] frames = store.getTiles(base, 0, 0, count, height, height);
   sequence = new SequenceSprite(this, frames, 100);
   view.attachSprite(sequence, HorizontalAlignment.CENTER, VerticalAlignment.MIDDLE, 0, 0);
 }
  /**
   * Create an <code>AnimatedIcon</code> from a Sprite. Each animation frame will be a rectangle of
   * the same height that the original sprite.
   *
   * @param baseSprite animation frames image
   * @param delay delay between the frames
   */
  AnimatedIcon(Sprite baseSprite, int delay) {
    setOpaque(false);

    int height = baseSprite.getHeight();
    int frames = baseSprite.getWidth() / height;

    this.sprite = new Sprite[frames];
    timer = new Timer(delay, timerTask);

    setBorder(BorderFactory.createEmptyBorder(0, 2, 0, 2));

    final SpriteStore store = SpriteStore.get();

    for (int i = 0; i < frames; i++) {
      sprite[i] = store.getTile(baseSprite, i * height, 0, height, height);
    }
  }
  /**
   * Paint an area with the image pattern.
   *
   * @param g graphics
   * @param width width of the painted area
   * @param height height of the painted area
   */
  public void paint(Graphics g, int width, int height) {
    // Paint the center part. That covers the whole area
    Sprite centerSprite = images[4];
    int centerWidth = centerSprite.getWidth();
    int centerHeight = centerSprite.getHeight();
    for (int y = 0; y < height; y += centerHeight) {
      for (int x = 0; x < width; x += centerWidth) {
        centerSprite.draw(g, x, y);
      }
    }

    // Sides
    // Some needed dimensions (and sprites)
    Sprite rightSprite = images[5];
    int rightWidth = rightSprite.getWidth();
    Sprite leftSprite = images[3];
    int leftWidth = leftSprite.getHeight();
    Sprite topSprite = images[1];
    int topHeight = topSprite.getHeight();
    Sprite bottomSprite = images[7];
    int bottomHeight = bottomSprite.getHeight();

    // Top row.
    for (int x = leftWidth; x < width - rightWidth; x += centerWidth) {
      topSprite.draw(g, x, 0);
    }
    // left side
    for (int y = topHeight; y < height - bottomHeight; y += centerHeight) {
      leftSprite.draw(g, 0, y);
    }
    /*
     * The rest of the sides will not tile properly, but the background
     * pattern is subtle enough that it will not be immediately noticeable.
     */
    // right side
    // Do not draw over the left side, but let the image overflow from the
    // right if there's no space
    int rightX = Math.max(width - rightWidth, leftWidth);
    for (int y = topHeight; y < height - bottomHeight; y += centerHeight) {
      rightSprite.draw(g, rightX, y);
    }
    // bottom
    // Do not draw over the top border, but let the scroll overflow from the
    // bottom if there's no space
    int bottomY = Math.max(height - bottomHeight, topHeight);
    for (int x = centerWidth; x < width - centerWidth; x += centerWidth) {
      bottomSprite.draw(g, x, bottomY);
    }

    // Corners. Again, only the first one will tile properly
    // Top left corner
    Sprite sprite = images[0];
    sprite.draw(g, 0, 0);
    // Top right corner
    sprite = images[2];
    sprite.draw(g, rightX, 0);
    // Bottom left corner
    sprite = images[6];
    sprite.draw(g, 0, bottomY);
    // Bottom right corner
    sprite = images[8];
    sprite.draw(g, rightX, bottomY);
  }