Example #1
0
 /**
  * Render a section of the tile map
  *
  * @param x The x location to render at
  * @param y The y location to render at
  * @param sx The x tile location to start rendering
  * @param sy The y tile location to start rendering
  * @param width The width of the section to render (in tiles)
  * @param height The height of the secton to render (in tiles)
  * @param lineByLine True if we should render line by line, i.e. giving us a chance to render
  *     something else between lines (@see {@link #renderedLine(int, int, int)}
  */
 public void render(int x, int y, int sx, int sy, int width, int height, boolean lineByLine) {
   switch (orientation) {
     case ORTHOGONAL:
       for (int ty = 0; ty < height; ty++) {
         for (int i = 0; i < layers.size(); i++) {
           Layer layer = (Layer) layers.get(i);
           layer.render(x, y, sx, sy, width, ty, lineByLine, tileWidth, tileHeight);
         }
       }
       break;
     case ISOMETRIC:
       renderIsometricMap(x, y, sx, sy, width, height, null, lineByLine);
       break;
     default:
       // log error or something
   }
 }
Example #2
0
  /**
   * Load a TilED map
   *
   * @param in The input stream from which to load the map
   * @param tileSetsLocation The location from which we can retrieve tileset images
   * @throws SlickException Indicates a failure to parse the map or find a tileset
   */
  private void load(InputStream in, String tileSetsLocation) throws SlickException {
    tilesLocation = tileSetsLocation;

    try {
      DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
      factory.setValidating(false);
      DocumentBuilder builder = factory.newDocumentBuilder();
      builder.setEntityResolver(
          new EntityResolver() {
            public InputSource resolveEntity(String publicId, String systemId)
                throws SAXException, IOException {
              return new InputSource(new ByteArrayInputStream(new byte[0]));
            }
          });

      Document doc = builder.parse(in);
      Element docElement = doc.getDocumentElement();

      if (docElement.getAttribute("orientation").equals("orthogonal")) {
        orientation = ORTHOGONAL;
      } else {
        orientation = ISOMETRIC;
      }

      width = Integer.parseInt(docElement.getAttribute("width"));
      height = Integer.parseInt(docElement.getAttribute("height"));
      tileWidth = Integer.parseInt(docElement.getAttribute("tilewidth"));
      tileHeight = Integer.parseInt(docElement.getAttribute("tileheight"));

      // now read the map properties
      Element propsElement = (Element) docElement.getElementsByTagName("properties").item(0);
      if (propsElement != null) {
        NodeList properties = propsElement.getElementsByTagName("property");
        if (properties != null) {
          props = new Properties();
          for (int p = 0; p < properties.getLength(); p++) {
            Element propElement = (Element) properties.item(p);

            String name = propElement.getAttribute("name");
            String value = propElement.getAttribute("value");
            props.setProperty(name, value);
          }
        }
      }

      if (loadTileSets) {
        TileSet tileSet = null;
        TileSet lastSet = null;

        NodeList setNodes = docElement.getElementsByTagName("tileset");
        for (int i = 0; i < setNodes.getLength(); i++) {
          Element current = (Element) setNodes.item(i);

          tileSet = new TileSet(this, current, !headless);
          tileSet.index = i;

          if (lastSet != null) {
            lastSet.setLimit(tileSet.firstGID - 1);
          }
          lastSet = tileSet;

          tileSets.add(tileSet);
        }
      }

      NodeList layerNodes = docElement.getElementsByTagName("layer");
      for (int i = 0; i < layerNodes.getLength(); i++) {
        Element current = (Element) layerNodes.item(i);
        Layer layer = new Layer(this, current);
        layer.index = i;
        layers.add(layer);
      }

      // acquire object-groups
      NodeList objectGroupNodes = docElement.getElementsByTagName("objectgroup");

      for (int i = 0; i < objectGroupNodes.getLength(); i++) {
        Element current = (Element) objectGroupNodes.item(i);
        ObjectGroup objectGroup = new ObjectGroup(current, this);
        objectGroup.index = i;

        objectGroups.add(objectGroup);
      }
    } catch (Exception e) {
      Log.error(e);
      throw new SlickException("Failed to parse tilemap", e);
    }
  }
Example #3
0
  /**
   * Render of isometric map renders.
   *
   * @param x The x location to render at
   * @param y The y location to render at
   * @param sx The x tile location to start rendering
   * @param sy The y tile location to start rendering
   * @param width The width of the section to render (in tiles)
   * @param height The height of the section to render (in tiles)
   * @param layer if this is null all layers are rendered, if not only the selected layer is
   *     renderered
   * @param lineByLine True if we should render line by line, i.e. giving us a chance to render
   *     something else between lines (@see {@link #renderedLine(int, int, int)}
   *     <p>TODO: [Isometric map] Render stuff between lines, concept of line differs from ortho
   *     maps
   */
  protected void renderIsometricMap(
      int x, int y, int sx, int sy, int width, int height, Layer layer, boolean lineByLine) {
    ArrayList drawLayers = layers;
    if (layer != null) {
      drawLayers = new ArrayList();
      drawLayers.add(layer);
    }

    int maxCount = width * height;
    int allCount = 0;

    boolean allProcessed = false;

    int initialLineX = x;
    int initialLineY = y;

    int startLineTileX = 0;
    int startLineTileY = 0;
    while (!allProcessed) {

      int currentTileX = startLineTileX;
      int currentTileY = startLineTileY;
      int currentLineX = initialLineX;

      int min = 0;
      if (height > width)
        min =
            (startLineTileY < width - 1)
                ? startLineTileY
                : (width - currentTileX < height) ? width - currentTileX - 1 : width - 1;
      else
        min =
            (startLineTileY < height - 1)
                ? startLineTileY
                : (width - currentTileX < height) ? width - currentTileX - 1 : height - 1;

      for (int burner = 0; burner <= min; currentTileX++, currentTileY--, burner++) {
        for (int layerIdx = 0; layerIdx < drawLayers.size(); layerIdx++) {
          Layer currentLayer = (Layer) drawLayers.get(layerIdx);
          currentLayer.render(
              currentLineX,
              initialLineY,
              currentTileX,
              currentTileY,
              1,
              0,
              lineByLine,
              tileWidth,
              tileHeight);
        }
        currentLineX += tileWidth;

        allCount++;
      }

      if (startLineTileY < (height - 1)) {
        startLineTileY += 1;
        initialLineX -= tileWidth / 2;
        initialLineY += tileHeight / 2;
      } else {
        startLineTileX += 1;
        initialLineX += tileWidth / 2;
        initialLineY += tileHeight / 2;
      }

      if (allCount >= maxCount) allProcessed = true;
    }
  }
Example #4
0
 /**
  * Set the global ID of a tile at specified location in the map
  *
  * @param x The x location of the tile
  * @param y The y location of the tile
  * @param layerIndex The index of the layer to set the new tileid
  * @param tileid The tileid to be set
  */
 public void setTileId(int x, int y, int layerIndex, int tileid) {
   Layer layer = (Layer) layers.get(layerIndex);
   layer.setTileID(x, y, tileid);
 }
Example #5
0
 /**
  * Get the global ID of a tile at specified location in the map
  *
  * @param x The x location of the tile
  * @param y The y location of the tile
  * @param layerIndex The index of the layer to retireve the tile from
  * @return The global ID of the tile
  */
 public int getTileId(int x, int y, int layerIndex) {
   Layer layer = (Layer) layers.get(layerIndex);
   return layer.getTileID(x, y);
 }