2

我目前正在用 Java 试验基于 2D 瓷砖的横向滚动游戏，主要基于 David Brackeen 的“Java 开发游戏”中的代码和示例

目前地图文件的大小为 100x100 瓦片（每个瓦片为 64x64 像素）。我已经将系统配置为仅显示玩家可见的图块。Graphics 系统由 ScreenManager 类管理，该类返回当前 BufferStrategy 的图形对象，如下所示：

ScreenManager.java

private GraphicsDevice device;

...

/**
 * Gets the graphics context for the display. The
 * ScreenManager uses double buffering, so applications must 
 * call update() to show any graphics drawn.
 * <p>
 * The application must dispose of the graphics object.
 */
public Graphics2D getGraphics(){
    Window window = device.getFullScreenWindow();
    if(window != null){
        BufferStrategy strategy = window.getBufferStrategy();
        return (Graphics2D)strategy.getDrawGraphics();
    }
    else{
        return null;
    }
}

在此 ScreenManager 中的图形在游戏循环中传递给 TreeRenderer 的绘制方法之后。

TreeMapRenderer.java

/**
    Draws the specified TileMap.
*/
public void draw(Graphics2D g, TileMap map,
    int screenWidth, int screenHeight, float fr)
{
    Sprite player = map.getPlayer();
    int mapWidth = tilesToPixels(map.getWidth());
    int mapHeight = tilesToPixels(map.getHeight());

    // get the scrolling position of the map
    // based on player's position
    int offsetX = screenWidth / 2 -
        Math.round(player.getX()) - TILE_SIZE;
    offsetX = Math.min(offsetX, 0);
    offsetX = Math.max(offsetX, screenWidth - mapWidth);

    // get the y offset to draw all sprites and tiles
    int offsetY = screenHeight /2 -
            Math.round(player.getY()) - TILE_SIZE;
    offsetY = Math.min(offsetY,0);
    offsetY = Math.max(offsetY, screenHeight - mapHeight);

    // draw the visible tiles
    int firstTileY = pixelsToTiles(-offsetY);
    int lastTileY = firstTileY + pixelsToTiles(screenHeight) +1;

    int firstTileX = pixelsToTiles(-offsetX);
    int lastTileX = firstTileX +
        pixelsToTiles(screenWidth) + 1;

    //HERE IS WHERE THE SYSTEM BOGS dOWN (checking ~280 tiles per iteration)
    for (int y=firstTileY; y<lastTileY; y++) {
        for (int x=firstTileX; x <= lastTileX; x++) {
            if(map.getTile(x, y) != null){
                Image image = map.getTile(x, y).getImage();
                if (image != null) {
                    g.drawImage(image,
                        tilesToPixels(x) + offsetX,
                        tilesToPixels(y) + offsetY,
                        null);
                }
            }
        }
    }

    // draw player
    g.drawImage(player.getImage(),
       Math.round(player.getX()) + offsetX,
       Math.round(player.getY()) + offsetY,
       null);

该算法正确地为 X 和 Y 轴选择正确的 FROM 和 TO 值，从 10000 到 ~285 剔除所需的瓷砖。

我的问题是，即使这样，在渲染瓷砖时，游戏也只能以 8-10 FPS 左右的速度运行。如果我关闭平铺渲染，则系统以 80 FPS 运行（无事可做时易于快速运行）

您对如何加快此过程有任何想法吗？我希望看到至少在 30 FPS 左右的东西才能让它可以玩。

最后，虽然我愿意使用 3rd 方库来做到这一点，但我想在承认失败之前自己尝试实现这个逻辑。

编辑：
这里要求的是关于如何调用Image image = map.getTile(x, y).getImage();工作的额外信息。

这里的地图来自下面的TileMap类

TileMap.java

public class TileMap {

private Tile[][] tiles;
private LinkedList sprites;
private Sprite player;
private GraphicsConfiguration gc;

/**
    Creates a new TileMap with the specified width and
    height (in number of tiles) of the map.
*/
public TileMap(GraphicsConfiguration gc, int width, int height) {
    this.gc = gc;
    tiles = new Tile[width][height];
    overlayer = new Tile[width][height];
    sprites = new LinkedList();
}


/**
    Gets the width of this TileMap (number of tiles across).
*/
public int getWidth() {
    return tiles.length;
}


/**
    Gets the height of this TileMap (number of tiles down).
*/
public int getHeight() {
    return tiles[0].length;
}


/**
    Gets the tile at the specified location. Returns null if
    no tile is at the location or if the location is out of
    bounds.
*/
public Tile getTile(int x, int y) {
    if (x < 0 || x >= getWidth() ||
        y < 0 || y >= getHeight())
    {
        return null;
    }
    else {
        return tiles[x][y];
    }
}


/**
 * Helper method to set a tile. If blocking is not defined than it is set to false.
 * 
 * @param x
 * @param y
 * @param tile
 */
public void setTile(int x, int y,Image tile){
    this.setTile(x,y,tile,false);
}

/**
    Sets the tile at the specified location.
*/
public void setTile(int x, int y, Image tile, boolean blocking) {
    if(tiles[x][y] == null){
        Tile t = new Tile(gc, tile, blocking);
        tiles[x][y] = t;
    }
    else{
        tiles[x][y].addImage(tile);
        tiles[x][y].setBlocking(blocking);
    }
}

...

这里的 Tile 是以下代码的一个实例。本质上，这个类只保存可以通过添加覆盖层来更新的图像，总是使用 gc.createCompatibleImage(w, h, Transparency.TRANSLUCENT); 和一个布尔值来判断它是否会阻止玩家。传入的镜像也是这样创建的。

Tile.java

public class Tile {
private Image image;
private boolean blocking = false;
private GraphicsConfiguration gc;

/**
 * Creates a new Tile to be used with a TileMap
 * @param image The base image for this Tile
 * @param blocking Will this tile allow the user to walk over/through
 */
public Tile(GraphicsConfiguration gc, Image image, boolean blocking){
    this.gc = gc;
    this.image = image;
    this.blocking = blocking;
}

public Tile(GraphicsConfiguration gc, Image image){
    this.gc = gc;
    this.image = image;
    this.blocking = false;
}

/**
Creates a duplicate of this animation. The list of frames
are shared between the two Animations, but each Animation
can be animated independently.
*/
public Object clone() {

    return new Tile(gc, image, blocking);
}

/**
 * Used to add an overlay to the existing tile
 * @param image2 The image to overlay
 */
public void addImage(Image image2){
    BufferedImage base = (BufferedImage)image;
    BufferedImage overlay = (BufferedImage)image2;

    // create the new image, canvas size is the max. of both image sizes
    int w = Math.max(base.getWidth(), overlay.getWidth());
    int h = Math.max(base.getHeight(), overlay.getHeight());
    //BufferedImage combined = new BufferedImage(w, h, BufferedImage.TYPE_INT_ARGB);
    BufferedImage combined = gc.createCompatibleImage(w, h, Transparency.TRANSLUCENT);
    // paint both images, preserving the alpha channels
    Graphics g = combined.getGraphics();
    g.drawImage(image, 0, 0, null);
    g.drawImage(overlay, 0, 0, null);

    this.image = (Image)combined;
}

public boolean isBlocking(){
    return this.blocking;
}

public void setBlocking(boolean blocking){
    this.blocking = blocking;
}

public Image getImage(){
    return this.image;
}

}

4

2 回答 2

1

我会使用像素渲染引擎（谷歌它；D）

基本上你所做的，它有一个巨大的整数数组，对应于你正在绘制的图像。

基本上，每个图块都有一个表示其像素的整数数组。当您渲染该图块时，您将图块数组“复制”（比这稍微复杂一些）到大数组:)

然后，一旦您完成将所有内容渲染到主阵列，您就可以在屏幕上绘制它。

这样，你每次画东西时只处理整数而不是整张图片。这使它更快。

我使用 MrDeathJockey 的（youtube）教程学习了这一点，并将它们与 DesignsbyZephyr（也是 youtube）结合起来。虽然我不推荐使用他的技术（他只使用 4 种颜色和 8 位图形，与 deadJockey 的教程一样，您可以自定义图像的大小，甚至可以拥有多个不同分辨率的精灵表（对字体有用）

然而，我确实使用了一些偏移的东西（让屏幕移动而不是播放器）和 Zephyr 的 InputHandler :)

希望这可以帮助！-Camodude009

于 2013-09-22T18:24:52.430 回答
0

创建透明图像（非半透明），因为半透明图像需要更高的 ram 并且存储在系统内存中而不是标准的 java 堆中。创建半透明图像需要多次本机调用来访问本机系统内存。使用 BufferedImages 而不是 Image。您可以随时将 BufferedImage 转换为 Image。

于 2012-06-02T01:33:47.243 回答