Java Tile.getType方法代码示例

import net.sf.freecol.common.model.Tile; //导入方法依赖的package包/类
/**
 * Create a {@code BufferedImage} and draw a {@code Tile} on it.
 * Draws the terrain and improvements.
 *
 * @param tile The Tile to draw.
 * @return The image.
 */
BufferedImage createTileImageWithBeachBorderAndItems(Tile tile) {
    if (!tile.isExplored())
        return lib.getTerrainImage(null, tile.getX(), tile.getY());
    final TileType tileType = tile.getType();
    Dimension terrainTileSize = lib.tileSize;
    BufferedImage overlayImage = lib.getOverlayImage(tile);
    final int compoundHeight = (overlayImage != null)
        ? overlayImage.getHeight()
        : tileType.isForested()
            ? lib.tileForestSize.height
            : terrainTileSize.height;
    BufferedImage image = new BufferedImage(
        terrainTileSize.width, compoundHeight, BufferedImage.TYPE_INT_ARGB);
    Graphics2D g = image.createGraphics();
    g.translate(0, compoundHeight - terrainTileSize.height);
    displayTileWithBeachAndBorder(g, tile);
    displayTileItems(g, tile, null, overlayImage);
    g.dispose();
    return image;
}
 

import net.sf.freecol.common.model.Tile; //导入方法依赖的package包/类
/**
 * Create a {@code BufferedImage} and draw a {@code Tile} on it.
 *
 * @param tile The {@code Tile} to draw.
 * @return The image.
 */
BufferedImage createTileImage(Tile tile) {
    final TileType tileType = tile.getType();
    Dimension terrainTileSize = lib.tileSize;
    BufferedImage overlayImage = lib.getOverlayImage(tile);
    final int compoundHeight = (overlayImage != null)
        ? overlayImage.getHeight()
        : tileType.isForested()
            ? lib.tileForestSize.height
            : terrainTileSize.height;
    BufferedImage image = new BufferedImage(
        terrainTileSize.width, compoundHeight, BufferedImage.TYPE_INT_ARGB);
    Graphics2D g = image.createGraphics();
    g.translate(0, compoundHeight - terrainTileSize.height);
    displayTile(g, tile, overlayImage);
    g.dispose();
    return image;
}
 

import net.sf.freecol.common.model.Tile; //导入方法依赖的package包/类
/**
 * Create a {@code BufferedImage} and draw a {@code Tile} on it.
 * The visualization of the {@code Tile} also includes information
 * from the corresponding {@code ColonyTile} of the given
 * {@code Colony}.
 *
 * @param tile The {@code Tile} to draw.
 * @param colony The {@code Colony} to create the visualization
 *      of the {@code Tile} for. This object is also used to
 *      get the {@code ColonyTile} for the given {@code Tile}.
 * @return The image.
 */
BufferedImage createColonyTileImage(Tile tile, Colony colony) {
    final TileType tileType = tile.getType();
    Dimension terrainTileSize = lib.tileSize;
    BufferedImage overlayImage = lib.getOverlayImage(tile);
    final int compoundHeight = (overlayImage != null)
        ? overlayImage.getHeight()
        : tileType.isForested()
            ? lib.tileForestSize.height
            : terrainTileSize.height;
    BufferedImage image = new BufferedImage(
        terrainTileSize.width, compoundHeight, BufferedImage.TYPE_INT_ARGB);
    Graphics2D g = image.createGraphics();
    g.translate(0, compoundHeight - terrainTileSize.height);
    displayColonyTile(g, tile, colony, overlayImage);
    g.dispose();
    return image;
}
 

import net.sf.freecol.common.model.Tile; //导入方法依赖的package包/类
/**
 * Pick a good tile to put elevated terrain on.
 *
 * @param map A {@code Map} to choose from.
 * @return A suitable {@code Tile}, or null if none found.
 */
private Tile getGoodMountainTile(Map map) {
    final Specification spec = map.getGame().getSpecification();
    final TileType hills = spec.getTileType("model.tile.hills");
    final TileType mountains = spec.getTileType("model.tile.mountains");
    Tile tile = null;
    while ((tile = map.getRandomLandTile(random)) != null) {
        // Can not be high ground already
        if (tile.getType() != hills && tile.getType() != mountains
            
            // Not too close to a mountain range as this would
            // defeat the purpose of adding random hills
            && none(tile.getSurroundingTiles(1, 3), t -> t.getType() == mountains)

            // Do not add hills too close to the ocean/lake, as
            // this helps with good locations for building
            // colonies on shore.
            && none(tile.getSurroundingTiles(1, 1), t -> !t.isLand())) {
            return tile;
        }
    }
    return null;
}
 

import net.sf.freecol.common.model.Tile; //导入方法依赖的package包/类
/**
 * Displays the given Tile onto the given Graphics2D object at the
 * location specified by the coordinates. Only base terrain will be drawn.
 *
 * @param g The Graphics2D object on which to draw the Tile.
 * @param tile The Tile to draw.
 */
void displayTileWithBeachAndBorder(Graphics2D g, Tile tile) {
    if (tile != null) {
        TileType tileType = tile.getType();
        int x = tile.getX();
        int y = tile.getY();
        // ATTENTION: we assume that all base tiles have the same size
        g.drawImage(lib.getTerrainImage(tileType, x, y),
                    0, 0, null);
        if (tile.isExplored()) {
            if (!tile.isLand() && tile.getStyle() > 0) {
                int edgeStyle = tile.getStyle() >> 4;
                if (edgeStyle > 0) {
                    g.drawImage(lib.getBeachEdgeImage(edgeStyle, x, y),
                                0, 0, null);
                }
                int cornerStyle = tile.getStyle() & 15;
                if (cornerStyle > 0) {
                    g.drawImage(lib.getBeachCornerImage(cornerStyle, x, y),
                                0, 0, null);
                }
            }

            List<SortableImage> imageBorders = new ArrayList<>(8);
            SortableImage si;
            for (Direction direction : Direction.values()) {
                Tile borderingTile = tile.getNeighbourOrNull(direction);
                if (borderingTile != null && borderingTile.isExplored()) {
                    TileType borderingTileType = borderingTile.getType();
                    if (borderingTileType != tileType) {
                        if (!tile.isLand() && borderingTile.isLand()) {
                            // If there is a Coast image (eg. beach) defined, use it, otherwise skip
                            // Draw the grass from the neighboring tile, spilling over on the side of this tile
                            si = new SortableImage(
                                lib.getBorderImage(borderingTileType, direction, x, y),
                                borderingTileType.getIndex());
                            imageBorders.add(si);
                            TileImprovement river = borderingTile.getRiver();
                            if (river != null) {
                                int magnitude = river.getRiverConnection(
                                    direction.getReverseDirection());
                                if (magnitude > 0) {
                                    si = new SortableImage(
                                        lib.getRiverMouthImage(direction,
                                            magnitude, x, y),
                                        -1);
                                    imageBorders.add(si);
                                }
                            }
                        } else if (!tile.isLand() || borderingTile.isLand()) {
                            if (borderingTileType.getIndex() < tileType.getIndex() &&
                                    !lib.getTerrainImage(tileType, 0, 0).equals(lib.getTerrainImage(borderingTileType, 0, 0))) {
                                // Draw land terrain with bordering land type, or ocean/high seas limit,
                                // if the tiles do not share same graphics (ocean & great river)
                                si = new SortableImage(
                                        lib.getBorderImage(borderingTileType, direction, x, y),
                                        borderingTileType.getIndex());
                                imageBorders.add(si);
                            }
                        }
                    }
                }
            }
            for (SortableImage sorted : sort(imageBorders)) {
                g.drawImage(sorted.image, 0, 0, null);
            }
        }
    }
}