2

Java でタイル ベースのプラットフォーマー ゲームを作成しています。2 次元配列に格納されているマップをレンダリングしますが、この配列が非常に大きいと、ゲームが遅くなり始めます。マップの表示可能な部分のみをレンダリングする必要があることに気付きました。そうしようとしましたが、部分的にしか機能しない非常にハッキーなコードを書いたので、削除しました。どうすればこれを適切に行うことができますか?これが私のコードです(ハックなものはありません)。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;
    }
}

ありがとうございました!

4

2 に答える 2

5

カメラがプレーヤーの中心にあるようです。これを行うには2つの方法があります。最初の方法が好きです。少しきれいです。

1番目: カメラ ビューの境界となる長方形を作成し、マップ x、y がこのビュー内にあるかどうかを確認し、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;
            }
        }
    }

(playerX,playerY)2番目のオプションは、それぞれから画面の中心までの距離を単純に計算し、表示範囲外にあるものをmap[x][y]すべてスキップするmap[x][y]ことです.これはコードが少し醜いので、私は本当にお勧めしません.上記の長方形のオプションは高速です.足りる。

編集: @JasonC それは本当です。たとえば、x 値が確実にビューの外にある場合、それはすべての 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(高価な操作)を設定するのではなく、代わりに単にブロックの画像を描画することを検討することです:

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

交換された

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

プレイヤー画像も同様。

于 2013-08-07T17:01:49.687 に答える
4

Graphics.setClip() を使用して、クリッピング領域を可視領域に設定します。これにより、ほとんどのレンダリング操作がその領域外で有効になるのを防ぎます。

これでは不十分な描画操作の場合 (おそらく、クリッピング領域外のオブジェクトに対して計算や何かを実行することも避けたい場合)、クリッピング四角形に対してオブジェクトの境界をテストし、交差しない場合はオブジェクトをスキップします。

Graphics.setClip()を参照してください。

さらなる最適化は、たとえば、明らかに可視領域外にあるマップ上のブロックの範囲を計算し、それを for ループから除外することで実行できます (ブロックが外にあることがわかっている場合、クリッピング領域に対してブロックをテストしても意味がありません)。すでに)。クリッピング リージョンを取得し、それをマップ インデックス座標に変換すると、マップ内の可視領域がどこにあるかがわかり、マップのそのサブセクションを反復処理できます。

于 2013-08-07T16:38:26.927 に答える