Java(swing)仅绘制屏幕上可见的内容

Question

我正在用 java 制作一个基于图 block 的平台游戏。我渲染一个存储在二维数组中的 map ，但是当这个数组非常大时，我的游戏开始变得缓慢。我意识到我必须只渲染 map 中可见的部分，我尝试这样做，但我编写了非常糟糕的代码，只能部分工作，所以我将其删除。我怎样才能正确地做到这一点？这是我的代码(没有黑客的东西)。另外，我如何使用 System.nanoTime() 而不是 System.currentTimeMillis() ？

package sexy_robot_from_another_dimension;

import java.awt.Color;
import java.awt.Font;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Rectangle;
import java.awt.RenderingHints;
import java.awt.TexturePaint;
import java.awt.image.BufferedImage;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Timer;
import java.util.TimerTask;

import javax.swing.JPanel;

@SuppressWarnings("serial")
public class Game extends JPanel
{
    int playerX = 50;
    int playerY = 50;
    static boolean up = false;
    static boolean down = false;
    static boolean right = false;
    static boolean left = false;
    int playerSpeed = 1;
    String[][] map;
    int blockSize = 20;
    int jumpLoop = 0;
    int maxJumpLoop = 280;
    static BufferedImage block, player;
    int playerWidth = 20;
    int playerHeight = 35;
    int cameraX = 0; 
    int cameraY = 0;
    long nextSecond = System.currentTimeMillis() + 1000;
    int frameInLastSecond = 0;
    int framesInCurrentSecond = 0;

    public Game()
    {
        super();
        try 
        {
            map = load("/maps/map1.txt");
        } 

        catch (IOException e) 
        {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        Timer timer = new Timer();
        TimerTask task = new TimerTask() 
        {
            @Override
            public void run() 
            {

                if(up)
                {               
                    if((!playerIsOnBlock(playerX, playerY).equals("0")) || (!playerIsOnBlock(playerX + (playerWidth - 1), playerY).equals("0")))
                    {
                        timeToJump();
                    }
                }

                if(down)
                {               
                }

                if(right)
                {
                    if((playerIsLeftBlock(playerX, playerY).equals("0")) && (playerIsLeftBlock(playerX, playerY + (playerHeight/2 - 1)).equals("0")) && (playerIsLeftBlock(playerX, playerY + (playerHeight - 1)).equals("0")))
                    {
                        playerX += playerSpeed;
                    }
                }

                if(left)
                {                   
                    if((playerIsRightBlock(playerX, playerY).equals("0")) && (playerIsRightBlock(playerX, playerY + (playerHeight/2 - 1)).equals("0")) && (playerIsRightBlock(playerX, playerY + (playerHeight - 1)).equals("0")))
                    {
                        playerX -= playerSpeed;
                    }
                }

                repaint();
            }
        };
        timer.scheduleAtFixedRate(task, 0, 10);

        Timer timerGrav = new Timer();
        TimerTask taskGrav = new TimerTask() 
        {
            @Override
            public void run() 
            {
                if((playerIsOnBlock(playerX, playerY).equals("0")) && (playerIsOnBlock(playerX + (playerWidth - 1), playerY).equals("0")))
                {
                    playerY += playerSpeed;
                    repaint();
                }
            }
        };
        timerGrav.scheduleAtFixedRate(taskGrav, 0, 6);
    }

    void timeToJump()
    {
        if(jumpLoop == 0)
        {
            jumpLoop = 1;
            Timer timer = new Timer();
            TimerTask task = new TimerTask() 
            {
                @Override
                public void run() 
                {
                    if((playerIsBelowBlock(playerX, playerY).equals("0")) && (playerIsBelowBlock(playerX + (playerWidth - 1), playerY).equals("0")))
                    {               
                        playerY -= playerSpeed;
                        jumpLoop++;
                        repaint();
                    }

                    else
                    {
                        jumpLoop = maxJumpLoop;
                    }

                    if(jumpLoop == maxJumpLoop)
                    {
                        jumpLoop = 0;
                        cancel();
                    }
                }
            };
            timer.scheduleAtFixedRate(task, 0, 3);
        }
    }

    public void paintComponent(Graphics g) 
    {
        super.paintComponent(g);
        Graphics2D g2 = (Graphics2D)g;
        g2.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING, RenderingHints.VALUE_TEXT_ANTIALIAS_ON);
        long currentTime = System.currentTimeMillis();
        if (currentTime > nextSecond) 
        {
            nextSecond += 1000;
            frameInLastSecond = framesInCurrentSecond;
            framesInCurrentSecond = 0;
        }
        framesInCurrentSecond++;

        g.drawString(frameInLastSecond + " fps", 10, 20);
        cameraX = -playerX + getWidth()/2;
        cameraY = -playerY + getHeight()/2;
        g.translate(cameraX, cameraY);
        for (int x = 0; x < map.length; x++) 
        {
            for (int y = 0; y < map[0].length; y++) 
            {
                switch(map[x][y])
                {
                case "0":
                    break;
                case "1":
                    if(block != null)
                    {
                        TexturePaint tp0 = new TexturePaint(block, new Rectangle(0, 0, blockSize, blockSize));
                        g2.setPaint(tp0);
                    }
                    g.fillRect(y*blockSize, x*blockSize, 20, 20);
                    break;
                }
            }
        }
        g.setColor(Color.BLACK);
        if(player != null)
        {
            TexturePaint tp0 = new TexturePaint(player, new Rectangle(playerX, playerY, playerWidth, playerHeight));
            g2.setPaint(tp0);
        }
        g.fillRect(playerX, playerY, playerWidth, playerHeight);
        g.setColor(Color.black);
        g.setFont(new Font("Droid Sans Mono", Font.PLAIN, 12));
        g.drawString("Sexy!", playerX - 5, playerY - 10);
    }

    boolean outOfMap(int x, int y)
    {
        y -= blockSize - 1;
        x -= blockSize - 1;
        if((y/blockSize <= map.length - 2) && (y/blockSize >= 0) && (x/blockSize <= map[0].length-2) && (x/blockSize >= 0))
        {
            return false;
        }
        return true;
    }

    String playerIsOnBlock(int x, int y)
    {
        y += playerHeight;
        if(!outOfMap(x, y))
        {
            if(map[y/blockSize][x/blockSize] != "0")
            {
                return map[y/blockSize][x/blockSize];
            }
        }
        return "0";     
    }

    String playerIsBelowBlock(int x, int y)
    {
        y -= playerSpeed;
        if(!outOfMap(x, y))
        {
            if(map[y/blockSize][x/blockSize] != "0")
            {
                return map[y/blockSize][x/blockSize];
            }
        }
        return "0";     
    }

    String playerIsLeftBlock(int x, int y)
    {
        x += playerWidth;
        if(!outOfMap(x, y))
        {
            if(map[y/blockSize][x/blockSize] != "0")
            {
                return map[y/blockSize][x/blockSize];
            }
        }
        return "0";     
    }

    String playerIsRightBlock(int x, int y)
    {
        x -= playerSpeed;
        if(!outOfMap(x, y))
        {
            if(map[y/blockSize][x/blockSize] != "0")
            {
                return map[y/blockSize][x/blockSize];
            }
        }
        return "0";     
    }


    String[][] load(String file) throws IOException
    {
        BufferedReader br = new BufferedReader(new InputStreamReader(getClass().getResourceAsStream(file)));
        int lines = 1;
        int length = br.readLine().split(" ").length;
        while (br.readLine() != null) lines++;
        br.close();
        br = new BufferedReader(new InputStreamReader(getClass().getResourceAsStream(file)));
        String[][] map = new String[lines][length];
        for (int i = 0; i < lines; i++)
        {
            String line = br.readLine();
            String[] parts = line.split(" ");
            for (int y = 0; y < length; y++)
            {
                map[i][y] = parts[y];
            }
        }
        br.close();
        return map;
    }
}

谢谢!

Answer 1

看来你的相机是以玩家为中心的，那么有两种方法可以做到这一点，我喜欢第一种方法，它更干净一点:

第一个:创建一个限制相机 View 的矩形，并检查 map x,y 是否在此 View 内，仅在 true 时才渲染。

  Rectangle cameraView = new Rectangle(playerX - getWidth() / 2, playerY - getHeight() / 2, getWidth(), getHeight());
    for (int x = 0; x < map.length; x++) {
        for (int y = 0; y < map[0].length; y++) {
            if (!cameraView.contains(x*blockSize, y*blockSize))
                continue;
            switch (map[x][y]) {
            case "0":
                break;
            case "1":
                if (block != null) {
                    TexturePaint tp0 = new TexturePaint(block, new Rectangle(0, 0, blockSize, blockSize));
                    g2.setPaint(tp0);
                }
                g.fillRect(y * blockSize, x * blockSize, 20, 20);
                break;
            }
        }
    }

第二个选项是简单地计算每个map[x][y]到屏幕中心(playerX,playerY)的距离并跳过所有map[x][y] 超出了您的查看范围，这对代码来说有点难看，我真的不推荐这样做，上面的矩形选项应该足够快。

编辑:@JasonC这是真的，我没有考虑到，例如当x值肯定在 View 之外时，它仍然会进入y循环遍历所有y值。我们可以简单地在 x 循环中创建一个虚拟变量并执行以下检查

for (int x = 0; x < map.length; x++) {
  int dummyY = playerY
  if(!cameraView.contains(x,dummyY))
    continue;
    ....
   //rest of code ommitted

您可以做的另一个优化是考虑不设置TexturePaint(昂贵的操作)，而是简单地绘制 block 的图像:

g.fillRect(y * blockSize, x * blockSize, 20, 20);

替换为

g.drawImage(block, y*blockSize, x*blockSize, null);

与玩家图像相同。