/**
   * Returns a scaled instance of the tile image. Using a MediaTracker instance, this function waits
   * until the scaling operation is done.
   *
   * <p>Internally it caches the scaled image in order to optimize the common case, where the same
   * scale is requested as the last time.
   *
   * @param zoom the requested zoom level
   * @return Image
   */
  public Image getScaledImage(double zoom) {
    if (zoom == 1.0) {
      return getImage();
    } else if (zoom == myZoom && scaledImage != null) {
      return scaledImage;
    } else {
      Image img = getImage();
      Rectangle bounds = img.getBounds();
      if (img != null) {
        ImageData imageData = img.getImageData();
        if (tileset != null && tileset.getTransparentColor() != null) {
          imageData.transparentPixel = imageData.palette.getPixel(tileset.getTransparentColor());
        }
        scaledImage =
            new Image(
                Display.getDefault(),
                imageData.scaledTo(
                    (int) Math.round(bounds.width * zoom), (int) Math.round(bounds.height * zoom)));

        //                MediaTracker mediaTracker = new MediaTracker(new Canvas());
        //                mediaTracker.addImage(scaledImage, 0);
        //                try {
        //                    mediaTracker.waitForID(0);
        //                }
        //                catch (InterruptedException ie) {
        //                    System.err.println(ie);
        //                }
        //                mediaTracker.removeImage(scaledImage);
        myZoom = zoom;
        return scaledImage;
      }
    }

    return null;
  }
Exemple #2
0
 /**
  * Get the tile set that matches the given global tile id, only to be used when loading a map.
  *
  * @param gid a global tile id
  * @return the tileset containing the tile with the given global tile id, or <code>null</code>
  *     when no such tileset exists
  */
 public TileSet findTileSetForTileGID(int gid) {
   TileSet has = null;
   for (TileSet tileset : tilesets) {
     if (tileset.getFirstGid() <= gid) {
       has = tileset;
     }
   }
   return has;
 }
 /**
  * Sets the parent tileset for a tile. If the tile is already a member of a set, and this method
  * is called with a different set as argument, the tile image is transferred to the new set.
  *
  * @param set
  */
 public void setTileSet(TileSet set) {
   if (tileset != null && tileset != set) {
     setImage(set.addImage(getImage()));
   } else {
     if (internalImage != null) {
       setImage(set.addImage(internalImage));
       internalImage = null;
     }
   }
   tileset = set;
 }
Exemple #4
0
  /**
   * Returns the maximum tile height. This is the height of the highest tile in all tilesets or the
   * tile height used by this map if it's smaller.
   *
   * @return int The maximum tile height
   */
  public int getTileHeightMax() {
    int maxHeight = tileHeight;

    for (TileSet tileset : tilesets) {
      int height = tileset.getTileHeight();
      if (height > maxHeight) {
        maxHeight = height;
      }
    }

    return maxHeight;
  }
Exemple #5
0
  /**
   * Writes a reference to an external tileset into a XML document. In the case where the tileset is
   * not stored in an external file, writes the contents of the tileset instead.
   *
   * @param set the tileset to write a reference to
   * @param w the XML writer to write to
   * @param wp the working directory of the map
   * @throws java.io.IOException
   */
  private void writeTilesetReference(TileSet set, XMLWriter w, String wp) throws IOException {

    String source = set.getSource();

    if (source == null) {
      writeTileset(set, w, wp);
    } else {
      w.startElement("tileset");
      w.writeAttribute("firstgid", getFirstGidForTileset(set));
      w.writeAttribute("source", getRelativePath(wp, source));
      if (set.getBaseDir() != null) {
        w.writeAttribute("basedir", set.getBaseDir());
      }
      w.endElement();
    }
  }
 /**
  * Changes the image of the tile as long as it is not null.
  *
  * @param i the new image of the tile
  */
 public void setImage(Image i) {
   if (tileset != null) {
     tileset.overlayImage(tileImageId, i);
   } else {
     internalImage = i;
   }
 }
 /**
  * Returns the tile image for this Tile.
  *
  * @return Image
  */
 public Image getImage() {
   if (tileset != null) {
     return tileset.getImageById(tileImageId);
   } else {
     return internalImage;
   }
 }
 public int getHeight() {
   if (tileset != null) {
     Point d = tileset.getImageDimensions(tileImageId);
     return d.y;
   } else if (internalImage != null) {
     return internalImage.getBounds().height;
   }
   return 0;
 }
 public int getWidth() {
   if (tileset != null) {
     Point d = tileset.getImageDimensions(tileImageId);
     return d.x;
   } else if (internalImage != null) {
     return internalImage.getBounds().width;
   }
   return 0;
 }
Exemple #10
0
  private void writeMap(Map map, XMLWriter w, String wp) throws IOException {
    w.writeDocType("map", null, "http://mapeditor.org/dtd/1.0/map.dtd");
    w.startElement("map");

    w.writeAttribute("version", "1.0");

    Map.Orientation orientation = map.getOrientation();
    w.writeAttribute("orientation", String.valueOf(orientation));
    w.writeAttribute("width", map.getWidth());
    w.writeAttribute("height", map.getHeight());
    w.writeAttribute("tilewidth", map.getTileWidth());
    w.writeAttribute("tileheight", map.getTileHeight());

    switch (orientation) {
      case HEXAGONAL:
        w.writeAttribute("hexsidelength", map.getHexSideLength());
      case STAGGERED:
        w.writeAttribute("staggeraxis", String.valueOf(map.getStaggerAxis()));
        w.writeAttribute("staggerindex", String.valueOf(map.getStaggerIndex()));
    }

    writeProperties(map.getProperties(), w);

    firstGidPerTileset = new HashMap<>();
    int firstgid = 1;
    for (TileSet tileset : map.getTileSets()) {
      setFirstGidForTileset(tileset, firstgid);
      writeTilesetReference(tileset, w, wp);
      firstgid += tileset.getMaxTileId() + 1;
    }

    for (MapLayer layer : map) {
      writeMapLayer(layer, w, wp);
    }
    firstGidPerTileset = null;

    w.endElement();
  }
Exemple #11
0
  /**
   * Removes a {@link TileSet} from the map, and removes any tiles in the set from the map layers. A
   * {@link MapChangedEvent} is fired when all processing is complete.
   *
   * @param tileset TileSet to remove
   * @throws LayerLockedException when the tileset is in use on a locked layer
   */
  public void removeTileset(TileSet tileset) throws LayerLockedException {
    // Sanity check
    final int tilesetIndex = tilesets.indexOf(tileset);
    if (tilesetIndex == -1) return;

    // Go through the map and remove any instances of the tiles in the set
    Iterator<Object> tileIterator = tileset.iterator();
    while (tileIterator.hasNext()) {
      Tile tile = (Tile) tileIterator.next();
      Iterator<MapLayer> layerIterator = getLayers();
      while (layerIterator.hasNext()) {
        MapLayer ml = (MapLayer) layerIterator.next();
        if (ml instanceof TileLayer) {
          ((TileLayer) ml).removeTile(tile);
        }
      }
    }

    tilesets.remove(tileset);
    fireTilesetRemoved(tilesetIndex);
  }
Exemple #12
0
  /**
   * Adds a Tileset to this Map. If the set is already attached to this map, <code>addTileset</code>
   * simply returns.
   *
   * @param tileset a tileset to add
   */
  public void addTileset(TileSet tileset) {
    if (tileset == null || tilesets.indexOf(tileset) > -1) {
      return;
    }

    Tile t = tileset.getTile(0);

    if (t != null) {
      int tw = t.getWidth();
      int th = t.getHeight();
      if (tw != tileWidth) {
        if (tileWidth == 0) {
          tileWidth = tw;
          tileHeight = th;
        }
      }
    }

    tilesets.add(tileset);
    fireTilesetAdded(tileset);
  }
Exemple #13
0
  private void writeTileset(TileSet set, XMLWriter w, String wp) throws IOException {

    String tileBitmapFile = set.getTilebmpFile();
    String name = set.getName();

    w.startElement("tileset");
    w.writeAttribute("firstgid", getFirstGidForTileset(set));

    if (name != null) {
      w.writeAttribute("name", name);
    }

    if (tileBitmapFile != null) {
      w.writeAttribute("tilewidth", set.getTileWidth());
      w.writeAttribute("tileheight", set.getTileHeight());

      final int tileSpacing = set.getTileSpacing();
      final int tileMargin = set.getTileMargin();
      if (tileSpacing != 0) {
        w.writeAttribute("spacing", tileSpacing);
      }
      if (tileMargin != 0) {
        w.writeAttribute("margin", tileMargin);
      }
    }

    if (set.getBaseDir() != null) {
      w.writeAttribute("basedir", set.getBaseDir());
    }

    if (tileBitmapFile != null) {
      w.startElement("image");
      w.writeAttribute("source", getRelativePath(wp, tileBitmapFile));

      Color trans = set.getTransparentColor();
      if (trans != null) {
        w.writeAttribute("trans", Integer.toHexString(trans.getRGB()).substring(2));
      }
      w.endElement();

      // Write tile properties when necessary.
      for (Tile tile : set) {
        // todo: move the null check back into the iterator?
        if (tile != null && !tile.getProperties().isEmpty()) {
          w.startElement("tile");
          w.writeAttribute("id", tile.getId());
          writeProperties(tile.getProperties(), w);
          w.endElement();
        }
      }
    } else {
      // Check to see if there is a need to write tile elements
      boolean needWrite = false;

      // As long as one has properties, they all need to be written.
      // TODO: This shouldn't be necessary
      for (Tile tile : set) {
        if (!tile.getProperties().isEmpty() || tile.getSource() != null) {
          needWrite = true;
          break;
        }
      }

      if (needWrite) {
        w.writeAttribute("tilewidth", set.getTileWidth());
        w.writeAttribute("tileheight", set.getTileHeight());
        w.writeAttribute("tilecount", set.size());
        w.writeAttribute("columns", set.getTilesPerRow());

        for (Tile tile : set) {
          // todo: move this check back into the iterator?
          if (tile != null) {
            writeTile(tile, w, wp);
          }
        }
      }
    }
    w.endElement();
  }
 /**
  * Returns the global tile id by adding the tile id to the map-assigned.
  *
  * @return id
  */
 public int getGid() {
   if (tileset != null) {
     return id + tileset.getFirstGid();
   }
   return id;
 }