protected void doPerformAction() {
    Map map = editor.getCurrentMap();

    int ret =
        JOptionPane.showConfirmDialog(
            editor.getAppFrame(),
            "Do you wish to merge tile images, and create a new tile set?",
            "Merge Tiles?",
            JOptionPane.YES_NO_CANCEL_OPTION);

    if (ret == JOptionPane.YES_OPTION) {
      TileMergeHelper tmh = new TileMergeHelper(map);
      int len = map.getTotalLayers();
      // TODO: Add a dialog option: "Yes, visible only"
      TileLayer newLayer = tmh.merge(0, len, true);
      map.removeAllLayers();
      map.addLayer(newLayer);
      newLayer.setName("Merged Layer");
      map.addTileset(tmh.getSet());
      editor.setCurrentLayer(0);
    } else if (ret == JOptionPane.NO_OPTION) {
      while (map.getTotalLayers() > 1) {
        map.mergeLayerDown(editor.getCurrentLayerIndex());
      }
      editor.setCurrentLayer(0);
    }
  }
Beispiel #2
0
 /**
  * Unlike mergeOnto, copyTo includes the null tile when merging.
  *
  * @see MapLayer#copyFrom
  * @see MapLayer#mergeOnto
  * @param other the layer to copy this layer to
  */
 @Override
 public void copyTo(MapLayer other) {
   for (int y = bounds.y; y < bounds.y + bounds.height; y++) {
     for (int x = bounds.x; x < bounds.x + bounds.width; x++) {
       ((TileLayer) other).setTileAt(x, y, getTileAt(x, y));
     }
   }
 }
Beispiel #3
0
 @Override
 public void mergeOnto(MapLayer other) {
   for (int y = bounds.y; y < bounds.y + bounds.height; y++) {
     for (int x = bounds.x; x < bounds.x + bounds.width; x++) {
       Tile tile = getTileAt(x, y);
       if (tile != null) {
         ((TileLayer) other).setTileAt(x, y, tile);
       }
     }
   }
 }
Beispiel #4
0
  /**
   * Creates a copy of this layer.
   *
   * @see Object#clone
   * @return a clone of this layer, as complete as possible
   * @exception CloneNotSupportedException
   */
  @Override
  public Object clone() throws CloneNotSupportedException {
    TileLayer clone = (TileLayer) super.clone();

    // Clone the layer data
    clone.map = new Tile[map.length][];
    clone.tileInstanceProperties = new HashMap<Object, Properties>();

    for (int i = 0; i < map.length; i++) {
      clone.map[i] = new Tile[map[i].length];
      System.arraycopy(map[i], 0, clone.map[i], 0, map[i].length);

      for (int j = 0; j < map[i].length; j++) {
        Properties p = getTileInstancePropertiesAt(i, j);

        if (p != null) {
          Integer key = i + j * bounds.width;
          clone.tileInstanceProperties.put(key, (Properties) p.clone());
        }
      }
    }

    return clone;
  }
Beispiel #5
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);
  }
Beispiel #6
0
  /**
   * Writes this layer to an XMLWriter. This should be done <b>after</b> the first global ids for
   * the tilesets are determined, in order for the right gids to be written to the layer data.
   */
  private void writeMapLayer(MapLayer l, XMLWriter w, String wp) throws IOException {
    Rectangle bounds = l.getBounds();

    if (l instanceof ObjectGroup) {
      w.startElement("objectgroup");
    } else {
      w.startElement("layer");
    }

    w.writeAttribute("name", l.getName());
    if (bounds.width != 0) {
      w.writeAttribute("width", bounds.width);
    }
    if (bounds.height != 0) {
      w.writeAttribute("height", bounds.height);
    }
    if (bounds.x != 0) {
      w.writeAttribute("x", bounds.x);
    }
    if (bounds.y != 0) {
      w.writeAttribute("y", bounds.y);
    }

    if (!l.isVisible()) {
      w.writeAttribute("visible", "0");
    }
    if (l.getOpacity() < 1.0f) {
      w.writeAttribute("opacity", l.getOpacity());
    }

    writeProperties(l.getProperties(), w);

    if (l instanceof ObjectGroup) {
      writeObjectGroup((ObjectGroup) l, w, wp);
    } else if (l instanceof TileLayer) {
      final TileLayer tl = (TileLayer) l;
      w.startElement("data");
      if (ENCODE_LAYER_DATA) {
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        OutputStream out;

        w.writeAttribute("encoding", "base64");

        DeflaterOutputStream dos;
        if (COMPRESS_LAYER_DATA) {
          if (Settings.LAYER_COMPRESSION_METHOD_ZLIB.equalsIgnoreCase(
              settings.layerCompressionMethod)) {
            dos = new DeflaterOutputStream(baos);
          } else if (Settings.LAYER_COMPRESSION_METHOD_GZIP.equalsIgnoreCase(
              settings.layerCompressionMethod)) {
            dos = new GZIPOutputStream(baos);
          } else {
            throw new IOException(
                "Unrecognized compression method \""
                    + settings.layerCompressionMethod
                    + "\" for map layer "
                    + l.getName());
          }
          out = dos;
          w.writeAttribute("compression", settings.layerCompressionMethod);
        } else {
          out = baos;
        }

        for (int y = 0; y < l.getHeight(); y++) {
          for (int x = 0; x < l.getWidth(); x++) {
            Tile tile = tl.getTileAt(x + bounds.x, y + bounds.y);
            int gid = 0;

            if (tile != null) {
              gid = getGid(tile);
            }

            out.write(gid & LAST_BYTE);
            out.write(gid >> 8 & LAST_BYTE);
            out.write(gid >> 16 & LAST_BYTE);
            out.write(gid >> 24 & LAST_BYTE);
          }
        }

        if (COMPRESS_LAYER_DATA && dos != null) {
          dos.finish();
        }

        w.writeCDATA(Base64.encodeToString(baos.toByteArray(), true));
      } else {
        for (int y = 0; y < l.getHeight(); y++) {
          for (int x = 0; x < l.getWidth(); x++) {
            Tile tile = tl.getTileAt(x + bounds.x, y + bounds.y);
            int gid = 0;

            if (tile != null) {
              gid = getGid(tile);
            }

            w.startElement("tile");
            w.writeAttribute("gid", gid);
            w.endElement();
          }
        }
      }
      w.endElement();

      boolean tilePropertiesElementStarted = false;

      for (int y = 0; y < l.getHeight(); y++) {
        for (int x = 0; x < l.getWidth(); x++) {
          Properties tip = tl.getTileInstancePropertiesAt(x, y);

          if (tip != null && !tip.isEmpty()) {
            if (!tilePropertiesElementStarted) {
              w.startElement("tileproperties");
              tilePropertiesElementStarted = true;
            }
            w.startElement("tile");

            w.writeAttribute("x", x);
            w.writeAttribute("y", y);

            writeProperties(tip, w);

            w.endElement();
          }
        }
      }

      if (tilePropertiesElementStarted) {
        w.endElement();
      }
    }
    w.endElement();
  }